commit 39a086b41b7d7f15460cdd8ab2d300ae48855f18
Author: wehub-resource-sync <resource-sync@wehub.local>
Date:   Mon Jul 13 13:08:08 2026 +0800

    chore: import upstream snapshot with attribution

diff --git a/.condarc b/.condarc
new file mode 100644
index 0000000..4883d18
--- /dev/null
+++ b/.condarc
@@ -0,0 +1,10 @@
+channels:
+  - defaults
+show_channel_urls: true
+default_channels:
+  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
+  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
+  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
+custom_channels:
+  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
+  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..7b7c5a9
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: YaoFANGUK
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/.github/workflows/build-windows-cpu.yml b/.github/workflows/build-windows-cpu.yml
new file mode 100644
index 0000000..f8e285f
--- /dev/null
+++ b/.github/workflows/build-windows-cpu.yml
@@ -0,0 +1,92 @@
+name: Build Windows CPU
+
+on: 
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+    inputs:
+      ssh:
+        description: 'SSH connection to Actions'
+        required: false
+        default: false
+
+
+jobs:
+  build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v4
+    - name: 读取 VERSION
+      id: version
+      run: |
+        VERSION=$(sed -n 's/^VERSION = "\(.*\)"/\1/p' backend/config.py)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      shell: bash
+    # - name: 检查 tag 是否已存在
+    #   run: |
+    #     TAG_NAME="${VERSION}"
+    #     if git ls-remote --tags origin | grep -q "refs/tags/$TAG_NAME"; then
+    #       echo "Tag $TAG_NAME 已存在，发布中止"
+    #       exit 1
+    #     fi
+    #   shell: bash
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip' # caching pip dependencies
+    - run: pip install paddlepaddle==3.0.0
+    - run: pip install -r requirements.txt
+    - run: pip freeze > requirements.txt
+    - run: pip install QPT==1.0b8 setuptools
+    - name: 获取 site-packages 路径
+      shell: bash
+      run: |
+        SITE_PACKAGES=$(python -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'Lib', 'site-packages'))")
+        SITE_PACKAGES_UNIX=$(cygpath -u "$SITE_PACKAGES")
+        echo "site-packages路径: $SITE_PACKAGES"
+        echo "site-packages UNIX路径: $SITE_PACKAGES_UNIX"
+        echo "SITE_PACKAGES_UNIX=$SITE_PACKAGES_UNIX" >> $GITHUB_ENV
+        echo "SITE_PACKAGES=$SITE_PACKAGES" >> $GITHUB_ENV
+    - name: 修复QPT内部错误
+      run: sed -i '98c\        try:\n            dep = pkg.requires()\n        except TypeError:\n            continue' ${SITE_PACKAGES_UNIX}/qpt/kernel/qpackage.py
+      shell: bash
+    - name: Start SSH via tmate
+      if: (github.event.inputs.ssh == 'true' && github.event.inputs.ssh  != 'false') || contains(github.event.action, 'ssh')
+      uses: mxschmitt/action-tmate@v3
+    - run: |
+        python backend/tools/makedist.py && \
+        mv ../vse_out ./vse_out && \
+        cp ./vse_out/Debug/Debug-进入虚拟环境.cmd ./vse_out/Release/
+      env:
+        QPT_Action: "True"
+      shell: bash
+    - name: 上传 Debug 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-cpu-debug
+        path: vse_out/Debug/
+    - name: 上传 Release 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-cpu-release
+        path: vse_out/Release/
+    - name: 打包 Release 文件夹
+      run: |
+        cd vse_out/Release
+        7z a -t7z -mx=9 -m0=LZMA2 -ms=on -mfb=64 -md=32m -mmt=on -v1888m vse-v${{ env.VERSION }}-windows-cpu.7z * && \
+        # 检测是否只有一个分卷
+        if [ -f vse-v${{ env.VERSION }}-windows-cpu.7z.001 ] && [ ! -f vse-v${{ env.VERSION }}-windows-cpu.7z.002 ]; then \
+          mv vse-v${{ env.VERSION }}-windows-cpu.7z.001 vse-v${{ env.VERSION }}-windows-cpu.7z; fi
+      shell: bash
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      with:
+        prerelease: true
+        tag_name: ${{ env.VERSION }}
+        target_commitish: ${{ github.sha }}
+        name: 硬字幕提取器 ${{ env.VERSION }}
+        files: |
+          vse_out/Release/vse-v${{ env.VERSION }}-windows-cpu.7z*
+    
\ No newline at end of file
diff --git a/.github/workflows/build-windows-cuda-10.2.yml b/.github/workflows/build-windows-cuda-10.2.yml
new file mode 100644
index 0000000..30596f8
--- /dev/null
+++ b/.github/workflows/build-windows-cuda-10.2.yml
@@ -0,0 +1,123 @@
+name: Build Windows CUDA 10.2
+
+on: 
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+    inputs:
+      ssh:
+        description: 'SSH connection to Actions'
+        required: false
+        default: false
+
+
+jobs:
+  build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v4
+    - name: 读取 VERSION
+      id: version
+      run: |
+        VERSION=$(sed -n 's/^VERSION = "\(.*\)"/\1/p' backend/config.py)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      shell: bash
+    # - name: 检查 tag 是否已存在
+    #   run: |
+    #     TAG_NAME="${VERSION}"
+    #     if git ls-remote --tags origin | grep -q "refs/tags/$TAG_NAME"; then
+    #       echo "Tag $TAG_NAME 已存在，发布中止"
+    #       exit 1
+    #     fi
+    #   shell: bash
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: 'pip' # caching pip dependencies
+    - name: 部署 CUDA
+      uses: Jimver/cuda-toolkit@v0.2.21
+      id: cuda-toolkit
+      with:
+        cuda: '10.2.89'
+    - run: echo "Installed cuda version is ${{steps.cuda-toolkit.outputs.cuda}}"
+    - run: echo "Cuda install location ${{steps.cuda-toolkit.outputs.CUDA_PATH}}"
+    - run: nvcc -V
+    - run: git clean -df
+    # 最后一个支持10.2版本的Paddle
+    # https://www.paddlepaddle.org.cn/documentation/docs/en/2.5/install/Tables_en.html
+    - run: python -m pip install paddlepaddle-gpu==2.5.2.post102 -f https://www.paddlepaddle.org.cn/whl/windows/mkl/avx/stable.html
+    - run: sed -i 's/numpy==.*/numpy==1.26.4/g' requirements.txt
+      shell: bash
+    - run: pip install -r requirements.txt
+    - run: |
+        mv -fv requirements.txt requirements.txt.bak && \
+        pip freeze > requirements.txt
+      shell: bash
+    - run: pip install QPT==1.0b8 setuptools
+    - name: 获取 site-packages 路径
+      shell: bash
+      run: |
+        SITE_PACKAGES=$(python -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'Lib', 'site-packages'))")
+        SITE_PACKAGES_UNIX=$(cygpath -u "$SITE_PACKAGES")
+        echo "site-packages路径: $SITE_PACKAGES"
+        echo "site-packages UNIX路径: $SITE_PACKAGES_UNIX"
+        echo "SITE_PACKAGES_UNIX=$SITE_PACKAGES_UNIX" >> $GITHUB_ENV
+        echo "SITE_PACKAGES=$SITE_PACKAGES" >> $GITHUB_ENV
+    - name: 修复QPT内部错误
+      run: sed -i '98c\        try:\n            dep = pkg.requires()\n        except TypeError:\n            continue' ${SITE_PACKAGES_UNIX}/qpt/kernel/qpackage.py
+      shell: bash
+    - name: Start SSH via tmate
+      if: (github.event.inputs.ssh == 'true' && github.event.inputs.ssh  != 'false') || contains(github.event.action, 'ssh')
+      uses: mxschmitt/action-tmate@v3
+    - run: |
+        python backend/tools/makedist.py --cuda=10.2 && \
+        mv ../vse_out ./vse_out && \
+        cp ./vse_out/Debug/Debug-进入虚拟环境.cmd ./vse_out/Release/
+        mv -fv requirements.txt.bak requirements.txt && \
+        pip download -d ./vse_out/Debug/opt/packages/ -r requirements.txt && \
+        # for paddlepaddle-gpu < 3.0.0
+        pip download -d./vse_out/Release/opt/packages/ numpy==1.26.4 && \
+        cp -rfv ./vse_out/Debug/opt/packages/* ./vse_out/Release/opt/packages/ && \
+        rm -fv ./vse_out/*/opt/packages/numpy-2* && \
+        rm -fv ./vse_out/*/opt/packages/paddlepaddle-* && \
+        rm -fv ./vse_out/*/opt/PaddlePaddlePackage/001-* 
+      env:
+        QPT_Action: "True"
+        CUDA_PATH_V10_2: "${{steps.cuda-toolkit.outputs.CUDA_PATH}}"
+      shell: bash
+    - name: 部署 CUDNN
+      shell: bash
+      run: |
+        curl -L -o cudnn.zip "https://developer.download.nvidia.cn/compute/redist/cudnn/v7.6.5/cudnn-10.2-windows10-x64-v7.6.5.32.zip" && \
+        unzip -j cudnn.zip "*/bin/*" -d "./vse_out/Debug/opt/CUDA/" && \
+        unzip -j cudnn.zip "*/bin/*" -d "./vse_out/Release/opt/CUDA/" && \
+        rm -fv cudnn.zip
+    - name: 上传 Debug 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2-debug
+        path: vse_out/Debug/
+    - name: 上传 Release 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2-release
+        path: vse_out/Release/
+    - name: 打包 Release 文件夹
+      run: |
+        cd vse_out/Release
+        7z a -t7z -mx=9 -m0=LZMA2 -ms=on -mfb=64 -md=32m -mmt=on -v1888m vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2.7z * && \
+        # 检测是否只有一个分卷
+        if [ -f vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2.7z.001 ] && [ ! -f vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2.7z.002 ]; then \
+          mv vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2.7z.001 vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2.7z; fi
+      shell: bash
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      with:
+        prerelease: true
+        tag_name: ${{ env.VERSION }}
+        target_commitish: ${{ github.sha }}
+        name: 硬字幕提取器 v${{ env.VERSION }}
+        files: |
+          vse_out/Release/vse-v${{ env.VERSION }}-windows-nvidia-cuda-10.2.7z*
\ No newline at end of file
diff --git a/.github/workflows/build-windows-cuda-11.8.yml b/.github/workflows/build-windows-cuda-11.8.yml
new file mode 100644
index 0000000..caf039d
--- /dev/null
+++ b/.github/workflows/build-windows-cuda-11.8.yml
@@ -0,0 +1,96 @@
+name: Build Windows CUDA 11.8
+
+on: 
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+    inputs:
+      ssh:
+        description: 'SSH connection to Actions'
+        required: false
+        default: false
+
+
+jobs:
+  build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v4
+    - name: 读取 VERSION
+      id: version
+      run: |
+        VERSION=$(sed -n 's/^VERSION = "\(.*\)"/\1/p' backend/config.py)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      shell: bash
+    # - name: 检查 tag 是否已存在
+    #   run: |
+    #     TAG_NAME="${VERSION}"
+    #     if git ls-remote --tags origin | grep -q "refs/tags/$TAG_NAME"; then
+    #       echo "Tag $TAG_NAME 已存在，发布中止"
+    #       exit 1
+    #     fi
+    #   shell: bash
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip' # caching pip dependencies
+    - run: pip install paddlepaddle-gpu==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cu118/
+    - run: pip install -r requirements.txt
+    - run: pip freeze > requirements.txt
+    - run: pip install QPT==1.0b8 setuptools
+    - name: 获取 site-packages 路径
+      shell: bash
+      run: |
+        SITE_PACKAGES=$(python -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'Lib', 'site-packages'))")
+        SITE_PACKAGES_UNIX=$(cygpath -u "$SITE_PACKAGES")
+        echo "site-packages路径: $SITE_PACKAGES"
+        echo "site-packages UNIX路径: $SITE_PACKAGES_UNIX"
+        echo "SITE_PACKAGES_UNIX=$SITE_PACKAGES_UNIX" >> $GITHUB_ENV
+        echo "SITE_PACKAGES=$SITE_PACKAGES" >> $GITHUB_ENV
+    - name: 修复QPT内部错误
+      run: sed -i '98c\        try:\n            dep = pkg.requires()\n        except TypeError:\n            continue' ${SITE_PACKAGES_UNIX}/qpt/kernel/qpackage.py
+      shell: bash
+    - name: Start SSH via tmate
+      if: (github.event.inputs.ssh == 'true' && github.event.inputs.ssh  != 'false') || contains(github.event.action, 'ssh')
+      uses: mxschmitt/action-tmate@v3
+    - run: |
+        python backend/tools/makedist.py --cuda=11.8 && \
+        mv ../vse_out ./vse_out && \
+        cp ./vse_out/Debug/Debug-进入虚拟环境.cmd ./vse_out/Release/
+        git checkout requirements.txt && \
+        pip download -d ./vse_out/Debug/opt/packages/ -r requirements.txt && \
+        cp -rfv ./vse_out/Debug/opt/packages/* ./vse_out/Release/opt/packages/ && \
+        rm -fv ./vse_out/*/opt/packages/paddlepaddle-* && \
+        rm -fv ./vse_out/*/opt/PaddlePaddlePackage/001-* 
+      env:
+        QPT_Action: "True"
+      shell: bash
+    - name: 上传 Debug 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8-debug
+        path: vse_out/Debug/
+    - name: 上传 Release 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8-release
+        path: vse_out/Release/
+    - name: 打包 Release 文件夹
+      run: |
+        cd vse_out/Release
+        7z a -t7z -mx=9 -m0=LZMA2 -ms=on -mfb=64 -md=32m -mmt=on -v1888m vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8.7z * && \
+        # 检测是否只有一个分卷
+        if [ -f vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8.7z.001 ] && [ ! -f vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8.7z.002 ]; then \
+          mv vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8.7z.001 vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8.7z; fi
+      shell: bash
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      with:
+        prerelease: true
+        tag_name: ${{ env.VERSION }}
+        target_commitish: ${{ github.sha }}
+        name: 硬字幕提取器 v${{ env.VERSION }}
+        files: |
+          vse_out/Release/vse-v${{ env.VERSION }}-windows-nvidia-cuda-11.8.7z*
\ No newline at end of file
diff --git a/.github/workflows/build-windows-cuda-12.6.yml b/.github/workflows/build-windows-cuda-12.6.yml
new file mode 100644
index 0000000..78895f7
--- /dev/null
+++ b/.github/workflows/build-windows-cuda-12.6.yml
@@ -0,0 +1,96 @@
+name: Build Windows CUDA 12.6
+
+on: 
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+    inputs:
+      ssh:
+        description: 'SSH connection to Actions'
+        required: false
+        default: false
+
+
+jobs:
+  build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v4
+    - name: 读取 VERSION
+      id: version
+      run: |
+        VERSION=$(sed -n 's/^VERSION = "\(.*\)"/\1/p' backend/config.py)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      shell: bash
+    # - name: 检查 tag 是否已存在
+    #   run: |
+    #     TAG_NAME="${VERSION}"
+    #     if git ls-remote --tags origin | grep -q "refs/tags/$TAG_NAME"; then
+    #       echo "Tag $TAG_NAME 已存在，发布中止"
+    #       exit 1
+    #     fi
+    #   shell: bash
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip' # caching pip dependencies
+    - run: pip install paddlepaddle-gpu==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cu126/
+    - run: pip install -r requirements.txt
+    - run: pip freeze > requirements.txt
+    - run: pip install QPT==1.0b8 setuptools
+    - name: 获取 site-packages 路径
+      shell: bash
+      run: |
+        SITE_PACKAGES=$(python -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'Lib', 'site-packages'))")
+        SITE_PACKAGES_UNIX=$(cygpath -u "$SITE_PACKAGES")
+        echo "site-packages路径: $SITE_PACKAGES"
+        echo "site-packages UNIX路径: $SITE_PACKAGES_UNIX"
+        echo "SITE_PACKAGES_UNIX=$SITE_PACKAGES_UNIX" >> $GITHUB_ENV
+        echo "SITE_PACKAGES=$SITE_PACKAGES" >> $GITHUB_ENV
+    - name: 修复QPT内部错误
+      run: sed -i '98c\        try:\n            dep = pkg.requires()\n        except TypeError:\n            continue' ${SITE_PACKAGES_UNIX}/qpt/kernel/qpackage.py
+      shell: bash
+    - name: Start SSH via tmate
+      if: (github.event.inputs.ssh == 'true' && github.event.inputs.ssh  != 'false') || contains(github.event.action, 'ssh')
+      uses: mxschmitt/action-tmate@v3
+    - run: |
+        python backend/tools/makedist.py --cuda=12.6 && \
+        mv ../vse_out ./vse_out && \
+        cp ./vse_out/Debug/Debug-进入虚拟环境.cmd ./vse_out/Release/
+        git checkout requirements.txt && \
+        pip download -d ./vse_out/Debug/opt/packages/ -r requirements.txt && \
+        cp -rfv ./vse_out/Debug/opt/packages/* ./vse_out/Release/opt/packages/ && \
+        rm -fv ./vse_out/*/opt/packages/paddlepaddle-* && \
+        rm -fv ./vse_out/*/opt/PaddlePaddlePackage/001-* 
+      env:
+        QPT_Action: "True"
+      shell: bash
+    - name: 上传 Debug 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6-debug
+        path: vse_out/Debug/
+    - name: 上传 Release 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6-release
+        path: vse_out/Release/
+    - name: 打包 Release 文件夹
+      run: |
+        cd vse_out/Release
+        7z a -t7z -mx=9 -m0=LZMA2 -ms=on -mfb=64 -md=32m -mmt=on -v1888m vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6.7z * && \
+        # 检测是否只有一个分卷
+        if [ -f vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6.7z.001 ] && [ ! -f vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6.7z.002 ]; then \
+          mv vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6.7z.001 vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6.7z; fi
+      shell: bash
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      with:
+        prerelease: true
+        tag_name: ${{ env.VERSION }}
+        target_commitish: ${{ github.sha }}
+        name: 硬字幕提取器 v${{ env.VERSION }}
+        files: |
+          vse_out/Release/vse-v${{ env.VERSION }}-windows-nvidia-cuda-12.6.7z*
\ No newline at end of file
diff --git a/.github/workflows/build-windows-directml.yml b/.github/workflows/build-windows-directml.yml
new file mode 100644
index 0000000..5156626
--- /dev/null
+++ b/.github/workflows/build-windows-directml.yml
@@ -0,0 +1,93 @@
+name: Build Windows DirectML
+
+on: 
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+    inputs:
+      ssh:
+        description: 'SSH connection to Actions'
+        required: false
+        default: false
+
+
+jobs:
+  build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v4
+    - name: 读取 VERSION
+      id: version
+      run: |
+        VERSION=$(sed -n 's/^VERSION = "\(.*\)"/\1/p' backend/config.py)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      shell: bash
+    # - name: 检查 tag 是否已存在
+    #   run: |
+    #     TAG_NAME="${VERSION}"
+    #     if git ls-remote --tags origin | grep -q "refs/tags/$TAG_NAME"; then
+    #       echo "Tag $TAG_NAME 已存在，发布中止"
+    #       exit 1
+    #     fi
+    #   shell: bash
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip' # caching pip dependencies
+    - run: pip install paddlepaddle==3.0.0
+    - run: pip install -r requirements.txt
+    - run: pip install -r requirements_directml.txt
+    - run: pip freeze > requirements.txt
+    - run: pip install QPT==1.0b8 setuptools
+    - name: 获取 site-packages 路径
+      shell: bash
+      run: |
+        SITE_PACKAGES=$(python -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'Lib', 'site-packages'))")
+        SITE_PACKAGES_UNIX=$(cygpath -u "$SITE_PACKAGES")
+        echo "site-packages路径: $SITE_PACKAGES"
+        echo "site-packages UNIX路径: $SITE_PACKAGES_UNIX"
+        echo "SITE_PACKAGES_UNIX=$SITE_PACKAGES_UNIX" >> $GITHUB_ENV
+        echo "SITE_PACKAGES=$SITE_PACKAGES" >> $GITHUB_ENV
+    - name: 修复QPT内部错误
+      run: sed -i '98c\        try:\n            dep = pkg.requires()\n        except TypeError:\n            continue' ${SITE_PACKAGES_UNIX}/qpt/kernel/qpackage.py
+      shell: bash
+    - name: Start SSH via tmate
+      if: (github.event.inputs.ssh == 'true' && github.event.inputs.ssh  != 'false') || contains(github.event.action, 'ssh')
+      uses: mxschmitt/action-tmate@v3
+    - run: |
+        python backend/tools/makedist.py && \
+        mv ../vse_out ./vse_out && \
+        cp ./vse_out/Debug/Debug-进入虚拟环境.cmd ./vse_out/Release/
+      env:
+        QPT_Action: "True"
+      shell: bash
+    - name: 上传 Debug 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-directml-debug
+        path: vse_out/Debug/
+    - name: 上传 Release 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vse-v${{ env.VERSION }}-windows-directml-release
+        path: vse_out/Release/
+    - name: 打包 Release 文件夹
+      run: |
+        cd vse_out/Release
+        7z a -t7z -mx=9 -m0=LZMA2 -ms=on -mfb=64 -md=32m -mmt=on -v1888m vse-v${{ env.VERSION }}-windows-directml.7z * && \
+        # 检测是否只有一个分卷
+        if [ -f vse-v${{ env.VERSION }}-windows-directml.7z.001 ] && [ ! -f vse-v${{ env.VERSION }}-windows-directml.7z.002 ]; then \
+          mv vse-v${{ env.VERSION }}-windows-directml.7z.001 vse-v${{ env.VERSION }}-windows-directml.7z; fi
+      shell: bash
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      with:
+        prerelease: true
+        tag_name: ${{ env.VERSION }}
+        target_commitish: ${{ github.sha }}
+        name: 硬字幕提取器 v${{ env.VERSION }}
+        files: |
+          vse_out/Release/vse-v${{ env.VERSION }}-windows-directml.7z*
+    
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..43d4c57
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,367 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/intellij+all,python,pycharm+all,macos,windows
+# Edit at https://www.toptal.com/developers/gitignore?templates=intellij+all,python,pycharm+all,macos,windows
+
+### Intellij+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Intellij+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+.idea/
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### PyCharm+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+
+# Generated files
+
+# Sensitive or high-churn files
+
+# Gradle
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+
+# Mongo Explorer plugin
+
+# File-based project format
+
+# IntelliJ
+
+# mpeltonen/sbt-idea plugin
+
+# JIRA plugin
+
+# Cursive Clojure plugin
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+
+# Editor-based Rest Client
+
+# Android studio 3.1+ serialized cache file
+
+### PyCharm+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+
+# Sonarlint plugin
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+doc/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+# .env
+.env/
+.venv/
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+pythonenv*
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# operating system-related files
+*.DS_Store #file properties cache/storage on macOS
+Thumbs.db #thumbnail cache on Windows
+
+# profiling data
+.prof
+
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+*.srt
+*.txt
+
+# End of https://www.toptal.com/developers/gitignore/api/intellij+all,python,pycharm+all,macos,windows
+/backend/models/V2/ch_det/inference.pdiparams
+/backend/models/V4/ch_det/inference.pdiparams
+/output/
+/backend/test.py
+/dylib/
+/settings.ini
+/test.py
+/test2.py
+/subtitle.ini
+/backend/models/**/*.onnx
+/config/config.json
+/.claude/
+/installer_output/
+/entitlements.plist
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..10a6d8f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,234 @@
+简体中文 | [English](README_en.md)
+
+<p align="center"><img src="https://github.com/YaoFANGUK/video-subtitle-extractor/raw/main/design/icon_1024.png" alt="VSE Logo" width="128"/></p>
+
+## 项目简介
+
+![License](https://img.shields.io/badge/License-Apache%202-red.svg)
+![python version](https://img.shields.io/badge/Python-3.12+-blue.svg)
+![support os](https://img.shields.io/badge/OS-Windows/macOS/Linux-green.svg)  
+
+Video-subtitle-extractor (VSE) 是一款将视频中的硬字幕提取为外挂字幕文件(srt格式)的软件
+主要实现了以下功能：
+
+- 提取视频中的关键帧
+- 检测视频帧中文本的所在位置
+- 识别视频帧中文本的内容
+- 过滤非字幕区域的文本
+- 去除水印、台标文本、原视频硬字幕，可配合：[video-subtitle-remover (VSR) ](https://github.com/YaoFANGUK/video-subtitle-remover/tree/main)
+- 去除重复字幕行，生成srt字幕文件/txt文本文件
+- 支持视频字幕**批量提取**
+- 多语言：支持**简体中文（中英双语）**、**繁体中文**、**英文**、**日语**、**韩语**、**越南语**、**阿拉伯语**、**法语**、**德语**、**俄语**、**西班牙语**、**葡萄牙语**、**意大利语**等**87种**语言的字幕提取
+- 多模式：
+  - **快速**：（推荐）使用轻量模型，快速提取字幕，可能丢少量字幕、存在少量错别字
+  - **自动**：（推荐）自动判断模型，CPU下使用轻量模型；GPU下使用精准模型，提取字幕速度较慢，可能丢少量字幕、几乎不存在错别字
+  - **精准**：（不推荐）使用精准模型，GPU下逐帧检测，不丢字幕，几乎不存在错别字，但速度**非常慢**
+
+> 请优先使用快速/自动模式，如果前两种模式存在较多丢字幕轴情况时，再使用精准模式
+ 
+<p style="text-align:center;"><img src="design/demo.png" alt="demo.png"/></p>
+
+**项目特色**：
+
+- 采用本地进行OCR识别，无需设置调用任何API，不需要接入百度、阿里等在线OCR服务即可本地完成文本识别
+- 支持GPU加速，GPU加速后可以获得更高的准确率与更快的提取速度
+
+**使用说明**：
+
+- 有使用问题请加群讨论，QQ群：210150985（已满）、806152575（已满）、816881808（已满）、295894827
+
+- 点击【打开】后选择视频文件，调整字幕区域，点击【运行】
+  - 单文件提取：打开文件的时候选择**单个**视频
+  - **批量提取**：打开文件的时候选择**多个**视频，确保每个视频的分辨率、字幕区域保持一致
+
+- 去除水印文本/替换特定文本：
+> 如果视频中出现特定的文本需要删除，或者特定的文本需要替换，可以编辑 ``backend/configs/typoMap.json``文件，加入你要替换或去除的内容
+
+```json
+{
+	"l'm": "I'm",
+	"l just": "I just",
+	"Let'sqo": "Let's go",
+	"Iife": "life",
+	"威筋": "威胁",
+  	"性感荷官在线发牌": ""
+}
+```
+
+> 这样就可以把文本中出现的所有“威筋”替换为“威胁”，所有的“性感荷官在线发牌”文本删除
+
+- 视频以及程序路径请**不要带中文和空格**，否则可能出现未知错误！！！
+
+ > 如：以下存放视频和代码的路径都不行
+ >
+ > D:\下载\vse\运行程序.exe（路径含中文）
+ >
+ > E:\study\kaoyan\sanshang youya.mp4 （路径含空格） 
+
+- 直接下载压缩包解压运行，如果不能运行再按照下面的教程，尝试源码安装conda环境运行
+
+**下载地址**：<a href="https://github.com/YaoFANGUK/video-subtitle-extractor/releases"> Release </a>
+
+> **有任何改进意见请在ISSUES和DISCUSSION中提出**
+
+> NVIDIA官方提供了各GPU型号的计算能力列表，您可以参考链接: [CUDA GPUs](https://developer.nvidia.com/cuda-gpus) 查看你的GPU适合哪个CUDA版本
+
+> NVIDIA 50系显卡需要使用cuda12.8.0及以上版本, 但Paddle3.3.1目前仍未支持，所以建议使用Directml通用版本
+
+**识别模式选择说明**：
+|    模式名称    | GPU | OCR模型尺寸 | 字幕检测引擎 | 备注 |
+|---------------|-----|---------|------|------|
+|    快速        | 有/无 | 迷你  | VideoSubFinder | |
+|    自动  | 有| 大  | VideoSubFinder |  推荐   |
+|    自动  | 无| 迷你  | VideoSubFinder |  推荐   |
+|    精准        | 有/无| 大  | VSE | 非常慢 |
+> Windows/Linux/MacOS环境下字幕检测引擎都是VideoSubFinder
+
+## 演示
+
+- GUI版：[点击查看GPU版本源码运行的安装教程 👈](https://www.bilibili.com/video/bv11L4y1Y7Tj)
+
+<p style="text-align:center;"><img src="https://github.com/YaoFANGUK/video-subtitle-extractor/raw/main/design/demo.gif" alt="demo.gif"/></p>
+
+
+## 源码使用说明
+
+#### 1. 安装 Python
+
+请确保您已经安装了 Python 3.12+
+
+- Windows 用户可以前往 [Python 官网](https://www.python.org/downloads/windows/) 下载并安装 Python
+- MacOS 用户可以使用 Homebrew 安装：
+  ```shell
+  brew install python@3.12
+  ```
+- Linux 用户可以使用包管理器安装，例如 Ubuntu/Debian：
+  ```shell
+  sudo apt update && sudo apt install python3.12 python3.12-venv python3.12-dev
+  ```
+
+#### 2. 安装依赖文件
+
+请使用虚拟环境来管理项目依赖，避免与系统环境冲突
+
+（1）创建虚拟环境并激活
+```shell
+python -m venv videoEnv
+```
+
+- Windows：
+```shell
+videoEnv\\Scripts\\activate
+```
+- MacOS/Linux：
+```shell
+source videoEnv/bin/activate
+```
+
+#### 3. 创建并激活项目目录
+
+切换到源码所在目录：
+```shell
+cd <源码所在目录>
+```
+> 例如：如果您的源代码放在 D 盘的 tools 文件夹下，并且源代码的文件夹名为 video-subtitle-extractor，则输入：
+> ```shell
+> cd D:/tools/video-subtitle-extractor-main
+> ```
+
+#### 4. 安装合适的运行环境
+
+本项目支持 CUDA（NVIDIA显卡加速）、CPU（无 GPU）、DirectML（AMD、Intel等GPU/APU加速）、ONNX四种运行模式
+
+##### (1) CUDA（NVIDIA 显卡用户）
+
+> 请确保您的 NVIDIA 显卡驱动支持所选 CUDA 版本
+
+- 推荐 CUDA 11.8，对应 cuDNN 8.6.0
+
+- 安装 CUDA：
+  - Windows：[CUDA 11.8 下载](https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_522.06_windows.exe)
+  - Linux：
+    ```shell
+    wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run
+    sudo sh cuda_11.8.0_520.61.05_linux.run
+    ```
+  - MacOS 不支持 CUDA
+
+- 安装 cuDNN（CUDA 11.8 对应 cuDNN 8.6.0）：
+  - [Windows cuDNN 8.6.0 下载](https://developer.download.nvidia.cn/compute/redist/cudnn/v8.6.0/local_installers/11.8/cudnn-windows-x86_64-8.6.0.163_cuda11-archive.zip)
+  - [Linux cuDNN 8.6.0 下载](https://developer.download.nvidia.cn/compute/redist/cudnn/v8.6.0/local_installers/11.8/cudnn-linux-x86_64-8.6.0.163_cuda11-archive.tar.xz)
+  - 安装方法请参考 NVIDIA 官方文档
+
+- 安装 PaddlePaddle GPU 版本（CUDA 11.8）：
+  ```shell
+  pip install paddlepaddle-gpu==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cu118/
+  pip install -r requirements.txt
+  ```
+
+##### (2) DirectML（AMD、Intel等GPU/APU加速卡用户）
+
+- 适用于 Windows 设备的 AMD/NVIDIA/Intel GPU
+- 安装 ONNX Runtime DirectML 版本：
+  ```shell
+  pip install paddlepaddle==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install -r requirements.txt
+  pip install -r requirements_directml.txt
+  ```
+
+##### (3) ONNX (适合macOS、AMD ROCm等环境加速用户, 基础环境与DirectML方式一致，未测试！)
+
+- 使用这个方式部署请勿反馈Issues
+- 适用于 Linux 或 macOS 设备的 AMD/Metal GPU/Apple Silicon GPU
+- 安装 ONNX Runtime DirectML 版本：
+  ```shell
+  pip install paddlepaddle==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install -r requirements.txt
+
+  # 阅读文档 https://onnxruntime.ai/docs/execution-providers/
+  # 根据你的设备选择合适的执行后端, 参考requirements_directml.txt文件修改成合适你环境的依赖
+
+  # 例如:
+  # requirements_coreml.txt
+  #   paddle2onnx==1.3.1
+  #   onnxruntime-coreml==1.13.1
+
+  pip install -r requirements_coreml.txt
+  ```
+
+##### (4) CPU 运行（无 GPU 加速）
+
+- 适用于没有 GPU 或不希望使用 GPU 的情况
+- 直接安装 CPU 版本 PaddlePaddle：
+  ```shell
+  pip install paddlepaddle==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install -r requirements.txt
+  ```
+
+#### 5. 运行程序
+
+- 运行图形化界面版本（GUI）
+
+```shell
+python gui.py
+```
+
+- 运行命令行版本（CLI）
+
+```shell
+python ./backend/main.py
+```
+
+## 常见问题与解决方案
+
+#### 1. 运行不正常/没有结果/cuda及cudnn问题
+
+解决方案：根据自己的显卡型号、显卡驱动版本，安装对应的cuda与cudnn
+
+#### 2. 7z文件解压错误
+
+解决方案：升级7-zip解压程序到最新版本
+
+## 赞助
+<img src="https://github.com/YaoFANGUK/video-subtitle-extractor/raw/main/design/sponsor.png" width="600">
+
diff --git a/README.wehub.md b/README.wehub.md
new file mode 100644
index 0000000..2ce607f
--- /dev/null
+++ b/README.wehub.md
@@ -0,0 +1,7 @@
+# WeHub 来源说明
+
+- 原始项目：`YaoFANGUK/video-subtitle-extractor`
+- 原始仓库：https://github.com/YaoFANGUK/video-subtitle-extractor
+- 导入方式：上游默认分支的最新快照
+- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准
+- 本文件仅用于记录来源，不代表 WeHub 是原项目作者
diff --git a/README_en.md b/README_en.md
new file mode 100644
index 0000000..9918ae1
--- /dev/null
+++ b/README_en.md
@@ -0,0 +1,237 @@
+[简体中文](README.md) | English
+
+<p align="center"><img src="https://github.com/YaoFANGUK/video-subtitle-extractor/raw/main/design/icon_1024.png" alt="VSE Logo" width="128"/></p>
+
+## Introduction
+
+![License](https://img.shields.io/badge/License-Apache%202-red.svg)
+![python version](https://img.shields.io/badge/Python-3.12+-blue.svg)
+![support os](https://img.shields.io/badge/OS-Windows/macOS/Linux-green.svg)
+
+Video-subtitle-extractor (VSE) is a software that extracts hard-coded subtitles from videos into external subtitle files (SRT format).
+
+Key features:
+
+- Extract key frames from videos
+- Detect text positions in video frames
+- Recognize text content in video frames
+- Filter out non-subtitle text regions
+- [Remove watermarks, channel logos, and original hard-coded subtitles — use with: video-subtitle-remover (VSR)](https://github.com/YaoFANGUK/video-subtitle-remover/tree/main)
+- Remove duplicate subtitle lines and generate SRT subtitle files / TXT text files
+- Support **batch extraction** of video subtitles
+- Multi-language: supports subtitle extraction in **87 languages**, including **Simplified Chinese (Chinese-English bilingual)**, **Traditional Chinese**, **English**, **Japanese**, **Korean**, **Vietnamese**, **Arabic**, **French**, **German**, **Russian**, **Spanish**, **Portuguese**, **Italian**, and more
+- Multiple modes:
+  - **Fast**: (Recommended) Uses a lightweight model for quick subtitle extraction. May miss a small number of subtitles and have minor typos.
+  - **Auto**: (Recommended) Automatically selects the model — uses the lightweight model on CPU and the precise model on GPU. Slower extraction speed, may miss a small number of subtitles, but with almost no typos.
+  - **Precise**: (Not recommended) Uses the precise model with frame-by-frame detection on GPU. No missed subtitles and almost no typos, but **very slow**.
+
+> Please use Fast/Auto mode first. Only switch to Precise mode if the first two modes miss too many subtitle lines.
+
+<p style="text-align:center;"><img src="design/demo.png" alt="demo.png"/></p>
+
+**Highlights**:
+
+- Uses local OCR recognition — no need to configure any API or connect to online OCR services such as Baidu or Alibaba
+- Supports GPU acceleration for higher accuracy and faster extraction speed
+
+**Usage Guide**:
+
+- For questions, please join the discussion group (QQ Group): 210150985 (full), 806152575 (full), 816881808 (full), 295894827
+
+- Click [Open] to select video files, adjust the subtitle area, then click [Run]
+  - Single file extraction: Select **one** video file when opening
+  - **Batch extraction**: Select **multiple** video files when opening. Ensure all videos have the same resolution and subtitle area
+
+- Remove watermark text / Replace specific text:
+> If specific text appears in the video that needs to be removed or replaced, edit the ``backend/configs/typoMap.json`` file and add your replacements
+
+```json
+{
+	"l'm": "I'm",
+	"l just": "I just",
+	"Let'sqo": "Let's go",
+	"Iife": "life",
+	"威筋": "威胁",
+  	"性感荷官在线发牌": ""
+}
+```
+
+> This will replace all occurrences of "威筋" with "威胁" and delete all "性感荷官在线发牌" text
+
+- Please **do not use Chinese characters or spaces** in video and program paths, otherwise unexpected errors may occur!!!
+
+  > For example, the following paths are NOT acceptable:
+  >
+  > D:\下载\vse\运行程序.exe (path contains Chinese characters)
+  >
+  > E:\study\kaoyan\sanshang youya.mp4 (path contains spaces)
+
+- Download the compressed package, extract it, and run directly. If it doesn't work, try the source code installation with conda environment as described below.
+
+**Download**: <a href="https://github.com/YaoFANGUK/video-subtitle-extractor/releases"> Release </a>
+
+> **Please submit any improvement suggestions in ISSUES and DISCUSSIONS**
+
+> NVIDIA provides a list of compute capabilities for each GPU model. You can refer to [CUDA GPUs](https://developer.nvidia.com/cuda-gpus) to check which CUDA version is suitable for your GPU.
+
+> NVIDIA 50-series GPUs require CUDA 12.8.0 or above, but Paddle 3.3.1 does not yet support it, so the DirectML universal version is recommended.
+
+**Recognition Mode Selection**:
+
+| Mode | GPU | OCR Model Size | Subtitle Detection Engine | Notes |
+|------|-----|----------------|---------------------------|-------|
+| Fast | Yes/No | Mini | VideoSubFinder | |
+| Auto | Yes | Large | VideoSubFinder | Recommended |
+| Auto | No | Mini | VideoSubFinder | Recommended |
+| Precise | Yes/No | Large | VSE | Very slow |
+
+> VideoSubFinder is the subtitle detection engine on Windows/Linux/macOS.
+
+## Demo
+
+- GUI version: [Click to view GPU version source code installation tutorial](https://www.bilibili.com/video/bv11L4y1Y7Tj)
+
+<p style="text-align:center;"><img src="https://github.com/YaoFANGUK/video-subtitle-extractor/raw/main/design/demo.gif" alt="demo.gif"/></p>
+
+
+## Source Code Usage Guide
+
+#### 1. Install Python
+
+Make sure you have Python 3.12+ installed.
+
+- Windows users can download and install Python from the [Python official website](https://www.python.org/downloads/windows/)
+- MacOS users can install via Homebrew:
+  ```shell
+  brew install python@3.12
+  ```
+- Linux users can install via package manager, e.g. Ubuntu/Debian:
+  ```shell
+  sudo apt update && sudo apt install python3.12 python3.12-venv python3.12-dev
+  ```
+
+#### 2. Install Dependencies
+
+Use a virtual environment to manage project dependencies and avoid conflicts with the system environment.
+
+(1) Create and activate a virtual environment
+```shell
+python -m venv videoEnv
+```
+
+- Windows:
+```shell
+videoEnv\\Scripts\\activate
+```
+- MacOS/Linux:
+```shell
+source videoEnv/bin/activate
+```
+
+#### 3. Navigate to the Project Directory
+
+Switch to the source code directory:
+```shell
+cd <source-code-directory>
+```
+> For example: if your source code is in the tools folder on drive D, and the source code folder is named video-subtitle-extractor, enter:
+> ```shell
+> cd D:/tools/video-subtitle-extractor-main
+> ```
+
+#### 4. Install the Appropriate Runtime Environment
+
+This project supports four runtime modes: CUDA (NVIDIA GPU acceleration), CPU (no GPU), DirectML (AMD, Intel GPU/APU acceleration), and ONNX.
+
+##### (1) CUDA (NVIDIA GPU Users)
+
+> Please ensure your NVIDIA GPU driver supports the selected CUDA version.
+
+- Recommended: CUDA 11.8 with cuDNN 8.6.0
+
+- Install CUDA:
+  - Windows: [CUDA 11.8 Download](https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_522.06_windows.exe)
+  - Linux:
+    ```shell
+    wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run
+    sudo sh cuda_11.8.0_520.61.05_linux.run
+    ```
+  - MacOS does not support CUDA
+
+- Install cuDNN (CUDA 11.8 requires cuDNN 8.6.0):
+  - [Windows cuDNN 8.6.0 Download](https://developer.download.nvidia.cn/compute/redist/cudnn/v8.6.0/local_installers/11.8/cudnn-windows-x86_64-8.6.0.163_cuda11-archive.zip)
+  - [Linux cuDNN 8.6.0 Download](https://developer.download.nvidia.cn/compute/redist/cudnn/v8.6.0/local_installers/11.8/cudnn-linux-x86_64-8.6.0.163_cuda11-archive.tar.xz)
+  - Please refer to NVIDIA official documentation for installation instructions
+
+- Install PaddlePaddle GPU version (CUDA 11.8):
+  ```shell
+  pip install paddlepaddle-gpu==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cu118/
+  pip install -r requirements.txt
+  ```
+
+##### (2) DirectML (AMD, Intel GPU/APU Users)
+
+- Suitable for AMD/NVIDIA/Intel GPUs on Windows
+- Install ONNX Runtime DirectML version:
+  ```shell
+  pip install paddlepaddle==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install -r requirements.txt
+  pip install -r requirements_directml.txt
+  ```
+
+##### (3) ONNX (For macOS, AMD ROCm, etc. — uses the same base setup as DirectML, untested!)
+
+- Please do not submit issues if using this deployment method
+- Suitable for AMD/Metal GPU/Apple Silicon GPU on Linux or macOS
+- Install ONNX Runtime:
+  ```shell
+  pip install paddlepaddle==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install -r requirements.txt
+
+  # Read the documentation at https://onnxruntime.ai/docs/execution-providers/
+  # Choose the appropriate execution backend for your device.
+  # Refer to requirements_directml.txt and modify the dependencies for your environment.
+
+  # For example:
+  # requirements_coreml.txt
+  #   paddle2onnx==1.3.1
+  #   onnxruntime-coreml==1.13.1
+
+  pip install -r requirements_coreml.txt
+  ```
+
+##### (4) CPU Mode (No GPU Acceleration)
+
+- Suitable for systems without a GPU or when GPU usage is not desired
+- Install the CPU version of PaddlePaddle directly:
+  ```shell
+  pip install paddlepaddle==3.3.1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install -r requirements.txt
+  ```
+
+#### 5. Run the Program
+
+- Run the GUI version:
+
+```shell
+python gui.py
+```
+
+- Run the CLI version:
+
+```shell
+python ./backend/main.py
+```
+
+## FAQ
+
+#### 1. Program not working / no results / CUDA and cuDNN issues
+
+Solution: Install the appropriate CUDA and cuDNN versions based on your GPU model and driver version.
+
+#### 2. 7z file extraction error
+
+Solution: Upgrade 7-Zip to the latest version.
+
+## Sponsor
+<img src="https://github.com/YaoFANGUK/video-subtitle-extractor/raw/main/design/sponsor.png" width="600">
diff --git a/backend/__init__.py b/backend/__init__.py
new file mode 100644
index 0000000..622b46f
--- /dev/null
+++ b/backend/__init__.py
@@ -0,0 +1,3 @@
+import os
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'dependencies'))
diff --git a/backend/bean/subtitle_area.py b/backend/bean/subtitle_area.py
new file mode 100644
index 0000000..89ebe92
--- /dev/null
+++ b/backend/bean/subtitle_area.py
@@ -0,0 +1,48 @@
+
+from typing import Union
+from dataclasses import dataclass
+from shapely.geometry import Polygon
+
+@dataclass
+class SubtitleArea:
+    """
+    字幕区域
+    """
+    ymin: Union[int, float]
+    ymax: Union[int, float]
+    xmin: Union[int, float]
+    xmax: Union[int, float]
+    # 字幕区域在视频中的位置
+    ab_section: range = None
+    
+    def __init__(self, ymin: Union[int, float], ymax: Union[int, float], 
+                 xmin: Union[int, float], xmax: Union[int, float], 
+                 ab_section: range = None):
+        self.ymin = ymin
+        self.ymax = ymax    
+        self.xmin = xmin
+        self.xmax = xmax
+        self.ab_section = ab_section
+
+    def normalized(self):
+        if self.xmin > self.xmax:
+            self.xmin, self.xmax = self.xmax, self.xmin
+        if self.ymin > self.ymax:
+            self.ymin, self.ymax = self.ymax, self.ymin
+
+    def is_empty(self):
+        return self.xmin == 0 and self.xmax == 0 and self.ymin == 0 and self.ymax == 0
+
+    @property
+    def width(self):
+        return self.xmax - self.xmin
+
+    @property
+    def height(self):
+        return self.ymax - self.ymin
+
+    def in_ab_section(self, frame_idx):
+        return True
+
+    def to_polygon(self):
+        return Polygon([[self.xmin, self.ymin], [self.xmax, self.ymin], [self.xmax, self.ymax], [self.xmin, self.ymax]])
\ No newline at end of file
diff --git a/backend/config.py b/backend/config.py
new file mode 100644
index 0000000..904d6ba
--- /dev/null
+++ b/backend/config.py
@@ -0,0 +1,113 @@
+
+import os
+from pathlib import Path
+from qfluentwidgets import (qconfig, ConfigItem, QConfig, OptionsValidator, BoolValidator, OptionsConfigItem, 
+                            EnumSerializer, RangeValidator, RangeConfigItem, ConfigValidator)
+from backend.tools.constant import SubtitleArea, VideoSubFinderDecoder
+import configparser
+
+# 项目版本号
+VERSION = "2.2.0"
+PROJECT_HOME_URL = "https://github.com/YaoFANGUK/video-subtitle-extractor"
+PROJECT_ISSUES_URL = PROJECT_HOME_URL + "/issues"
+PROJECT_RELEASES_URL = PROJECT_HOME_URL + "/releases"
+PROJECT_UPDATE_URLS = [
+    "https://api.github.com/repos/YaoFANGUK/video-subtitle-extractor/releases/latest",
+    "https://accelerate.xdow.net/api/repos/YaoFANGUK/video-subtitle-extractor/releases/latest",
+] 
+# 硬件加速选项开关
+HARDWARD_ACCELERATION_OPTION = True
+
+# 读取界面语言配置
+tr = configparser.ConfigParser()
+
+TRANSLATION_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'interface', f"en.ini")
+tr.read(TRANSLATION_FILE, encoding='utf-8')
+
+class Config(QConfig):
+    # 界面语言设置
+    intefaceTexts = {
+        '简体中文': 'ch',
+        '繁體中文': 'chinese_cht',
+        'English': 'en',
+        '한국어': 'ko',
+        '日本語': 'japan',
+        'Tiếng Việt': 'vi',
+        'Español': 'es',
+        'Turkish': 'tr'
+    }
+    interface = OptionsConfigItem("Window", "Interface", "ChineseSimplified", OptionsValidator(intefaceTexts.values()), restart = True)
+    
+    # 窗口位置和大小
+    windowX = ConfigItem("Window", "X", None)
+    windowY = ConfigItem("Window", "Y", None)
+    windowW = ConfigItem("Window", "Width", 1200)
+    windowH = ConfigItem("Window", "Height", 1200)
+
+    # 使用一个配置项存储所有选区
+    # 默认值为一个选区，格式为："ymin,ymax,xmin,xmax;ymin,ymax,xmin,xmax;..."，分号分隔不同选区
+    subtitleSelectionAreas = ConfigItem("Main", "SubtitleSelectionAreas", "0.78,0.99,0.05,0.95")
+
+    # 字幕语言设置
+    language = OptionsConfigItem("Main", "Language", "ch", OptionsValidator([name for name in tr["Language"]]))
+    # 识别模式设置
+    mode = OptionsConfigItem("Main", "Mode", "fast",  OptionsValidator(["auto", "fast", "accurate"]))
+    # 是否生成TXT文本字幕
+    generateTxt = ConfigItem("Main", "GenerateTxt", False, BoolValidator())
+    # 每张图中同时识别6个文本框中的文本，GPU显存越大，该数值可以设置越大
+    recBatchNumber = RangeConfigItem("Main", "RecBatchNumber", 6, RangeValidator(1, 100))
+    # DB算法每个batch识别多少张，默认为10
+    maxBatchSize = RangeConfigItem("Main", "MaxBatchSize", 10, RangeValidator(1, 256))
+    # 字幕出现区域
+    subtitleArea = OptionsConfigItem("Main", "SubtitleArea", SubtitleArea.UNKNOWN, OptionsValidator(SubtitleArea), EnumSerializer(SubtitleArea))
+    # 每一秒抓取多少帧进行OCR识别
+    extractFrequency = RangeConfigItem("Main", "ExtractFrequency", 3, RangeValidator(1, 60))
+    # 容忍的像素点偏差
+    tolerantPixelY = RangeConfigItem("Main", "TolerantPixelY", 50, RangeValidator(1, 1000))
+    tolerantPixelX = RangeConfigItem("Main", "TolerantPixelX", 100, RangeValidator(1, 1000))
+    # 字幕区域偏移量
+    subtitleAreaDeviationPixel = RangeConfigItem("Main", "SubtitleAreaDeviationPixel", 50, RangeValidator(1, 1000))
+    # 最有可能出现的水印区域
+    waterarkAreaNum = RangeConfigItem("Main", "WaterarkAreaNum", 5, RangeValidator(1, 10))
+    # 文本相似度阈值
+    # 用于去重时判断两行字幕是不是同一行，这个值越高越严格。 e.g. 0.99表示100个字里面有99各个字一模一样才算相似
+    # 采用动态算法实现相似度阈值判断: 对于短文本要求较低的阈值，对于长文本要求较高的阈值
+    # 如：文本较短，人民、入民，0.5就算相似
+    thresholdTextSimilarity = RangeConfigItem("Main", "ThresholdTextSimilarity", 80, RangeValidator(0, 100))
+    # 字幕提取中置信度低于0.75的不要
+    dropScore = RangeConfigItem("Main", "DropScore", 75, RangeValidator(0, 100))
+    # 字幕区域允许偏差, 0为不允许越界, 0.03表示可以越界3%
+    subtitleAreaDeviationRate = RangeConfigItem("Main", "SubtitleAreaDeviationRate", 0, RangeValidator(0, 100))
+    # 输出丢失的字幕帧, 仅简体中文,繁体中文,日文,韩语有效, 默认将调试信息输出到: 视频路径/loss
+    debugOcrLoss = ConfigItem("Main", "DebugOcrLoss", False, BoolValidator())
+    # 是否不删除缓存数据，以方便调试
+    debugNoDeleteCache = ConfigItem("Main", "DebugNoDeleteCache", False, BoolValidator())
+    # 是否删除空时间轴
+    deleteEmptyTimeStamp = ConfigItem("Main", "DeleteEmptyTimeStamp", True, BoolValidator())
+    # 是否重新分词, 用于解决没有语句没有空格
+    wordSegmentation = ConfigItem("Main", "WordSegmentation", True, BoolValidator())
+    # 是否使用硬件加速
+    hardwareAcceleration = ConfigItem("Main", "HardwareAcceleration", HARDWARD_ACCELERATION_OPTION, BoolValidator())
+    # 启动时检查应用更新
+    checkUpdateOnStartup = ConfigItem("Main", "CheckUpdateOnStartup", True, BoolValidator())
+    # 视频保存目录
+    saveDirectory = ConfigItem("Main", "SaveDirectory", "", ConfigValidator())
+    # VideoSubFinder CPU核心数
+    videoSubFinderCpuCores = RangeConfigItem("Main", "VideoSubFinderCpuCores", 0, RangeValidator(0, os.cpu_count()))
+    # VideoSubFinder 视频解码组件
+    videoSubFinderDecoder = OptionsConfigItem("Main", "VideoSubFinderDecoder", VideoSubFinderDecoder.OPENCV, OptionsValidator(VideoSubFinderDecoder), EnumSerializer(VideoSubFinderDecoder))
+
+CONFIG_FILE = 'config/config.json'
+config = Config()
+qconfig.load(CONFIG_FILE, config)
+
+# 读取界面语言配置
+tr = configparser.ConfigParser()
+
+TRANSLATION_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'interface', f"{config.interface.value}.ini")
+tr.read(TRANSLATION_FILE, encoding='utf-8')
+
+# 项目的base目录
+BASE_DIR = str(Path(os.path.abspath(__file__)).parent)
+
+os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
diff --git a/backend/configs/typoMap.json b/backend/configs/typoMap.json
new file mode 100644
index 0000000..9cb3b17
--- /dev/null
+++ b/backend/configs/typoMap.json
@@ -0,0 +1,7 @@
+{
+	"l'm": "I'm",
+	"l just": "I just",
+	"Let'sqo": "Let's go",
+	"Iife": "life",
+	"威筋": "威胁"
+}
\ No newline at end of file
diff --git a/backend/interface/ch.ini b/backend/interface/ch.ini
new file mode 100644
index 0000000..7154d93
--- /dev/null
+++ b/backend/interface/ch.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = 提供反馈
+FeedbackTitle = 提供反馈
+FeedbackDesc = 通过提供反馈帮助我们改进
+CopyrightButton = 检查更新
+CopyrightTitle = 关于
+CopyrightDesc = ©版权所有 2020, YaoFANGUK, Jason Eric (界面设计), 当前版本: {}
+ProjectLinkTitle = 字幕提取器
+ProjectLinkDesc = 视频硬字幕提取，生成srt文件。无需申请第三方API，本地实现文本识别。基于深度学习的视频字幕提取框架，包含字幕区域检测、字幕内容提取。
+BasicSetting = 基础设置
+AdvancedSetting = 高级设置
+DevSetting = 开发配置
+VideoSubFinderSetting = VideoSubFinder配置
+AboutSetting = 关于
+GenerateTxt = 生成TXT文本字幕
+WordSegmentation = 重新分词
+WordSegmentationDesc = 用于解决语句没有空格的问题
+HardwareAcceleration = 硬件加速
+HardwareAccelerationDesc = 使用GPU或ONNX后端进行加速处理
+RecBatchNumber = 识别批次数量
+RecBatchNumberDesc = 每张图中同时识别的文本框数量，GPU显存越大，该数值可以设置越大，默认为6
+MaxBatchSize = 最大批处理大小
+MaxBatchSizeDesc = DB算法每个batch识别多少张，默认为10
+SubtitleArea = 字幕出现区域
+SubtitleAreaDesc = 选择正确的字幕出现区域可提高处理速度，默认为全屏
+ExtractFrequency = 抽帧频率
+ExtractFrequencyDesc = 每一秒抓取多少帧进行OCR识别，默认为3
+TolerantPixelY = Y轴容忍像素偏差，默认为50
+TolerantPixelYDesc = 
+TolerantPixelX = X轴容忍像素偏差，默认为100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = 字幕区域偏移量
+SubtitleAreaDeviationPixelDesc = 字幕区域允许的像素偏移量
+WaterarkAreaNum = 水印区域数量，默认为5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = 文本相似度阈值，默认为80%%
+ThresholdTextSimilarityDesc = 用于去重时判断两行字幕是不是同一行，这个值越高越严格
+DropScore = 置信度阈值，默认为75%%
+DropScoreDesc = 字幕提取中置信度低于此值的不要
+SubtitleAreaDeviationRate = 字幕区域允许偏差率
+SubtitleAreaDeviationRateDesc = 0为不允许越界, 0.03表示可以越界3%%，默认为0%%
+CheckUpdateOnStartup = 在应用程序启动时检查更新
+CheckUpdateOnStartupDesc = 新版本将更加稳定, 并拥有更多功能(建议启用此选项)
+DebugOcrLoss = 输出丢失中日韩文字的字幕帧
+DebugOcrLossDesc = 仅简体中文,繁体中文,日文,韩语有效, 默认将调试信息输出到: 视频路径/loss
+DebugNoDeleteCache = 保留缓存数据
+DebugNoDeleteCacheDesc = 不删除缓存数据，以方便调试
+DeleteEmptyTimeStamp = 删除空时间轴
+DeleteEmptyTimeStampDesc = 删除没有字幕内容的时间轴
+UpdatesAvailableTitle = 有可用更新
+UpdatesAvailableDesc = 发现新版本 {}, 是否更新？
+NoUpdatesAvailableTitle = 无可用更新
+NoUpdatesAvailableDesc = 软件已是最新版本
+VideoSubFinderCpuCores = CPU核心数
+VideoSubFinderCpuCoresDesc = 字幕提取时使用的CPU核心数，默认为0，即自动, 选择所有核心并不会变得快
+VideoSubFinderDecoder = 视频解码组件
+VideoSubFinderDecoderDesc = 用于针对不同视频兼容性需求, 默认为OpenCV(推荐), 当遇到无法正常提取时可以切换为FFmpeg(可能会造成时间轴细微偏移)
+ChooseDirectory = 选择文件夹
+SaveDirectory = 字幕保存目录
+SaveDirectoryDefault = 默认保存到输入视频当前目录
+
+[SubtitleArea]
+LowerPart = 下半部分
+UpperPart = 上半部分
+Unknown = 全屏
+
+[LanguageModeGUI]
+Title = 字幕提取器
+InterfaceLanguage = 界面语言
+SubtitleLanguage = 视频字幕的语言
+Mode = 识别模式
+
+[Mode]
+Auto = 自动
+Fast = 快速
+Accurate = 精准
+
+[Language]
+CH = 简体中文
+CHINESE_CHT = 繁体中文
+EN = 英文
+JAPAN = 日文
+KOREAN = 韩文
+AR = 阿拉伯文
+FRENCH = 法文
+GERMAN = 德文
+RU = 俄罗斯文
+ES = 西班牙文
+PT = 葡萄牙文
+IT = 意大利文
+AF = 南非荷兰文
+AZ = 阿塞拜疆文
+BS = 波斯尼亚文
+CS = 捷克文
+CY = 威尔士文
+DA = 丹麦文
+DE = 德文
+ET = 爱沙尼亚文
+FR = 法文
+GA = 爱尔兰文
+HR = 克罗地亚文
+HU = 匈牙利文
+ID = 印尼文
+IS = 冰岛文
+KU = 库尔德文
+LA = 拉丁文
+LT = 立陶宛文
+LV = 拉脱维亚文
+MI = 毛利文
+MS = 马来文
+MT = 马耳他文
+NL = 荷兰文
+NO = 挪威文
+OC = 欧西坦文
+PI = 巴利文
+PL = 波兰文
+RO = 罗马尼亚文
+RS_LATIN = 塞尔维亚文(latin)
+SK = 斯洛伐克文
+SL = 斯洛文尼亚文
+SQ = 阿尔巴尼亚文
+SV = 瑞典文
+SW = 西瓦希里文
+TL = 塔加洛文
+TR = 土耳其文
+UZ = 乌兹别克文
+VI = 越南文
+LATIN = 拉丁文
+FA = 波斯文
+UG = 维吾尔文
+UR = 乌尔都文
+RS_CYRILLIC = 塞尔维亚文(cyrillic)
+BE = 白俄罗斯文
+BG = 保加利亚文
+UK = 乌克兰文
+MN = 蒙古文
+ABQ = 阿巴扎文
+ADY = 阿迪赫文
+KBD = 卡巴尔达文
+AVA = 阿瓦尔文
+DAR = 达尔瓦文
+INH = 因古什文
+CHE = 车臣文
+LBE = 拉克文
+LEZ = 莱兹甘文
+TAB = 塔巴萨兰文
+CYRILLIC = 西里尔文
+HI = 印地文
+MR = 马拉地文
+NE = 尼泊尔文
+BH = 比尔哈文
+MAI = 迈蒂利文
+ANG = 昂加文
+BHO = 孟加拉文
+MAH = 摩揭陀文
+SCK = 那格浦尔文
+NEW = 尼瓦尔文
+GOM = 保加利亚文
+SA = 沙特阿拉伯文
+BGC = 哈里亚纳文
+DEVANAGARI = 德瓦那加里文
+TA = 泰米尔文
+KN = 卡纳达文
+TE = 泰卢固文
+KA = 卡纳达文
+
+[SubtitleExtractorGUI]
+Title = 字幕提取器
+Open = 打开
+AllFile = 所有文件
+Vertical = 垂直方向
+Horizontal = 水平方向
+Run = 运行
+Stop = 停止
+Setting = 设置
+OpenVideoSuccess = 成功打开视频
+OpenVideoFailed = 无法打开视频: {}, 格式不兼容或文件损坏
+OpenVideoFirst = 请先打开视频文件
+SubtitleArea = 字幕区域
+VideoPreview = 视频预览
+ErrorDuringProcessing = 处理过程中发生错误: {}
+DeleteSelection = 删除当前激活选区
+
+[TimelineSync]
+Title = 同步时间轴
+Error = 出错了
+UnableToLocateFile = 找不到{}文件: {}
+ChooseFile = 选择文件
+SourceVideoTitle = 原始视频
+SourceVideoDesc = 选择已有字幕的视频文件, 例如: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv
+SourceSubtitleTitle = 原始字幕
+SourceSubtitleDesc = 选择与原始视频相匹配的字幕文件, 例如: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass
+DestinationVideoTitle = 目标视频
+DestinationVideoDesc = 选择需要同步时间轴的视频文件, 同步后的字幕将会保存到目标视频文件相同目录, 例如: the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv
+
+[Main]
+RecSubLang = 识别字幕语言
+RecMode = 识别模式
+IllegalPathWarning = 【警告】程序运行中断！路径不合法！请不要将程序放入带有空格和中文的路径下！！！请修改程序路径名后重新运行程序
+AcceleratorWarning = 【重要提示】请勿通过任务管理器、GPU低占用率或"PaddlePaddle works on..."等信息提示判断程序是否调用显卡资源。由于现代显卡的运算效率极高，通常可在每秒内处理上千张图像任务，出现低占用率属正常现象。如需验证硬件调用状态，请通过对比CPU版本与GPU版本在快速模式或者精准模式的执行耗时差异进行判断，若两者运行时间相近再进行反馈。
+AcceleratorON = 使用{}进行加速
+FrameCount = 帧数
+FrameRate = 帧率
+StartProcessFrame = 【处理中】正在提取视频关键帧...
+FinishProcessFrame = 【结束】视频关键帧提取完成
+StartFindSub = 【处理中】正在识别字幕内容，请耐心等待...
+FinishFindSub = 【结束】字幕内容识别完成
+StartDetectWaterMark = 【处理中】正在检测水印区域
+checkWaterMark = 视频是否存在水印区域，存在的话输入y，不存在的话输入n:
+FinishDetectWaterMark = 【结束】水印区域过滤完成
+StartDeleteNonSub = 【处理中】正在过滤非字幕区域内容
+FinishDeleteNonSub = 【结束】非字幕区域内容过滤完成
+StartGenerateSub = 【处理中】正在生成字幕文件...
+FinishGenerateSub = 【结束】字幕文件生成成功
+SubFrameNo = 字幕帧
+Elapse = 耗时
+ChooseSubArea = 请指定字幕区域
+WatchPicture = 请查看图片, 确定水印区域
+QuestionDelete = 区域中的字幕是否去除? 输入 "y" 或 "回车" 表示去除，输入"n"或其他表示不去除:
+FinishDelete = 已经删除该区域字幕...
+FinishWaterMarkFilter = 水印区域字幕过滤完毕...
+CheckSubArea = 请查看图片, 确定字幕区域是否正确:
+DeleteNoSubArea = 红色框区域外的字幕是否去除? 输入 "y" 或 "回车" 表示去除，输入"n"或其他表示不去除:
+FinishDeleteNoSubArea = 去除完毕
+SubLocation = 【完成】字幕文件生成位置: {}
+InputVideo = 请输入视频完整路径：
+OnnxExectionProviderNotSupportedSkipped = ONNX 执行提供程序: {} 不支持，已跳过。
+OnnxExecutionProviderDetected=检测到 ONNX 执行提供程序: {}
+OnnxRuntimeNotInstall = ONNX 运行环境未安装，已跳过。
+OcrDropNoIntercetion = 在选区之外
+OcrDropOutOfBoxRate = 超出选区越界允许偏差: {0}%%  当前值: {1}%%
+OcrDropConfidentLow = 置信值低于阈值: {0}%%
+OcrResult = √ 置信值: {1}%% 识别结果: {0} 
+OcrResultWithDropReason = × 置信值: {1}%% 识别结果: {0} 丢弃原因: {2}
+
+[TaskList]
+Pending = 待处理
+Processing = 处理中
+Completed = 已完成
+Failed = 失败
+Name = 名称
+Progress = ⠀进度⠀
+Status = ㅤ状态ㅤ
+OpenVideoLocation = 打开视频位置
+OpenSubtitleLocation = 打开字幕位置
+ResetTaskStatus = 重置任务状态
+DeleteTask = 删除任务
+Warning = 警告
+UnableToLocateFile = 找不到文件，可能已被移动或删除
+SubtitleNotFound = 字幕文件尚未生成，请先等待任务完成
+
+[VersionService]
+VersionInfo = 当前版本: {} 最新版本: {}
+RequestError = 尝试访问 {} 失败, 原因: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/chinese_cht.ini b/backend/interface/chinese_cht.ini
new file mode 100644
index 0000000..ff9542a
--- /dev/null
+++ b/backend/interface/chinese_cht.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = 提供回饋
+FeedbackTitle = 提供回饋
+FeedbackDesc = 透過提供回饋協助我們改進
+CopyrightButton = 檢查更新
+CopyrightTitle = About
+CopyrightDesc = ©版權所有 2020, YaoFANGUK, Jason Eric (介面設計), 當前版本: {}
+ProjectLinkTitle = 字幕提取器
+ProjectLinkDesc = 視頻硬字幕提取，生成srt文件。無需申請第三方API，本地實現文本識別。基於深度學習的視頻字幕提取框架，包含字幕區域檢測、字幕內容提取。
+BasicSetting = 基本設置
+AdvancedSetting = 高級設置
+VideoSubFinderSetting = VideoSubFinder設定
+DevSetting = 開發配置
+AboutSetting = 關於
+GenerateTxt = 生成TXT文本字幕
+WordSegmentation = 重新分詞
+WordSegmentationDesc = 用於解決語句沒有空格的問題
+HardwareAcceleration = 硬體加速
+HardwareAccelerationDesc = 使用GPU或ONNX後端進行加速處理
+RecBatchNumber = 識別批次數量
+RecBatchNumberDesc = 每張圖中同時識別的文本框數量，GPU顯存越大，該數值可以設置越大，默認為6
+MaxBatchSize = 最大批處理大小
+MaxBatchSizeDesc = DB算法每個batch識別多少張，默認為10
+SubtitleArea = 字幕出現區域
+SubtitleAreaDesc = 選擇正確的字幕出現區域可提高處理速度，默認為全屏
+ExtractFrequency = 抽幀頻率
+ExtractFrequencyDesc = 每一秒抓取多少幀進行OCR識別，默認為3
+TolerantPixelY = Y軸容忍像素偏差，默認為50
+TolerantPixelYDesc = 
+TolerantPixelX = X軸容忍像素偏差，默認為100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = 字幕區域偏移量
+SubtitleAreaDeviationPixelDesc = 字幕區域允許的像素偏移量
+WaterarkAreaNum = 水印區域數量，默認為5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = 文本相似度閾值，默認為80%%
+ThresholdTextSimilarityDesc = 用於去重時判斷兩行字幕是不是同一行，這個值越高越嚴格
+DropScore = 置信度閾值，默認為75%%
+DropScoreDesc = 字幕提取中置信度低於此值的不要
+SubtitleAreaDeviationRate = 字幕區域允許偏差率
+SubtitleAreaDeviationRateDesc = 0為不允許越界, 0.03表示可以越界3%%，默認為0%%
+CheckUpdateOnStartup = 啟動時檢查更新
+CheckUpdateOnStartupDesc = 新版本將更加穩定，並擁有更多功能（建議啟用此選項）
+DebugOcrLoss = 輸出丟失中日韓文字的字幕幀
+DebugOcrLossDesc = 僅簡體中文,繁體中文,日文,韓語有效, 默認將調試信息輸出到: 視頻路徑/loss
+DebugNoDeleteCache = 保留緩存數據
+DebugNoDeleteCacheDesc = 不刪除緩存數據，以方便調試
+DeleteEmptyTimeStamp = 刪除空時間軸
+DeleteEmptyTimeStampDesc = 刪除沒有字幕內容的時間軸
+UpdatesAvailableTitle = 有可用更新
+UpdatesAvailableDesc = 發現新版本 {}，是否更新？
+NoUpdatesAvailableTitle = 無可用更新
+NoUpdatesAvailableDesc = 軟體已是最新版本
+VideoSubFinderCpuCores = CPU核心數
+VideoSubFinderCpuCoresDesc = 提取字幕時使用的CPU核心數，預設為0（自動），選擇所有核心不一定更快
+VideoSubFinderDecoder = 視頻解碼組件
+VideoSubFinderDecoderDesc = 用於不同影片相容性需求，預設為OpenCV（推薦），若無法正常提取可切換為FFmpeg（可能導致時間軸略有偏移）
+ChooseDirectory = 選擇資料夾
+SaveDirectory = 字幕儲存目錄
+SaveDirectoryDefault = 預設儲存至輸入影片的目前目錄
+
+[SubtitleArea]
+LowerPart = 下半部分
+UpperPart = 上半部分
+Unknown = 全屏
+
+[LanguageModeGUI]
+Title = 字幕提取器
+InterfaceLanguage = 介面語言
+SubtitleLanguage = 視頻字幕的語言
+Mode = 識別模式
+
+[Mode]
+Auto = 自動
+Fast = 快速
+Accurate = 精準
+
+[Language]
+CH = 簡體中文
+CHINESE_CHT = 繁體中文
+EN = 英文
+JAPAN = 日文
+KOREAN = 韓文
+AR = 阿拉伯文
+FRENCH = 法文
+GERMAN = 德文
+RU = 俄羅斯文
+ES = 西班牙文
+PT = 葡萄牙文
+IT = 意大利文
+AF = 南非荷蘭文
+AZ = 阿塞拜疆文
+BS = 波斯尼亞文
+CS = 捷克文
+CY = 威爾士文
+DA = 丹麥文
+DE = 德文
+ET = 愛沙尼亞文
+FR = 法文
+GA = 愛爾蘭文
+HR = 克羅地亞文
+HU = 匈牙利文
+ID = 印尼文
+IS = 冰島文
+KU = 庫爾德文
+LA = 拉丁文
+LT = 立陶宛文
+LV = 拉脫維亞文
+MI = 毛利文
+MS = 馬來文
+MT = 馬耳他文
+NL = 荷蘭文
+NO = 挪威文
+OC = 歐西坦文
+PI = 巴利文
+PL = 波蘭文
+RO = 羅馬尼亞文
+RS_LATIN = 塞爾維亞文(latin)
+SK = 斯洛伐克文
+SL = 斯洛文尼亞文
+SQ = 阿爾巴尼亞文
+SV = 瑞典文
+SW = 西瓦希裏文
+TL = 塔加洛文
+TR = 土耳其文
+UZ = 烏茲別克文
+VI = 越南文
+LATIN = 拉丁文
+FA = 波斯文
+UG = 維吾爾文
+UR = 烏爾都文
+RS_CYRILLIC = 塞爾維亞文(cyrillic)
+BE = 白俄羅斯文
+BG = 保加利亞文
+UK = 烏克蘭文
+MN = 蒙古文
+ABQ = 阿巴紮文
+ADY = 阿迪赫文
+KBD = 卡巴爾達文
+AVA = 阿瓦爾文
+DAR = 達爾瓦文
+INH = 因古什文
+CHE = 車臣文
+LBE = 拉克文
+LEZ = 萊茲甘文
+TAB = 塔巴薩蘭文
+CYRILLIC = 西裏爾文
+HI = 印地文
+MR = 馬拉地文
+NE = 尼泊爾文
+BH = 比爾哈文
+MAI = 邁蒂利文
+ANG = 昂加文
+BHO = 孟加拉文
+MAH = 摩揭陀文
+SCK = 那格浦爾文
+NEW = 尼瓦爾文
+GOM = 保加利亞文
+SA = 沙特阿拉伯文
+BGC = 哈裏亞納文
+DEVANAGARI = 德瓦那加裏文
+TA = 泰米爾文
+KN = 卡納達文
+TE = 泰盧固文
+KA = 卡納達文
+
+[SubtitleExtractorGUI]
+Title = 字幕提取器
+Open = 打開
+AllFile = 所有文件
+Vertical = 垂直方向
+Horizontal = 水平方向
+Run = 運行
+Stop = 停止
+Setting = 設置
+OpenVideoSuccess = 成功打開視頻
+OpenVideoFailed = 無法打開視頻: {}，格式不相容或檔案損壞
+OpenVideoFirst = 請先打開視頻
+SubtitleArea = 字幕區域
+VideoPreview = 視頻預覽
+ErrorDuringProcessing = 處理過程中發生錯誤: {} 
+DeleteSelection = 刪除當前激活選區
+
+[TimelineSync]
+Title = 同步時間軸
+Error = 出錯了
+UnableToLocateFile = 找不到 {} 檔案: {}
+ChooseFile = 選擇檔案
+SourceVideoTitle = 原始影片
+SourceVideoDesc = 選擇已有字幕的影片檔案，例如：The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv
+SourceSubtitleTitle = 原始字幕
+SourceSubtitleDesc = 選擇與原始影片相匹配的字幕檔案，例如：The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass
+DestinationVideoTitle = 目標影片
+DestinationVideoDesc = 選擇需要同步時間軸的影片檔案，同步後的字幕將會儲存到目標影片檔案相同目錄，例如：the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv
+
+[Main]
+RecSubLang = 識別字幕語言
+RecMode = 識別模式
+IllegalPathWarning = 【警告】程序運行中斷！路徑不合法！請不要將程序放入帶有空格和中文的路徑下！！！請修改程序路徑名後重新運行程序
+AcceleratorWarning = 【重要提示】請勿透過工作管理員、GPU低使用率或「PaddlePaddle works on...」等訊息提示判斷程式是否調用顯示卡資源。由於現代顯示卡的運算效率極高，通常可在每秒內處理上千張影像任務，低使用率屬正常現象。如需驗證硬體調用狀態，請透過對比CPU版本與GPU版本在快速模式或精準模式的執行耗時差異進行判斷，若兩者運行時間相近再進行回饋。
+AcceleratorON = 使用{}進行加速
+FrameCount = 幀數
+FrameRate = 幀率
+StartProcessFrame = 【處理中】開啟提取視頻關鍵幀...
+FinishProcessFrame = 【結束】提取視頻關鍵幀完畢...
+StartFindSub = 【處理中】開始提取字幕信息，此步驟可能花費較長時間，請耐心等待...
+FinishFindSub = 【結束】完成字幕提取，生成原始字幕文件...
+StartDetectWaterMark = 【處理中】開始檢測並過濾水印區域內容
+checkWaterMark = 視頻是否存在水印區域，存在的話輸入y，不存在的話輸入n:
+FinishDetectWaterMark = 【結束】已經成功過濾水印區域內容
+StartDeleteNonSub = 【處理中】開始檢測非字幕區域，並將非字幕區域的內容刪除
+FinishDeleteNonSub = 【結束】已將非字幕區域的內容刪除
+StartGenerateSub = 【處理中】開始生成字幕文件
+FinishGenerateSub = 【結束】字幕文件生成成功
+SubFrameNo = 字幕幀
+Elapse = 耗時
+ChooseSubArea = 請指定字幕區域
+WatchPicture = 請查看圖片, 確定水印區域
+QuestionDelete = 區域中的字幕是否去除? 輸入 "y" 或 "回車" 表示去除，輸入"n"或其他表示不去除:
+FinishDelete = 已經刪除該區域字幕...
+FinishWaterMarkFilter = 水印區域字幕過濾完畢...
+CheckSubArea = 請查看圖片, 確定字幕區域是否正確:
+DeleteNoSubArea = 紅色框區域外的字幕是否去除? 輸入 "y" 或 "回車" 表示去除，輸入"n"或其他表示不去除:
+FinishDeleteNoSubArea = 去除完畢
+SubLocation = 【完成】字幕檔案生成位置: {}
+InputVideo = 請輸入視頻完整路徑：
+OnnxExectionProviderNotSupportedSkipped = ONNX 執行提供程序: {} 不支援，已跳過。
+OnnxExecutionProviderDetected = 檢測到 ONNX 執行提供程序: {}
+OnnxRuntimeNotInstall = ONNX 執行環境未安裝，已跳過。
+OcrDropNoIntercetion = 在選區之外
+OcrDropOutOfBoxRate = 超出選區允許偏差: {0}%%  當前值: {1}%%
+OcrDropConfidentLow = 置信值低於閾值: {0}%%
+OcrResult = √ 置信值: {1}%% 識別結果: {0}
+OcrResultWithDropReason = × 置信值: {1}%% 識別結果: {0} 丟棄原因: {2}
+
+[TaskList]
+Pending = 待處理
+Processing = 處理中
+Completed = 已完成
+Failed = 失敗
+Name = 檔案
+Progress = ⠀進度⠀
+Status = ㅤ狀態ㅤ
+OpenVideoLocation = 開啟視頻位置
+OpenSubtitleLocation = 開啟字幕位置 
+ResetTaskStatus = 重設任務狀態  
+DeleteTask = 刪除
+Warning = 警告
+UnableToLocateFile = 找不到檔案，可能已被移動或刪除
+SubtitleNotFound = 字幕檔案尚未生成，請先等待任務完成
+
+[VersionService]
+VersionInfo = 當前版本: {} 最新版本: {}
+RequestError = 嘗試訪問 {} 失敗，原因: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/en.ini b/backend/interface/en.ini
new file mode 100644
index 0000000..b26a272
--- /dev/null
+++ b/backend/interface/en.ini
@@ -0,0 +1,265 @@
+[Setting]
+FeedbackButton = Feedback
+FeedbackTitle = Feedback
+FeedbackDesc = Help us improve by providing feedback
+CopyrightButton = Check for Updates
+CopyrightTitle = About
+CopyrightDesc = ©Copyright 2020, YaoFANGUK, Jason Eric (UI), Current version: {}
+ProjectLinkTitle = Subtitle Extractor
+ProjectLinkDesc = Video hard subtitle extraction, generating srt files. No third-party API required, local text recognition. A video subtitle extraction framework based on deep learning, including subtitle area detection and subtitle content extraction.
+BasicSetting = Basic Settings
+AdvancedSetting = Advanced Settings
+VideoSubFinderSetting = VideoSubFinder Settings
+DevSetting = Development Settings
+AboutSetting = About
+GenerateTxt = Generate TXT Subtitles
+WordSegmentation = Word Segmentation
+WordSegmentationDesc = Used to solve sentences without spaces
+HardwareAcceleration = Hardware Acceleration
+HardwareAccelerationDesc = Use GPU or ONNX backend for accelerated processing
+RecBatchNumber = Recognition Batch Count
+RecBatchNumberDesc = Number of text boxes recognized simultaneously in each image. The larger the GPU memory, the larger this value can be set, default is 6
+MaxBatchSize = Maximum Batch Size
+MaxBatchSizeDesc = How many images each batch of DB algorithm recognizes, default is 10
+SubtitleArea = Subtitle Area
+SubtitleAreaDesc = Selecting the correct subtitle area can improve processing speed, default is full screen
+ExtractFrequency = Frame Extraction Frequency
+ExtractFrequencyDesc = How many frames to capture per second for OCR recognition, default is 3
+TolerantPixelY = Y-axis Pixel Tolerance, default is 50
+TolerantPixelYDesc = 
+TolerantPixelX = X-axis Pixel Tolerance, default is 100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = Subtitle Area Offset
+SubtitleAreaDeviationPixelDesc = Allowed pixel offset for subtitle area
+WaterarkAreaNum = Number of Watermark Areas, default is 5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = Text Similarity Threshold, default is 80%%
+ThresholdTextSimilarityDesc = Used to determine if two subtitle lines are the same when deduplicating, higher value means stricter
+DropScore = Confidence Threshold, default is 75%%
+DropScoreDesc = Subtitles with confidence below this value will be discarded
+SubtitleAreaDeviationRate = Subtitle Area Deviation Rate
+SubtitleAreaDeviationRateDesc = 0 means no boundary crossing allowed, 0.03 means 3%% crossing allowed, default is 0%%
+CheckUpdateOnStartup = Check for updates on startup
+CheckUpdateOnStartupDesc = New versions are more stable and have more features (recommended to enable this option)
+DebugOcrLoss = Output subtitle frames missing Chinese, Japanese, or Korean characters
+DebugOcrLossDesc = Only valid for Simplified Chinese, Traditional Chinese, Japanese, Korean. Debug info will be output to: video_path/loss
+DebugNoDeleteCache = Keep Cache Data
+DebugNoDeleteCacheDesc = Do not delete cache data for debugging purposes
+DeleteEmptyTimeStamp = Delete Empty Timestamps
+DeleteEmptyTimeStampDesc = Delete timestamps without subtitle content
+UpdatesAvailableTitle = Updates Available
+UpdatesAvailableDesc = New version {} found, update now?
+NoUpdatesAvailableTitle = No Updates Available
+NoUpdatesAvailableDesc = The software is up to date
+VideoSubFinderCpuCores = CPU Cores
+VideoSubFinderCpuCoresDesc = Number of CPU cores used for subtitle extraction. Default is 0 (auto). Using all cores may not be faster.
+VideoSubFinderDecoder = Video Decoder
+VideoSubFinderDecoderDesc = For different video compatibility needs. Default is OpenCV (recommended). Switch to FFmpeg if extraction fails (may cause slight timeline shift).
+ChooseDirectory = Choose Folder
+SaveDirectory = Subtitle Save Directory
+SaveDirectoryDefault = Default: save to the current directory of the input video
+
+[SubtitleArea]
+LowerPart = Lower Part
+UpperPart = Upper Part
+Unknown = Full Screen
+
+[LanguageModeGUI]
+Title = Subtitle Extractor
+InterfaceLanguage = Interface Language
+SubtitleLanguage = Subtitle Language
+Mode = Recognition Mode
+
+[Mode]
+Auto = auto
+Fast = fast
+Accurate = accurate
+
+
+[Language]
+CH = Simplified Chinese
+CHINESE_CHT = Traditional Chinese
+EN = English
+JAPAN = Japanese
+KOREAN = Korean
+AR = Arabic
+FRENCH = French
+GERMAN = German
+RU = Russian
+ES = Spanish
+PT = Portuguese
+IT = Italian
+AF = Afrikaans
+AZ = Azerbaijani
+BS = Bosnian
+CS = Czech
+CY = Welsh
+DA = Danish
+DE = German
+ET = Estonian
+FR = French
+GA = Irish
+HR = Croatian
+HU = Hungarian
+ID = Indonesian
+IS = Icelandic
+KU = Kurdish
+LA = Latin
+LT = Lithuanian
+LV = Latvian
+MI = Maori
+MS = Malay
+MT = Maltese
+NL = Dutch
+NO = Norwegian
+OC = Occitan
+PI = Pali
+PL = Polish
+RO = Romanian
+RS_LATIN = Serbian(latin)
+SK = Slovak
+SL = Slovenian
+SQ = Albanian
+SV = Swedish
+SW = Swahili
+TL = Tagalog
+TR = Turkish
+UZ = Uzbek
+VI = Vietnamese
+LATIN = Latin
+FA = Persian
+UR = Urdu
+RS_CYRILLIC = Serbian(cyrillic)
+BE = Belarusian
+BG = Bulgarian
+UK = Ukranian
+MN = Mongolian
+ABQ = Abaza
+ADY = Adyghe
+KBD = Kabardian
+AVA = Avar
+DAR = Dargwa
+INH = Ingush
+CHE = Chechen
+LBE = Lak
+LEZ = Lezghian
+TAB = Tabassaran
+CYRILLIC = Cyrillic
+HI = Hindi
+MR = Marathi
+NE = Nepali
+BH = Bihari
+MAI = Maithili
+ANG = Angika
+BHO = Bhojpuri
+MAH = Magahi
+SCK = Nagpur
+NEW = Newari
+GOM = Goan Konkani
+SA = Saudi Arabia
+BGC = Haryanvi
+DEVANAGARI = Devanagari
+TA = Tamil
+KN = Kannada
+UG = Uyghur
+TE = Telugu
+KA = Kannada
+
+[SubtitleExtractorGUI]
+Title = Subtitle Extractor
+Open = Open
+AllFile = All Files
+Vertical = Vertical
+Horizontal = Horizontal
+Run = Run
+Stop = Stop
+Setting = Settings
+OpenVideoSuccess = Successfully Open Video
+OpenVideoFailed = Failed to open video: {}, incompatible format or file is corrupted
+OpenVideoFirst = Please Open Video First
+SubtitleArea = Subtitle Area
+VideoPreview = Video Preview
+ErrorDuringProcessing = Error during processing: {}
+DeleteSelection = Delete Selection
+
+[TimelineSync]
+Title = Sync Timeline
+Error = Error
+UnableToLocateFile = Unable to locate {} file: {}
+ChooseFile = Choose File
+SourceVideoTitle = Source Video
+SourceVideoDesc = Select a video file with existing subtitles, e.g., The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv
+SourceSubtitleTitle = Source Subtitle
+SourceSubtitleDesc = Select a subtitle file that matches the source video, e.g., The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass
+DestinationVideoTitle = Destination Video
+DestinationVideoDesc = Select the video file to sync the timeline with. The synced subtitles will be saved in the same directory as the destination video file, e.g., the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv
+
+[Main]
+RecSubLang = Subtitle Language
+RecMode = Mode
+IllegalPathWarning = [Warning] The program is interrupted! The path is illegal! Please do not put the program in a path with spaces and Chinese! ! ! Please modify the program path name and re-run the program
+AcceleratorWarning = [Important Notice] Do not rely on Task Manager, low GPU utilization, or messages like "PaddlePaddle works on..." to determine whether the program utilizes GPU resources. Modern GPUs are designed for extreme computational efficiency, typically capable of processing thousands of image tasks per second, making low utilization rates a normal occurrence. To verify hardware resource allocation, please compare execution time differences between the CPU and GPU versions in Fast or Accurate mode. Submit feedback only if the runtime durations are comparable.
+AcceleratorON = Use {} for acceleration
+FrameCount = Frame Count
+FrameRate = Frame Rate
+StartProcessFrame = [Processing] Extracting video keyframes...
+FinishProcessFrame = [Finished] Video keyframes extracted
+StartFindSub = [Processing] Recognizing subtitle content, please wait...
+FinishFindSub = [Finished] Subtitle content recognized
+StartDetectWaterMark = [Processing] Detecting watermark area
+checkWaterMark = Whether there is a watermark area in the video, if it exists, enter "y", if it does not exist, enter "n":
+FinishDetectWaterMark = [Finished] Watermark area filtered
+StartDeleteNonSub = [Processing] Filtering non-subtitle area content
+FinishDeleteNonSub = [Finished] Non-subtitle area content filtered
+StartGenerateSub = [Processing] Generating subtitle file...
+FinishGenerateSub = [Finished] Subtitle file generated successfully
+SubFrameNo = Subtitle frame
+Elapse = elapse
+ChooseSubArea = Please specify subtitle area
+WatchPicture = Please check the picture to determine the watermark area
+QuestionDelete = Whether to remove the subtitles in the area? Input "y" or "Enter" to remove, input "n" or other means not to remove:
+FinishDelete = Subtitles in this area have been deleted...
+FinishWaterMarkFilter = The subtitles in the watermark area are filtered...
+CheckSubArea = Please check the picture to make sure the subtitle area is correct:
+DeleteNoSubArea = Are the subtitles outside the red box area removed? Input "y" or "Enter" to remove, input "n" or other means not to remove:
+FinishDeleteNoSubArea = Removed
+SubLocation = [Done] Subtitle file location: {}
+InputVideo = Please enter the full path of the video：
+OnnxExectionProviderNotSupportedSkipped = ONNX Execution Provider: {} is not supported, skipped.
+OnnxExecutionProviderDetected=Detected ONNX execution provider: {}
+OnnxRuntimeNotInstall = ONNX runtime environment not installed, skipped.
+OcrDropNoIntercetion = Out of selection
+OcrDropOutOfBoxRate = Exceeds allowed deviation: {0}%%  Current: {1}%%
+OcrDropConfidentLow = Confidence below threshold: {0}%%
+OcrResult = √ Confidence: {1}%% Result: {0}
+OcrResultWithDropReason = × Confidence: {1}%% Result: {0} Drop reason: {2}
+
+[TaskList]
+Pending = Pending
+Processing = Running
+Completed = Done
+Failed = Failed
+Name = File
+Progress = Progress
+Status = Status
+OpenVideoLocation = Open Video Location
+OpenSubtitleLocation = Open Subtitle Location  
+ResetTaskStatus = Reset Task  
+DeleteTask = Delete
+Warning = Warning
+UnableToLocateFile = File not found, it may have been moved or deleted
+SubtitleNotFound = Subtitle file not yet generated, please wait for task to complete
+
+[VersionService]
+VersionInfo = Current version: {} Latest version: {}
+RequestError = Failed to access {}, reason: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/es.ini b/backend/interface/es.ini
new file mode 100644
index 0000000..a581912
--- /dev/null
+++ b/backend/interface/es.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = Enviar comentarios
+FeedbackTitle = Enviar comentarios
+FeedbackDesc = Ayúdanos a mejorar proporcionando comentarios
+CopyrightButton = Buscar actualizaciones
+CopyrightTitle = About
+CopyrightDesc = ©Derechos reservados 2020, YaoFANGUK, Jason Eric (UI), Versión actual: {}
+ProjectLinkTitle = Extractor de subtítulos
+ProjectLinkDesc = Extracción de subtítulos incrustados en video, generando archivos srt. No requiere API de terceros, reconocimiento de texto local. Un marco de extracción de subtítulos de video basado en aprendizaje profundo, que incluye detección de área de subtítulos y extracción de contenido de subtítulos.
+BasicSetting = Configuración básica
+AdvancedSetting = Configuración de avanzada
+VideoSubFinderSetting = Configuración de VideoSubFinder
+DevSetting = Configuración de desarrollo
+AboutSetting = Acerca de
+GenerateTxt = Generar subtítulos TXT
+WordSegmentation = Segmentación de palabras
+WordSegmentationDesc = Utilizado para resolver oraciones sin espacios
+HardwareAcceleration = Aceleración de hardware
+HardwareAccelerationDesc = Usar GPU o backend ONNX para procesamiento acelerado
+RecBatchNumber = Cantidad de lotes de reconocimiento
+RecBatchNumberDesc = Número de cuadros de texto reconocidos simultáneamente en cada imagen. Cuanto mayor sea la memoria GPU, mayor puede ser este valor, el valor predeterminado es 6
+MaxBatchSize = Tamaño máximo de lote
+MaxBatchSizeDesc = Cuántas imágenes reconoce cada lote del algoritmo DB, el valor predeterminado es 10
+SubtitleArea = Área de subtítulos
+SubtitleAreaDesc = Seleccionar el área correcta de subtítulos puede mejorar la velocidad de procesamiento, el valor predeterminado es pantalla completa
+ExtractFrequency = Frecuencia de extracción de fotogramas
+ExtractFrequencyDesc = Cuántos fotogramas capturar por segundo para el reconocimiento OCR, el valor predeterminado es 3
+TolerantPixelY = Tolerancia de píxeles en el eje Y, predeterminado 50
+TolerantPixelYDesc = 
+TolerantPixelX = Tolerancia de píxeles en el eje X, predeterminado 100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = Desplazamiento del área de subtítulos
+SubtitleAreaDeviationPixelDesc = Desplazamiento de píxeles permitido para el área de subtítulos
+WaterarkAreaNum = Número de áreas de marca de agua, predeterminado 5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = Umbral de similitud de texto, predeterminado 80%%
+ThresholdTextSimilarityDesc = Utilizado para determinar si dos líneas de subtítulos son iguales al eliminar duplicados, un valor más alto significa más estricto
+DropScore = Umbral de confianza, predeterminado 75%%
+DropScoreDesc = Los subtítulos con confianza por debajo de este valor serán descartados
+SubtitleAreaDeviationRate = Tasa de desviación del área de subtítulos
+SubtitleAreaDeviationRateDesc = 0 significa que no se permite cruzar el límite, 0.03 significa que se permite un cruce del 3%%, el valor predeterminado es 0%%
+CheckUpdateOnStartup = Buscar actualizaciones al iniciar
+CheckUpdateOnStartupDesc = Las nuevas versiones son más estables y tienen más funciones (se recomienda habilitar esta opción)
+DebugOcrLoss = Exportar fotogramas de subtítulos que faltan caracteres chinos, japoneses o coreanos
+DebugOcrLossDesc = Solo válido para chino simplificado, chino tradicional, japonés, coreano. La información de depuración se enviará a: ruta_del_video/loss
+DebugNoDeleteCache = Mantener datos en caché
+DebugNoDeleteCacheDesc = No eliminar datos en caché para fines de depuración
+DeleteEmptyTimeStamp = Eliminar marcas de tiempo vacías
+DeleteEmptyTimeStampDesc = Eliminar marcas de tiempo sin contenido de subtítulos
+UpdatesAvailableTitle = Actualizaciones disponibles
+UpdatesAvailableDesc = Se encontró una nueva versión {}, ¿actualizar ahora?
+NoUpdatesAvailableTitle = No hay actualizaciones disponibles
+NoUpdatesAvailableDesc = El software está actualizado
+VideoSubFinderCpuCores = Núcleos de CPU
+VideoSubFinderCpuCoresDesc = Núcleos de CPU usados para extraer subtítulos. Por defecto es 0 (automático). Usar todos los núcleos no siempre es más rápido.
+VideoSubFinderDecoder = Componente de decodificación de video
+VideoSubFinderDecoderDesc = Para diferentes necesidades de compatibilidad de video. Por defecto es OpenCV (recomendado). Cambia a FFmpeg si la extracción falla (puede causar un pequeño desfase en la línea de tiempo).
+ChooseDirectory = Seleccionar Carpeta
+SaveDirectory = Directorio de guardado de subtítulos
+SaveDirectoryDefault = Predeterminado: guardar en el directorio actual del video de entrada
+
+[SubtitleArea]
+LowerPart = Parte inferior
+UpperPart = Parte superior
+Unknown = Pantalla completa
+
+[LanguageModeGUI]
+Title = Extractor de subtítulos
+InterfaceLanguage = Idioma de la interfaz
+SubtitleLanguage = Idioma de los subtítulos
+Mode = Modo de reconocimiento
+
+[Mode]
+Auto = automático
+Fast = rápido
+Accurate = preciso
+
+[Language]
+CH = Chino simplificado
+CHINESE_CHT = Chino tradicional
+EN = Inglés
+JAPAN = Japonés
+KOREAN = Coreano
+AR = Árabe
+FRENCH = Francés
+GERMAN = Alemán
+RU = Ruso
+ES = Español
+PT = Portugués
+IT = Italiano
+AF = Afrikáans
+AZ = Azerí
+BS = Bosnio
+CS = Checo
+CY = Galés
+DA = Danés
+DE = Alemán
+ET = Estonio
+FR = Francés
+GA = Irlandés
+HR = Croata
+HU = Húngaro
+ID = Indonesio
+IS = Islandés
+KU = Kurdo
+LA = Latín
+LT = Lituano
+LV = Letón
+MI = Maorí
+MS = Malay
+MT = Maltés
+NL = Neerlandés
+NO = Noruego
+OC = Occitano
+PI = Pali
+PL = Polaco
+RO = Rumano
+RS_LATIN = Serbio (latín)
+SK = Eslovaco
+SL = Esloveno
+SQ = Albanés
+SV = Sueco
+SW = Swahili
+TL = Tagalo
+TR = Turco
+UZ = Uzbeko
+VI = Vietnamita
+LATIN = Latín
+FA = Persa
+UR = Urdu
+RS_CYRILLIC = Serbio (cirílico)
+BE = Bielorruso
+BG = Búlgaro
+UK = Ucraniano
+MN = Mongol
+ABQ = Abaza
+ADY = Adigueo
+KBD = Kabardino
+AVA = Avar
+DAR = Dargwa
+INH = Ingush
+CHE = Checheno
+LBE = Lak
+LEZ = Lezgiano
+TAB = Tabasarán
+CYRILLIC = Cirílico
+HI = Hindi
+MR = Marathi
+NE = Nepalí
+BH = Bihari
+MAI = Maithili
+ANG = Angika
+BHO = Bhojpuri
+MAH = Magahi
+SCK = Nagpur
+NEW = Newari
+GOM = Concaní
+SA = Arabia Saudita
+BGC = Haryanvi
+DEVANAGARI = Devanagari
+TA = Tamil
+KN = Kannada
+UG = Uigur
+TE = Telugu
+KA = Kannada
+
+[SubtitleExtractorGUI]
+Title = Extractor de subtítulos
+Open = Abrir
+AllFile = Todos los archivos
+Vertical = Vertical
+Horizontal = Horizontal
+Run = Ejecutar
+Stop = Detener
+Setting = Configuraciones
+OpenVideoSuccess = Se abrió el video exitosamente
+OpenVideoFailed = No se pudo abrir el video: {}, formato incompatible o archivo dañado
+OpenVideoFirst = Por favor, abra el video primero
+SubtitleArea = Área de subtítulos
+VideoPreview = Vista previa de video
+ErrorDuringProcessing = Error durante el procesamiento: {}
+DeleteSelection = Eliminar selección
+
+[TimelineSync]
+Title = Sincronizar Línea de Tiempo
+Error = Error
+UnableToLocateFile = No se encuentra el archivo {}: {}
+ChooseFile = Seleccionar Archivo
+SourceVideoTitle = Video de Origen
+SourceVideoDesc = Selecciona un archivo de video con subtítulos existentes, ej., The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv
+SourceSubtitleTitle = Subtítulo de Origen
+SourceSubtitleDesc = Selecciona un archivo de subtítulos que coincida con el video de origen, ej., The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass
+DestinationVideoTitle = Video de Destino
+DestinationVideoDesc = Selecciona el archivo de video para sincronizar la línea de tiempo. Los subtítulos sincronizados se guardarán en el mismo directorio que el archivo de video de destino, ej., the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv
+
+[Main]
+RecSubLang = Idioma de subtítulos
+RecMode = Modo
+IllegalPathWarning = [Advertencia] ¡El programa se interrumpió! ¡La ruta es ilegal! ¡No coloque el programa en una ruta con espacios y caracteres chinos! Por favor, modifique el nombre de ruta del programa y vuelva a ejecutarlo.
+AcceleratorWarning = [Aviso importante] No utilice el Administrador de tareas, la baja utilización de la GPU o mensajes como "PaddlePaddle works on..." para determinar si el programa está utilizando recursos de la tarjeta gráfica. Debido a la alta eficiencia de cálculo de las tarjetas gráficas modernas, que normalmente pueden procesar miles de imágenes por segundo, es normal que aparezca una baja tasa de utilización. Para verificar el estado de uso del hardware, compare la diferencia de tiempo de ejecución entre las versiones CPU y GPU en modo rápido o preciso. Solo envíe comentarios si los tiempos de ejecución de ambas versiones son similares.
+AcceleratorON = Use {} para aceleración
+FrameCount = Conteo de fotogramas
+FrameRate = Velocidad de fotogramas
+StartProcessFrame = [Procesamiento] Empieza a extraer fotogramas clave del video...
+FinishProcessFrame = [Terminado] Se termino de extraer fotogramas clave del video...
+StartFindSub = [Procesamiento] Empieza la extracción de información de subtítulos, este paso puede llevar bastante tiempo, por favor tenga paciencia...
+FinishFindSub = [Terminado] Se termino la extracción de subtítulos, se generó el archivo de subtítulos original...
+StartDetectWaterMark = [Procesamiento] Empieza la detección y filtración del área de marca de agua
+checkWaterMark = Si hay un área de marca de agua en el video, si existe, escriba "s", si no, escriba "n":
+FinishDetectWaterMark = [Terminado] El área de marca de agua ha sido filtrada exitosamente
+StartDeleteNonSub = [Procesamiento] Empieza la detección del área sin subtítulos y se elimina el contenido de la misma
+FinishDeleteNonSub = [Terminado] El área sin subtítulos ha sido eliminada
+StartGenerateSub = [Procesamiento] Empieza la generación de archivos de subtítulos
+FinishGenerateSub = [Terminado] Se generó el archivo de subtítulos exitosamente
+SubFrameNo = Fotograma de subtítulo
+Elapse = transcurrir
+ChooseSubArea = Por favor, especifique el área de subtítulo
+WatchPicture = Por favor, revise la imagen para determinar la area de marca de agua
+QuestionDelete = ¿Desea quitar los subtítulos en esta area? Pulsar "s" o "Enter" para eliminar, pulsar "n" o cualquier otro to te significa no eliminar:
+FinishDelete = Se han eliminado los subtítulos de esta área...
+FinishWaterMarkFilter = Se han filtrado los subtítulos en la área de la marca de agua...
+CheckSubArea = Por favor, revise la imagen para asegurarse que el área de subtítulo es correcta:
+DeleteNoSubArea = ¿Se remueven los subtítulos fuera del área del cuadro rojo? Pulsar "s" o "Enter" para eliminar, pulsar "n" o cualquier otro to te significa no eliminar:
+FinishDeleteNoSubArea = Eliminado
+SubLocation = [Completado] Ubicación del archivo de subtítulos: {}
+InputVideo = Por favor, ingrese la ruta completa del video：
+OnnxExectionProviderNotSupportedSkipped = Proveedor de ejecución de ONNX: {} no es compatible, ya se omitió.
+OnnxExecutionProviderDetected = Proveedor de ejecución de ONNX detectado: {}
+OnnxRuntimeNotInstall = Entorno de ejecución de ONNX no instalado, omitido.
+OcrDropNoIntercetion = Fuera de la selección
+OcrDropOutOfBoxRate = Excede desviación permitida: {0}%%  Actual: {1}%%
+OcrDropConfidentLow = Confianza baja: {0}%%
+OcrResult = √ Confianza: {1}%% Resultado: {0}
+OcrResultWithDropReason = × Confianza: {1}%% Resultado: {0} Motivo: {2}
+
+[TaskList]
+Pending = Pendiente
+Processing = Procesando
+Completed = Completado
+Failed = Fallido
+Name = Archivo
+Progress = Progreso
+Status = Estado
+OpenVideoLocation = Abrir ubicación del video
+OpenSubtitleLocation = Abrir ubicación del subtítulo  
+ResetTaskStatus = Reiniciar tarea  
+DeleteTask = Eliminar
+Warning = Advertencia
+UnableToLocateFile = Archivo no encontrado, puede haber sido movido o eliminado
+SubtitleNotFound = Archivo de subtítulos aún no generado, espere a que se complete la tarea
+
+[VersionService]
+VersionInfo = Versión actual: {} Última versión: {}
+RequestError = Error al acceder a {}, razón: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/japan.ini b/backend/interface/japan.ini
new file mode 100644
index 0000000..e047827
--- /dev/null
+++ b/backend/interface/japan.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = フィードバックを送信
+FeedbackTitle = フィードバックを送信
+FeedbackDesc = フィードバックを提供して改善にご協力ください
+CopyrightButton = アップデートを確認
+CopyrightTitle = About
+CopyrightDesc = ©著作権 2020, YaoFANGUK, Jason Eric (UI)、現在のバージョン: {}
+ProjectLinkTitle = 字幕抽出ツール
+ProjectLinkDesc = 動画の硬字幕を抽出し、srtファイルを生成します。サードパーティAPIは不要で、ローカルでテキスト認識を実現。深層学習に基づく動画字幕抽出フレームワークで、字幕領域の検出と字幕内容の抽出を含みます。
+BasicSetting = 基本設定
+AdvancedSetting = 詳細設定
+VideoSubFinderSetting = VideoSubFinder設定
+DevSetting = 開発設定
+AboutSetting = について
+GenerateTxt = TXT字幕を生成
+WordSegmentation = 分かち書き
+WordSegmentationDesc = 文章にスペースがない問題を解決するため
+HardwareAcceleration = ハードウェアアクセラレーション
+HardwareAccelerationDesc = GPUまたはONNXバックエンドを使用して処理を高速化
+RecBatchNumber = 認識バッチ数
+RecBatchNumberDesc = 各画像で同時に認識するテキストボックスの数。GPUメモリが大きいほど、この値を大きく設定できます。デフォルトは6
+MaxBatchSize = 最大バッチサイズ
+MaxBatchSizeDesc = DBアルゴリズムの各バッチで認識する画像数、デフォルトは10
+SubtitleArea = 字幕表示領域
+SubtitleAreaDesc = 正しい字幕領域を選択すると処理速度が向上します。デフォルトは全画面
+ExtractFrequency = フレーム抽出頻度
+ExtractFrequencyDesc = 1秒あたりのOCR認識用フレーム取得数、デフォルトは3
+TolerantPixelY = Y軸許容ピクセル偏差、デフォルトは50
+TolerantPixelYDesc = 
+TolerantPixelX = X軸許容ピクセル偏差、デフォルトは100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = 字幕領域オフセット
+SubtitleAreaDeviationPixelDesc = 字幕領域の許容ピクセルオフセット
+WaterarkAreaNum = ウォーターマーク領域数、デフォルトは5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = テキスト類似度閾値、デフォルトは80%%
+ThresholdTextSimilarityDesc = 重複除去時に2行の字幕が同じかどうかを判断するために使用、値が高いほど厳密
+DropScore = 信頼度閾値、デフォルトは75%%
+DropScoreDesc = この値より低い信頼度の字幕は除外
+SubtitleAreaDeviationRate = 字幕領域許容偏差率
+SubtitleAreaDeviationRateDesc = 0は境界超過不可、0.03は3%%の超過を許可、デフォルトは0%%
+CheckUpdateOnStartup = 起動時にアップデートを確認する
+CheckUpdateOnStartupDesc = 新しいバージョンはより安定し、より多くの機能があります（このオプションの有効化を推奨します）
+DebugOcrLoss = 中日韓文字が欠落している字幕フレームを出力
+DebugOcrLossDesc = 簡体字中国語、繁体字中国語、日本語、韓国語のみ有効。デバッグ情報は動画パス/lossに出力
+DebugNoDeleteCache = キャッシュデータを保持
+DebugNoDeleteCacheDesc = デバッグ用にキャッシュデータを削除しない
+DeleteEmptyTimeStamp = 空のタイムスタンプを削除
+DeleteEmptyTimeStampDesc = 字幕内容のないタイムスタンプを削除
+UpdatesAvailableTitle = 利用可能なアップデート
+UpdatesAvailableDesc = 新しいバージョン{}が見つかりました。今すぐアップデートしますか？
+NoUpdatesAvailableTitle = 利用可能なアップデートはありません
+NoUpdatesAvailableDesc = ソフトウェアは最新バージョンです
+VideoSubFinderCpuCores = CPUコア数
+VideoSubFinderCpuCoresDesc = 字幕抽出に使用するCPUコア数。デフォルトは0（自動）。全コアを選択しても速くなるとは限りません。
+VideoSubFinderDecoder = ビデオデコーダー
+VideoSubFinderDecoderDesc = 異なる動画互換性のニーズに対応。デフォルトはOpenCV（推奨）。抽出できない場合はFFmpegに切り替えてください（タイムラインがわずかにずれる場合があります）。
+ChooseDirectory = フォルダを選択
+SaveDirectory = 字幕の保存ディレクトリ
+SaveDirectoryDefault = デフォルト: 入力動画の現在のディレクトリに保存
+
+[SubtitleArea]
+LowerPart = 下部
+UpperPart = 上部
+Unknown = 全画面
+
+[LanguageModeGUI]
+Title = サブタイトル抽出器
+InterfaceLanguage = 言語の選択：
+SubtitleLanguage = サブタイトルの言語：
+Mode = モードを選択：
+
+[Mode]
+Auto = 自動
+Fast = 高速
+Accurate = 正確
+
+[Language]
+CH = 簡体字中国語
+CHINESE_CHT = 繁体字中国語
+EN = 英語
+JAPAN = 日本語
+KOREAN = 韓国語
+AR = アラビア語
+FRENCH = フランス語
+GERMAN = ドイツ語
+RU = ロシア語
+ES = スペイン語
+PT = ポルトガル語
+IT = イタリア語
+AF = アフリカーンス語
+AZ = アゼルバイジャン語
+BS = ボスニア語
+CS = チェコ語
+CY = ウェールズ語
+DA = デンマーク語
+DE = ドイツ語
+ET = エストニア語
+FR = フランス語
+GA = アイルランド語
+HR = クロアチア語
+HU = ハンガリー語
+ID = インドネシア語
+IS = アイスランド語
+KU = クルド語
+LA = ラテン語
+LT = リトアニア語
+LV = ラトビア語
+MI = マオリ語
+MS = マレー語
+MT = マルタ語
+NL = オランダ語
+NO = ノルウェー語
+OC = オック語
+PI = パーリ語
+PL = ポーランド語
+RO = ルーマニア語
+RS_LATIN = セルビア語(ラテン文字)
+SK = スロバキア語
+SL = スロベニア語
+SQ = アルバニア語
+SV = スウェーデン語
+SW = スワヒリ語
+TL = タガログ語
+TR = トルコ語
+UZ = ウズベク語
+VI = ベトナム語
+LATIN = ラテン語
+FA = ペルシア語
+UR = ウルドゥ語
+RS_CYRILLIC = セルビア語(キリル文字)
+BE = ベラルーシ語
+BG = ブルガリア語
+UK = ウクライナ語
+MN = モンゴル語
+ABQ = アバザ語
+ADY = アディゲ語
+KBD = カバルディン語
+AVA = アヴァール語
+DAR = ダルガン語
+INH = イングーシ語
+CHE = チェチェン語
+LBE = ラク語
+LEZ = レズギ語
+TAB = タバサラン語
+CYRILLIC = キリル文字
+HI = ヒンディー語
+MR = マラーティー語
+NE = ネパール語
+BH = ビハリ語
+MAI = マイティリー語
+ANG = アンギカ語
+BHO = ボージプリー語
+MAH = マガヒー語
+SCK = ナグプール語
+NEW = ネワール語
+GOM = ゴアのコンカニ語
+SA = サウジアラビア
+BGC = ハリヤンビ語
+DEVANAGARI = デーヴァナーガリー文字
+TA = タミル語
+KN = カンナダ語
+UG = ウイグル語
+TE = テルグ語
+KA = カンナダ語
+
+[SubtitleExtractorGUI]
+Title = サブタイトル抽出器
+Open = 開く
+AllFile = 全てのファイル
+Vertical = 垂直
+Horizontal = 水平
+Run = 実行
+Stop = 停止
+Setting = 設定
+OpenVideoSuccess = ビデオが正常に開きました
+OpenVideoFailed = ビデオを開けません: {}、フォーマットが非対応またはファイルが破損しています
+OpenVideoFirst = 最初にビデオを開いてください
+SubtitleArea = サブタイトル領域
+VideoPreview = ビデオプレビュー
+ErrorDuringProcessing = 処理中にエラーが発生しました: {}
+DeleteSelection = 現在のアクティブ選択範囲を削除
+
+[TimelineSync]
+Title = タイムライン同期
+Error = エラー
+UnableToLocateFile = {} ファイルが見つかりません: {}
+ChooseFile = ファイルを選択
+SourceVideoTitle = ソース動画
+SourceVideoDesc = 既存の字幕がある動画ファイルを選択してください（例: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv）
+SourceSubtitleTitle = ソース字幕
+SourceSubtitleDesc = ソース動画と一致する字幕ファイルを選択してください（例: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass）
+DestinationVideoTitle = ターゲット動画
+DestinationVideoDesc = タイムラインを同期する動画ファイルを選択してください。同期後の字幕はターゲット動画と同じディレクトリに保存されます（例: the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv）
+
+[Main]
+RecSubLang = サブタイトル言語
+RecMode = モード
+IllegalPathWarning = 【注意】プログラムは中断されました！ パスが不正です！ プログラムをスペースや中国語が含まれるパスに置かないでください！！！ プログラムのパス名を修正してプログラムを再実行してください
+AcceleratorWarning = 【重要なお知らせ】タスクマネージャー、GPU低使用率、または「PaddlePaddle works on...」といったメッセージでGPUリソースの使用状況を判断しないでください。最新GPUは極めて高い演算効率を備え、通常1秒間に数千の画像タスクを処理可能なため、低使用率は正常です。ハードウェアリソースの使用状態を確認する場合は、高速モードまたは精密モードでCPU版とGPU版の実行時間差を比較してください。両者の処理時間が近似する場合に限り、フィードバックを提出願います。
+AcceleratorON = {}を使用して加速します
+FrameCount = フレーム数
+FrameRate = フレームレート
+StartProcessFrame = 【処理中】ビデオのキーフレームの抽出を開始します…
+FinishProcessFrame = 【完了】ビデオのキーフレームの抽出が終了しました…
+StartFindSub = 【処理中】サブタイトル情報の抽出を開始します。このステップでは時間がかかる場合がありますので、お待ちください…
+FinishFindSub = 【終了】サブタイトルの抽出が完了し、元のサブタイトルファイルを生成します…
+StartDetectWaterMark = 【処理中】透かし領域を検出し、フィルタリングします
+checkWaterMark = ビデオに透かし領域が存在するかどうか、存在する場合は"y"、存在しない場合は"n"を入力してください：
+FinishDetectWaterMark = 【完了】透かし領域が正常にフィルタリングされました
+StartDeleteNonSub = 【処理中】非字幕領域を検出し、非字幕領域の内容を削除します
+FinishDeleteNonSub = 【完了】非字幕領域が削除されました
+StartGenerateSub = 【処理中】字幕ファイルの生成を開始します
+FinishGenerateSub = 【完了】字幕ファイルが正常に生成されました
+SubFrameNo = 字幕フレーム
+Elapse = 経過
+ChooseSubArea = サブタイトル領域を指定してください
+WatchPicture = 写真をチェックして透かし領域を確認してください
+QuestionDelete = この領域の字幕を削除しますか？ "y"または"Enter"を入力して削除、"n"または他の手段を入力して削除しない：
+FinishDelete = この領域の字幕は削除されました…
+FinishWaterMarkFilter = 透かし領域の字幕がフィルタリングされました…
+CheckSubArea = 写真を確認して字幕エリアが正しいことを確認してください：
+DeleteNoSubArea = 赤い枠以外の領域の字幕を削除しますか？ "y"または"Enter"を入力して削除、"n"または他の手段を入力して削除しない：
+FinishDeleteNoSubArea = 削除済み
+SubLocation = 【完了】字幕ファイルの保存場所: {}
+InputVideo = ビデオのフルパスを入力してください：
+OnnxExectionProviderNotSupportedSkipped = ONNX 実行プロバイダー: {} はサポートされていないため、スキップされました。
+OnnxExecutionProviderDetected = ONNX 実行プロバイダー検出: {}
+OnnxRuntimeNotInstall = ONNX 実行環境がインストールされていません、スキップされました。
+OcrDropNoIntercetion = 選択範囲外
+OcrDropOutOfBoxRate = 許容偏差超過: {0}%%  現在: {1}%%
+OcrDropConfidentLow = 信頼度が低い: {0}%%
+OcrResult = √ 信頼度: {1}%% 結果: {0}
+OcrResultWithDropReason = × 信頼度: {1}%% 結果: {0} 理由: {2}
+
+[TaskList]
+Pending = 待機
+Processing = 処理中
+Completed = 完了
+Failed = 失敗
+Name = ファイル
+Progress = ⠀進捗⠀
+Status = ㅤ状態ㅤ
+OpenVideoLocation = 動画の場所を開く
+OpenSubtitleLocation = 字幕の場所を開く
+ResetTaskStatus = タスク状態リセット
+DeleteTask = 削除
+Warning = 警告
+UnableToLocateFile = ファイルが見つかりません。移動または削除された可能性があります
+SubtitleNotFound = 字幕ファイルはまだ生成されていません。タスクが完了するまでお待ちください
+
+[VersionService]
+VersionInfo = 現在のバージョン: {} 最新バージョン: {}
+RequestError = {} へのアクセスに失敗しました。理由: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/ko.ini b/backend/interface/ko.ini
new file mode 100644
index 0000000..539105f
--- /dev/null
+++ b/backend/interface/ko.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = 피드백 제공
+FeedbackTitle = 피드백 제공
+FeedbackDesc = 피드백을 제공하여 개선에 도움을 주세요
+CopyrightButton = 업데이트 확인
+CopyrightTitle = About
+CopyrightDesc = ©저작권 2020, YaoFANGUK, Jason Eric (UI), 현재 버전: {}
+ProjectLinkTitle = 자막 추출기
+ProjectLinkDesc = 비디오 하드 자막 추출, srt 파일 생성. 제3자 API가 필요 없으며, 로컬에서 텍스트 인식 구현. 딥러닝 기반 비디오 자막 추출 프레임워크로, 자막 영역 감지 및 자막 내용 추출 포함.
+BasicSetting = 기본 설정
+AdvancedSetting = 고급 설정
+VideoSubFinderSetting = VideoSubFinder 설정
+DevSetting = 개발 설정
+AboutSetting = 관한
+GenerateTxt = TXT 자막 생성
+WordSegmentation = 단어 분할
+WordSegmentationDesc = 문장에 공백이 없는 문제 해결용
+HardwareAcceleration = 하드웨어 가속
+HardwareAccelerationDesc = GPU 또는 ONNX 백엔드를 사용하여 처리 속도 향상
+RecBatchNumber = 인식 배치 수
+RecBatchNumberDesc = 각 이미지에서 동시에 인식할 텍스트 상자 수. GPU 메모리가 클수록 이 값을 크게 설정할 수 있음, 기본값 6
+MaxBatchSize = 최대 배치 크기
+MaxBatchSizeDesc = DB 알고리즘이 각 배치당 인식하는 이미지 수, 기본값 10
+SubtitleArea = 자막 출현 영역
+SubtitleAreaDesc = 올바른 자막 영역을 선택하면 처리 속도가 향상됨, 기본값은 전체 화면
+ExtractFrequency = 프레임 추출 빈도
+ExtractFrequencyDesc = OCR 인식을 위해 초당 캡처할 프레임 수, 기본값 3
+TolerantPixelY = Y축 허용 픽셀 편차, 기본값 50
+TolerantPixelYDesc = 
+TolerantPixelX = X축 허용 픽셀 편차, 기본값 100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = 자막 영역 오프셋
+SubtitleAreaDeviationPixelDesc = 자막 영역의 허용 픽셀 오프셋
+WaterarkAreaNum = 워터마크 영역 수, 기본값 5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = 텍스트 유사도 임계값, 기본값 80%%
+ThresholdTextSimilarityDesc = 중복 제거 시 두 자막 줄이 동일한지 판단하는 데 사용, 값이 높을수록 엄격
+DropScore = 신뢰도 임계값, 기본값 75%%
+DropScoreDesc = 이 값보다 낮은 신뢰도의 자막은 제외
+SubtitleAreaDeviationRate = 자막 영역 허용 편차율
+SubtitleAreaDeviationRateDesc = 0은 경계 초과 불가, 0.03은 3%% 초과 허용, 기본값 0%%
+CheckUpdateOnStartup = 시작 시 업데이트 확인
+CheckUpdateOnStartupDesc = 새 버전은 더 안정적이고 더 많은 기능을 제공합니다(이 옵션을 활성화하는 것이 좋습니다)
+DebugOcrLoss = 중국어, 일본어, 한국어 문자가 누락된 자막 프레임 출력
+DebugOcrLossDesc = 간체 중국어, 번체 중국어, 일본어, 한국어만 유효. 디버그 정보는 비디오 경로/loss에 출력
+DebugNoDeleteCache = 캐시 데이터 유지
+DebugNoDeleteCacheDesc = 디버깅을 위해 캐시 데이터를 삭제하지 않음
+DeleteEmptyTimeStamp = 빈 타임스탬프 삭제
+DeleteEmptyTimeStampDesc = 자막 내용이 없는 타임스탬프 삭제
+UpdatesAvailableTitle = 사용 가능한 업데이트
+UpdatesAvailableDesc = 새 버전 {}이(가) 발견되었습니다. 지금 업데이트하시겠습니까?
+NoUpdatesAvailableTitle = 사용 가능한 업데이트 없음
+NoUpdatesAvailableDesc = 소프트웨어가 최신 버전입니다
+VideoSubFinderCpuCores = CPU 코어 수
+VideoSubFinderCpuCoresDesc = 자막 추출에 사용할 CPU 코어 수입니다. 기본값은 0(자동)이며, 모든 코어를 선택해도 더 빨라지지 않을 수 있습니다.
+VideoSubFinderDecoder = 비디오 디코더
+VideoSubFinderDecoderDesc = 다양한 비디오 호환성 요구에 사용. 기본값은 OpenCV(추천)이며, 추출이 실패할 경우 FFmpeg로 전환하세요(타임라인이 약간 어긋날 수 있음).
+ChooseDirectory = 폴더 선택
+SaveDirectory = 자막 저장 디렉터리
+SaveDirectoryDefault = 기본값: 입력 동영상의 현재 디렉터리에 저장
+
+[SubtitleArea]
+LowerPart = 하단 부분
+UpperPart = 상단 부분
+Unknown = 전체 화면
+
+[LanguageModeGUI]
+Title = Subtitle Extractor
+InterfaceLanguage = 인터페이스 언어
+SubtitleLanguage = 자막 언어
+Mode = 인식 모드
+
+[Mode]
+Auto = 자동적 인
+Fast = 빠름
+Accurate = 정확함
+
+[Language]
+CH = 중국어(간체)
+CHINESE_CHT = 중국어(번체)
+EN = 영어
+JAPAN = 일본어
+KOREAN = 한국어
+AR = 아랍어
+FRENCH = 프랑스어
+GERMAN = 독일어
+RU = 러시아어
+ES = 스페인어
+PT = 포르투갈어
+IT = 이탈리아어
+AF = 아프리칸스어
+AZ = 아제르바이잔어
+BS = 보스니아어
+CS = 체코어
+CY = 웨일스어
+DA = 덴마크어
+DE = 독일어
+ET = 에스토니아어
+FR = 프랑스어
+GA = 아일랜드어
+HR = 크로아티아어
+HU = 헝가리어
+ID = 인도네시아어
+IS = 아이슬란드어
+KU = 쿠르드어
+LA = 라틴어
+LT = 리투아니아어
+LV = 라트비아어
+MI = 마오리어
+MS = 말레이어
+MT = 몰타어
+NL = 네덜란드어
+NO = 노르웨이어
+OC = 옥시타니아어
+PI = 팔리어
+PL = 폴란드어
+RO = 루마니아어
+RS_LATIN = 세르비아어(라틴어)
+SK = 슬로바키아어
+SL = 슬로베니아어
+SQ = 알바니아어
+SV = 스웨덴어
+SW = 스와힐리어
+TL = 타갈로그어
+TR = 터키어
+UZ = 우즈베크어
+VI = 베트남어
+LATIN = 라틴어
+FA = 페르시아어
+UR = 우르두어
+RS_CYRILLIC = 세르비아어(키릴 문자)
+BE = 벨라루스어
+BG = 불가리아어
+UK = 우크라이나어
+MN = 몽골어
+ABQ = 아바자어
+ADY = 아디게어
+KBD = 카바르다어
+AVA = 아바르어
+DAR = 다르기어
+INH = 인구시어
+CHE = 체첸어
+LBE = 라크어
+LEZ = 레즈기안어
+TAB = 타바사란어
+CYRILLIC = 키릴 문자
+HI = 힌디어
+MR = 마라티어
+NE = 네팔어
+BH = 비하르어
+MAI = 마이틸리어
+ANG = 앙기카어
+BHO = 보즈푸리어
+MAH = 마가히어
+SCK = 나그푸르어
+NEW = 네와르어
+GOM = 불가리아어
+SA = 사우디아라비아어
+BGC = 하리아나어
+DEVANAGARI = 데바나가리 문자
+TA = 타밀어
+KN = 칸나다어
+UG = 위구르어
+TE = 텔루구어
+KA = 칸나다어
+
+[SubtitleExtractorGUI]
+Title = Subtitle Extractor
+Open = 열기
+AllFile = 모든 파일
+Vertical = 세로
+Horizontal = 가로
+Run = 실행
+Stop = 중지
+Setting = 설정
+OpenVideoSuccess = 비디오 열기 성공
+OpenVideoFailed = 비디오를 열 수 없습니다: {}, 형식이 호환되지 않거나 파일이 손상되었습니다
+OpenVideoFirst = 비디오을 먼저 열어주세요
+SubtitleArea = 자막 영역
+VideoPreview = 비디오 미리보기
+ErrorDuringProcessing = 처리 중 오류: {}
+DeleteSelection = 현재 활성 선택 영역 삭제
+
+[TimelineSync]
+Title = 타임라인 동기화
+Error = 오류 발생
+UnableToLocateFile = {} 파일을 찾을 수 없음: {}
+ChooseFile = 파일 선택
+SourceVideoTitle = 원본 동영상
+SourceVideoDesc = 기존 자막이 있는 동영상 파일 선택 (예: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv)
+SourceSubtitleTitle = 원본 자막
+SourceSubtitleDesc = 원본 동영상과 일치하는 자막 파일 선택 (예: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass)
+DestinationVideoTitle = 대상 동영상
+DestinationVideoDesc = 타임라인을 동기화할 동영상 파일을 선택하세요. 동기화된 자막은 대상 동영상 파일과 같은 디렉터리에 저장됩니다 (예: the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv)
+
+[Main]
+RecSubLang = 자막 언어 인식
+RecMode = 인식 모드
+IllegalPathWarning =  [경고] 프로그램이 중단되었습니다! 경로가 올바르지 않습니다! 공백과 한국어가 포함된 경로에 프로그램을 넣지 마세요! 경로 이름을 변경하고 프로그램을 다시 실행해주세요
+AcceleratorWarning = [중요 공지] 작업 관리자, GPU 저사용률 또는 "PaddlePaddle works on..." 메시지로 GPU 리소스 사용 여부를 판단하지 마십시오. 최신 GPU는 초당 수천 장의 이미지 작업을 처리할 수 있는 극한의 연산 효율성을 지니며, 낮은 사용률은 정상 현상입니다. 하드웨어 할당 상태를 확인하려면 빠른 모드나 정확한 모드에서 CPU 버전과 GPU 버전의 실행 시간 차이를 비교해 주시기 바랍니다. 두 버전의 소요 시간이 유사한 경우에만 피드백을 제출해 주십시오.
+AcceleratorON = 가속을 위해 {} 사용
+FrameCount = 프레임 수
+FrameRate = 프레임 속도
+StartProcessFrame = [처리 중] 비디오 키프레임 추출 시작...
+FinishProcessFrame = [완료] 비디오 키 프레임 추출 완료...
+StartFindSub = [처리 중] 자막 정보 추출 시작, 이 단계는 시간이 오래 걸릴 수 있으니 조금만 기다려주세요...
+FinishFindSub = [완료] 자막 추출 완료, 원본 자막 파일 생성...
+StartDetectWaterMark = [처리 중] 워터마크 영역 내용 검출 및 필터링 시작
+checkWaterMark = 워터마크 영역이 영상에 존재하는지 여부, 존재하면 y, 존재하지 않으면 n을 입력합니다:
+FinishDetectWaterMark = [완료] 워터마크 영역의 내용이 성공적으로 필터링되었습니다
+StartDeleteNonSub = [처리 중] 비자막 영역 검출을 시작하고, 비자막 영역의 내용을 삭제합니다
+FinishDeleteNonSub = [완료] 비자막 영역이 삭제되었습니다
+StartGenerateSub = [처리 중] 자막 파일 생성 시작
+FinishGenerateSub = [완료] 자막 파일 생성 성공
+SubFrameNo = 자막 프레임
+Elapse = 경과 시간
+ChooseSubArea = 자막 영역을 지정해주세요.
+WatchPicture = 이미지를 확인하고 워터마크 영역을 지정해주세요
+QuestionDelete = 해당 영역의 자막을 제거할까요? 제거하려면 "y" 또는 "Enter"를 입력하고, 제거하지 않으려면 "n" 또는 아무거나 입력합니다:
+FinishDelete = 이 영역의 자막이 삭제되었습니다...
+FinishWaterMarkFilter = 워터마크 영역이 필터링되었습니다...
+CheckSubArea = 자막 영역이 올바른지 이미지를 확인해주세요.
+DeleteNoSubArea = 빨간색 상자 영역 밖의 자막이 제거되었나요? 제거하려면 "y" 또는 "Enter"를 입력하고, 제거하지 않으려면 "n" 또는 아무거나 입력합니다:
+FinishDeleteNoSubArea = 제거 완료
+SubLocation = [완료] 자막 파일 생성 위치: {}
+InputVideo = 비디오의 전체 경로를 입력하세요:
+OnnxExectionProviderNotSupportedSkipped = ONNX 실행 제공자: {} 지원되지 않음, 이미 건너뛰었습니다.
+OnnxExecutionProviderDetected = ONNX 실행 제공자 감지됨: {}
+OnnxRuntimeNotInstall = ONNX 실행 환경이 설치되지 않음, 건너뛰었습니다.
+OcrDropNoIntercetion = 선택 영역 밖
+OcrDropOutOfBoxRate = 허용 편차 초과: {0}%%  현재: {1}%%
+OcrDropConfidentLow = 신뢰도 낮음: {0}%%
+OcrResult = √ 신뢰도: {1}%% 결과: {0}
+OcrResultWithDropReason = × 신뢰도: {1}%% 결과: {0} 사유: {2}
+
+[TaskList]
+Pending = 대기
+Processing = 처리중
+Completed = 완료
+Failed = 실패
+Name = 파일
+Progress = ⠀진행⠀
+Status = ㅤ상태ㅤ
+OpenVideoLocation = 비디오 위치 열기
+OpenSubtitleLocation = 자막 위치 열기
+ResetTaskStatus = 작업 상태 재설정
+DeleteTask = 삭제
+Warning = 경고
+UnableToLocateFile = 파일을 찾을 수 없습니다. 이동되거나 삭제되었을 수 있습니다
+SubtitleNotFound = 자막 파일이 아직 생성되지 않았습니다. 작업이 완료될 때까지 기다려주세요
+
+[VersionService]
+VersionInfo = 현재 버전: {} 최신 버전: {}
+RequestError = {} 에 접근하지 못했습니다. 원인: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/tr.ini b/backend/interface/tr.ini
new file mode 100644
index 0000000..82d57d4
--- /dev/null
+++ b/backend/interface/tr.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = Geri Bildirim
+FeedbackTitle = Geri Bildirim
+FeedbackDesc = Geri bildirimde bulunarak gelişmemize yardımcı olun
+CopyrightButton = Güncellemeleri Kontrol Et
+CopyrightTitle = Hakkında
+CopyrightDesc = ©Telif Hakkı 2020, YaoFANGUK, Jason Eric (UI), Mevcut sürüm: {}
+ProjectLinkTitle = Altyazı Çıkarıcı
+ProjectLinkDesc = Videodan gömülü altyazı çıkarma, srt dosyaları oluşturma. Üçüncü taraf API gerektirmez, yerel metin tanıma. Altyazı alanı tespiti ve altyazı içeriği çıkarma dahil olmak üzere derin öğrenmeye dayalı bir video altyazı çıkarma çerçevesi.
+BasicSetting = Temel Ayarlar
+AdvancedSetting = Gelişmiş Ayarlar
+VideoSubFinderSetting = VideoSubFinder Ayarları
+DevSetting = Geliştirici Ayarları
+AboutSetting = Hakkında
+GenerateTxt = TXT Altyazı Oluştur
+WordSegmentation = Kelime Bölütleme
+WordSegmentationDesc = Boşluk içermeyen cümleleri çözmek için kullanılır
+HardwareAcceleration = Donanım Hızlandırma
+HardwareAccelerationDesc = Hızlandırılmış işleme için GPU veya ONNX arka ucunu kullanın
+RecBatchNumber = Tanıma Yığın Sayısı
+RecBatchNumberDesc = Her resimde aynı anda tanınan metin kutusu sayısı. GPU belleği ne kadar büyükse, bu değer o kadar büyük ayarlanabilir, varsayılan 6'dır
+MaxBatchSize = Maksimum Yığın Boyutu
+MaxBatchSizeDesc = DB algoritmasının her yığınının kaç resmi tanıdığı, varsayılan 10'dur
+SubtitleArea = Altyazı Alanı
+SubtitleAreaDesc = Doğru altyazı alanını seçmek işlem hızını artırabilir, varsayılan tam ekrandır
+ExtractFrequency = Kare Çıkarma Sıklığı
+ExtractFrequencyDesc = OCR tanıma için saniyede kaç kare yakalanacağı, varsayılan 3'tür
+TolerantPixelY = Y ekseni Piksel Toleransı, varsayılan 50
+TolerantPixelYDesc = 
+TolerantPixelX = X ekseni Piksel Toleransı, varsayılan 100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = Altyazı Alanı Sapması
+SubtitleAreaDeviationPixelDesc = Altyazı alanı için izin verilen piksel sapması
+WaterarkAreaNum = Filigran Alanı Sayısı, varsayılan 5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = Metin Benzerlik Eşiği, varsayılan %%80
+ThresholdTextSimilarityDesc = Yinelenenleri kaldırırken iki altyazı satırının aynı olup olmadığını belirlemek için kullanılır, daha yüksek değer daha katı anlamına gelir
+DropScore = Güven Eşiği, varsayılan %%75
+DropScoreDesc = Güveni bu değerin altında olan altyazılar atılacaktır
+SubtitleAreaDeviationRate = Altyazı Alanı Sapma Oranı
+SubtitleAreaDeviationRateDesc = 0 sınır geçişine izin verilmediği anlamına gelir, 0.03 %%3'lük geçişe izin verildiği anlamına gelir, varsayılan %%0
+CheckUpdateOnStartup = Başlangıçta güncellemeleri kontrol et
+CheckUpdateOnStartupDesc = Yeni sürümler daha kararlı ve daha fazla özelliğe sahiptir (bu seçeneğin etkinleştirilmesi önerilir)
+DebugOcrLoss = Çince, Japonca veya Korece karakterleri eksik olan altyazı karelerini çıktıla
+DebugOcrLossDesc = Yalnızca Basitleştirilmiş Çince, Geleneksel Çince, Japonca, Korece için geçerlidir. Hata ayıklama bilgileri şu konuma yazdırılır: video_yolu/loss
+DebugNoDeleteCache = Önbellek Verilerini Sakla
+DebugNoDeleteCacheDesc = Hata ayıklama amacıyla önbellek verilerini silme
+DeleteEmptyTimeStamp = Boş Zaman Damgalarını Sil
+DeleteEmptyTimeStampDesc = Altyazı içeriği olmayan zaman damgalarını sil
+UpdatesAvailableTitle = Güncellemeler Mevcut
+UpdatesAvailableDesc = Yeni sürüm {} bulundu, şimdi güncellensin mi?
+NoUpdatesAvailableTitle = Güncelleme Yok
+NoUpdatesAvailableDesc = Yazılım güncel
+VideoSubFinderCpuCores = CPU Çekirdekleri
+VideoSubFinderCpuCoresDesc = Altyazı çıkarma için kullanılan CPU çekirdeği sayısı. Varsayılan 0'dır (otomatik). Tüm çekirdekleri kullanmak daha hızlı olmayabilir.
+VideoSubFinderDecoder = Video Çözücü
+VideoSubFinderDecoderDesc = Farklı video uyumluluk ihtiyaçları için. Varsayılan OpenCV'dir (önerilir). Çıkarma başarısız olursa FFmpeg'e geçin (hafif zaman çizelgesi kaymasına neden olabilir).
+ChooseDirectory = Klasör Seç
+SaveDirectory = Altyazı Kayıt Dizini
+SaveDirectoryDefault = Varsayılan: giriş videosunun bulunduğu dizine kaydet
+
+[SubtitleArea]
+LowerPart = Alt Kısım
+UpperPart = Üst Kısım
+Unknown = Tam Ekran
+
+[LanguageModeGUI]
+Title = Altyazı Çıkarıcı
+InterfaceLanguage = Arayüz Dili
+SubtitleLanguage = Altyazı Dili
+Mode = Tanıma Modu
+
+[Mode]
+Auto = Otomatik
+Fast = Hızlı
+Accurate = Doğruluk
+
+[Language]
+CH = Basitleştirilmiş Çince
+CHINESE_CHT = Geleneksel Çince
+EN = İngilizce
+JAPAN = Japonca
+KOREAN = Korece
+AR = Arapça
+FRENCH = Fransızca
+GERMAN = Almanca
+RU = Rusça
+ES = İspanyolca
+PT = Portekizce
+IT = İtalyanca
+AF = Afrikaanca
+AZ = Azerice
+BS = Boşnakça
+CS = Çekçe
+CY = Galce
+DA = Danca
+DE = Almanca
+ET = Estonca
+FR = Fransızca
+GA = İrlandaca
+HR = Hırvatça
+HU = Macarca
+ID = Endonezce
+IS = İzlandaca
+KU = Kürtçe
+LA = Latince
+LT = Litvanyaca
+LV = Letonca
+MI = Maorice
+MS = Malayca
+MT = Maltaca
+NL = Felemenkçe
+NO = Norveççe
+OC = Oksitanca
+PI = Pali
+PL = Lehçe
+RO = Rumence
+RS_LATIN = Sırpça(latin)
+SK = Slovakça
+SL = Slovence
+SQ = Arnavutça
+SV = İsveççe
+SW = Svahili
+TL = Tagalogca
+TR = Türkçe
+UZ = Özbekçe
+VI = Vietnamca
+LATIN = Latince
+FA = Farsça
+UR = Urduca
+RS_CYRILLIC = Sırpça(kiril)
+BE = Belarusça
+BG = Bulgarca
+UK = Ukraynaca
+MN = Moğolca
+ABQ = Abazaca
+ADY = Adigece
+KBD = Kabardeyce
+AVA = Avarca
+DAR = Dargince
+INH = İnguşça
+CHE = Çeçence
+LBE = Lakça
+LEZ = Lezgice
+TAB = Tabasaranca
+CYRILLIC = Kiril
+HI = Hintçe
+MR = Marathice
+NE = Nepalce
+BH = Bihari
+MAI = Maithili
+ANG = Angika
+BHO = Bhojpuri
+MAH = Magahi
+SCK = Nagpur
+NEW = Newari
+GOM = Goan Konkani
+SA = Sanskritçe
+BGC = Haryanvi
+DEVANAGARI = Devanagari
+TA = Tamilce
+KN = Kannada
+UG = Uygurca
+TE = Teluguca
+KA = Kannada
+
+[SubtitleExtractorGUI]
+Title = Altyazı Çıkarıcı
+Open = Aç
+AllFile = Tüm Dosyalar
+Vertical = Dikey
+Horizontal = Yatay
+Run = Çalıştır
+Stop = Durdur
+Setting = Ayarlar
+OpenVideoSuccess = Video Başarıyla Açıldı
+OpenVideoFailed = Video açılamadı: {}, uyumsuz format veya dosya bozuk
+OpenVideoFirst = Lütfen Önce Video Açın
+SubtitleArea = Altyazı Alanı
+VideoPreview = Video Önizleme
+ErrorDuringProcessing = İşlem sırasında hata: {}
+DeleteSelection = Seçimi Sil
+
+[TimelineSync]
+Title = Zaman Çizelgesi Senkronizasyonu
+Error = Hata
+UnableToLocateFile = {} dosyası bulunamadı: {}
+ChooseFile = Dosya Seç
+SourceVideoTitle = Kaynak Video
+SourceVideoDesc = Mevcut altyazıları olan bir video dosyası seçin, örn: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv
+SourceSubtitleTitle = Kaynak Altyazı
+SourceSubtitleDesc = Kaynak videoyla eşleşen bir altyazı dosyası seçin, örn: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass
+DestinationVideoTitle = Hedef Video
+DestinationVideoDesc = Zaman çizelgesini senkronize etmek için video dosyasını seçin. Senkronize edilen altyazılar, hedef video dosyasıyla aynı dizine kaydedilecektir, örn: the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv
+
+[Main]
+RecSubLang = Altyazı Dili
+RecMode = Mod
+IllegalPathWarning = [Uyarı] Program kesildi! Yol geçersiz! Lütfen programı boşluk ve Çince karakterler içeren bir yola koymayın! Lütfen program yolu adını değiştirin ve programı yeniden çalıştırın
+AcceleratorWarning = [Önemli Uyarı] Programın GPU kaynaklarını kullanıp kullanmadığını belirlemek için Görev Yöneticisi'ne, düşük GPU kullanımına veya "PaddlePaddle şurada çalışıyor..." gibi mesajlara güvenmeyin. Modern GPU'lar aşırı hesaplama verimliliği için tasarlanmıştır ve genellikle saniyede binlerce görüntü görevini işleyebilir, bu da düşük kullanım oranlarını normal bir durum haline getirir. Donanım kaynağı tahsisini doğrulamak için, lütfen Hızlı veya Doğru modda CPU ve GPU sürümleri arasındaki yürütme süresi farklarını karşılaştırın. Yalnızca çalışma süreleri karşılaştırılabilir ise geri bildirim gönderin.
+AcceleratorON = Hızlandırma için {} kullanılıyor
+FrameCount = Kare Sayısı
+FrameRate = Kare Hızı
+StartProcessFrame = [İşleniyor] Video anahtar kareleri çıkarılmaya başlanıyor...
+FinishProcessFrame = [Bitti] Video anahtar kareleri çıkarma tamamlandı...
+StartFindSub = [İşleniyor] Altyazı bilgileri çıkarılmaya başlanıyor, bu adım uzun sürebilir, lütfen sabırlı olun...
+FinishFindSub = [Bitti] Altyazı çıkarma tamamlandı, orijinal altyazı dosyası oluşturuluyor...
+StartDetectWaterMark = [İşleniyor] Filigran alanı algılanmaya ve filtrelenmeye başlanıyor
+checkWaterMark = Videoda filigran alanı var mı, varsa "e" girin, yoksa "h" girin:
+FinishDetectWaterMark = [Bitti] Filigran alanı başarıyla filtrelendi
+StartDeleteNonSub = [İşleniyor] Altyazı olmayan alan algılanmaya ve bu alandaki içerik silinmeye başlanıyor
+FinishDeleteNonSub = [Bitti] Altyazı olmayan alan silindi
+StartGenerateSub = [İşleniyor] Altyazı dosyaları oluşturulmaya başlanıyor
+FinishGenerateSub = [Bitti] Altyazı dosyası başarıyla oluşturuldu
+SubFrameNo = Altyazı karesi
+Elapse = geçen süre
+ChooseSubArea = Lütfen altyazı alanını belirtin
+WatchPicture = Filigran alanını belirlemek için lütfen resmi kontrol edin
+QuestionDelete = Bu alandaki altyazılar kaldırılsın mı? Kaldırmak için "e" veya "Enter" tuşuna, kaldırmamak için "h" veya başka bir tuşa basın:
+FinishDelete = Bu alandaki altyazılar silindi...
+FinishWaterMarkFilter = Filigran alanındaki altyazılar filtrelendi...
+CheckSubArea = Altyazı alanının doğru olduğundan emin olmak için lütfen resmi kontrol edin:
+DeleteNoSubArea = Kırmızı kutu dışındaki altyazılar kaldırılsın mı? Kaldırmak için "e" veya "Enter" tuşuna, kaldırmamak için "h" veya başka bir tuşa basın:
+FinishDeleteNoSubArea = Kaldırıldı
+SubLocation = [Bitti] Altyazı dosyasının konumu: {}
+InputVideo = Lütfen videonun tam yolunu girin:
+OnnxExectionProviderNotSupportedSkipped = ONNX Yürütme Sağlayıcısı: {} desteklenmiyor, atlandı.
+OnnxExecutionProviderDetected=Algılanan ONNX yürütme sağlayıcısı: {}
+OnnxRuntimeNotInstall = ONNX çalışma zamanı ortamı yüklü değil, atlandı.
+OcrDropNoIntercetion = Seçim dışı
+OcrDropOutOfBoxRate = İzin verilen sapmayı aşıyor: %%{0}  Mevcut: %%{1}
+OcrDropConfidentLow = Güven eşiğin altında: %%{0}
+OcrResult = √ Güven: %%{1} Sonuç: {0}
+OcrResultWithDropReason = × Güven: %%{1} Sonuç: {0} Atlanma nedeni: {2}
+
+[TaskList]
+Pending = Bekliyor
+Processing = Çalışıyor
+Completed = Tamamlandı
+Failed = Başarısız
+Name = Dosya
+Progress = İlerleme
+Status = Durum
+OpenVideoLocation = Video Konumunu Aç
+OpenSubtitleLocation = Altyazı Konumunu Aç
+ResetTaskStatus = Görevi Sıfırla
+DeleteTask = Görevi Sil
+Warning = Uyarı
+UnableToLocateFile = Dosya bulunamadı, taşınmış veya silinmiş olabilir
+SubtitleNotFound = Altyazı dosyası henüz oluşturulmadı, lütfen görevin tamamlanmasını bekleyin
+
+[VersionService]
+VersionInfo = Mevcut sürüm: {} Son sürüm: {}
+RequestError = {} adresine erişilemedi, sebep: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/interface/vi.ini b/backend/interface/vi.ini
new file mode 100644
index 0000000..b3fcea4
--- /dev/null
+++ b/backend/interface/vi.ini
@@ -0,0 +1,264 @@
+[Setting]
+FeedbackButton = Gửi phản hồi
+FeedbackTitle = Gửi phản hồi
+FeedbackDesc = Giúp chúng tôi cải thiện bằng cách gửi phản hồi
+CopyrightButton = Kiểm tra cập nhật
+CopyrightTitle = About
+CopyrightDesc = ©Bản quyền 2020, YaoFANGUK, Jason Eric (UI), Phiên bản hiện tại: {}
+ProjectLinkTitle = Trích xuất phụ đề
+ProjectLinkDesc = Trích xuất phụ đề cứng từ video, tạo file srt. Không cần API bên thứ ba, nhận dạng văn bản cục bộ. Một framework trích xuất phụ đề video dựa trên học sâu, bao gồm phát hiện vùng phụ đề và trích xuất nội dung phụ đề.
+BasicSetting = Cài đặt cơ bản
+AdvancedSetting = Cài đặt nâng cao
+VideoSubFinderSetting = Cài đặt VideoSubFinder
+DevSetting = Cài đặt phát triển
+AboutSetting = Liên quan đến
+GenerateTxt = Tạo phụ đề TXT
+WordSegmentation = Phân đoạn từ
+WordSegmentationDesc = Dùng để giải quyết vấn đề câu không có khoảng trắng
+HardwareAcceleration = Tăng tốc phần cứng
+HardwareAccelerationDesc = Sử dụng GPU hoặc backend ONNX để xử lý nhanh hơn
+RecBatchNumber = Số lượng batch nhận dạng
+RecBatchNumberDesc = Số lượng hộp văn bản được nhận dạng đồng thời trong mỗi hình ảnh. Bộ nhớ GPU càng lớn, giá trị này có thể đặt càng lớn, mặc định là 6
+MaxBatchSize = Kích thước batch tối đa
+MaxBatchSizeDesc = Thuật toán DB nhận dạng bao nhiêu hình ảnh mỗi batch, mặc định là 10
+SubtitleArea = Khu vực phụ đề
+SubtitleAreaDesc = Chọn đúng khu vực phụ đề có thể cải thiện tốc độ xử lý, mặc định là toàn màn hình
+ExtractFrequency = Tần suất trích xuất khung hình
+ExtractFrequencyDesc = Bao nhiêu khung hình được chụp mỗi giây để nhận dạng OCR, mặc định là 3
+TolerantPixelY = Dung sai pixel trục Y, mặc định là 50
+TolerantPixelYDesc = 
+TolerantPixelX = Dung sai pixel trục X, mặc định là 100
+TolerantPixelXDesc = 
+SubtitleAreaDeviationPixel = Độ lệch khu vực phụ đề
+SubtitleAreaDeviationPixelDesc = Độ lệch pixel cho phép cho khu vực phụ đề
+WaterarkAreaNum = Số lượng khu vực watermark, mặc định là 5
+WaterarkAreaNumDesc = 
+ThresholdTextSimilarity = Ngưỡng tương đồng văn bản, mặc định là 80%%
+ThresholdTextSimilarityDesc = Dùng để xác định hai dòng phụ đề có giống nhau khi loại bỏ trùng lặp, giá trị càng cao càng nghiêm ngặt
+DropScore = Ngưỡng độ tin cậy, mặc định là 75%%
+DropScoreDesc = Phụ đề có độ tin cậy thấp hơn giá trị này sẽ bị loại bỏ
+SubtitleAreaDeviationRate = Tỷ lệ độ lệch khu vực phụ đề
+SubtitleAreaDeviationRateDesc = 0 nghĩa là không cho phép vượt ranh giới, 0.03 nghĩa là cho phép vượt 3%%, mặc định là 0%%
+CheckUpdateOnStartup = Kiểm tra cập nhật khi khởi động
+CheckUpdateOnStartupDesc = Phiên bản mới sẽ ổn định hơn và có nhiều tính năng hơn (nên bật tùy chọn này)
+DebugOcrLoss = Xuất khung phụ đề thiếu ký tự Trung, Nhật, Hàn
+DebugOcrLossDesc = Chỉ có hiệu lực với tiếng Trung giản thể, tiếng Trung phồn thể, tiếng Nhật, tiếng Hàn. Thông tin gỡ lỗi sẽ được xuất ra: đường_dẫn_video/loss
+DebugNoDeleteCache = Giữ dữ liệu cache
+DebugNoDeleteCacheDesc = Không xóa dữ liệu cache để phục vụ gỡ lỗi
+DeleteEmptyTimeStamp = Xóa dấu thời gian trống
+DeleteEmptyTimeStampDesc = Xóa dấu thời gian không có nội dung phụ đề
+UpdatesAvailableTitle = Có bản cập nhật mới
+UpdatesAvailableDesc = Phát hiện phiên bản mới {}, cập nhật ngay bây giờ?
+NoUpdatesAvailableTitle = Không có bản cập nhật mới
+NoUpdatesAvailableDesc = Phần mềm đã là phiên bản mới nhất
+VideoSubFinderCpuCores = Số lõi CPU
+VideoSubFinderCpuCoresDesc = Số lõi CPU dùng để tách phụ đề. Mặc định là 0 (tự động). Dùng tất cả lõi không phải lúc nào cũng nhanh hơn.
+VideoSubFinderDecoder = Bộ giải mã video
+VideoSubFinderDecoderDesc = Dùng cho các nhu cầu tương thích video khác nhau. Mặc định là OpenCV (khuyến nghị). Chuyển sang FFmpeg nếu tách phụ đề thất bại (có thể lệch nhẹ thời gian).
+ChooseDirectory = Chọn Thư Mục
+SaveDirectory = Thư mục lưu phụ đề
+SaveDirectoryDefault = Mặc định: lưu vào thư mục hiện tại của video đầu vào
+
+[TimelineSync]
+Title = Đồng bộ Timeline
+Error = Lỗi
+UnableToLocateFile = Không tìm thấy tệp {}: {}
+ChooseFile = Chọn Tệp
+SourceVideoTitle = Video Nguồn
+SourceVideoDesc = Chọn tệp video có sẵn phụ đề, ví dụ: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.mkv
+SourceSubtitleTitle = Phụ đề Nguồn
+SourceSubtitleDesc = Chọn tệp phụ đề phù hợp với video nguồn, ví dụ: The.Librarians.US.S03E07.720p.HDTV.x264-AVS.ass
+DestinationVideoTitle = Video Đích
+DestinationVideoDesc = Chọn tệp video cần đồng bộ timeline. Phụ đề sau khi đồng bộ sẽ được lưu vào cùng thư mục với tệp video đích, ví dụ: the.librarians.us.s03e07.1080p.bluray.x264-sprinter.mkv
+
+[SubtitleArea]
+LowerPart = Phần dưới
+UpperPart = Phần trên
+Unknown = Toàn màn hình
+
+[LanguageModeGUI]
+Title = Trích xuất phụ đề
+InterfaceLanguage = Ngôn ngữ giao diện
+SubtitleLanguage = Ngôn ngữ phụ đề
+Mode = Chế độ nhận dạng
+
+[Mode]
+Auto = tự động
+Fast = nhanh
+Accurate = chính xác
+
+[Language]
+CH = Tiếng Trung giản thể
+CHINESE_CHT = Tiếng Trung phồn thể
+EN = Tiếng Anh
+JAPAN = Tiếng Nhật
+KOREAN = Tiếng Hàn
+AR = Tiếng Ả Rập
+FRENCH = Tiếng Pháp
+GERMAN = Tiếng Đức
+RU = Tiếng Nga
+ES = Tiếng Tây Ban Nha
+PT = Tiếng Bồ Đào Nha
+IT = Tiếng Ý
+AF = Afrikaans
+AZ = Azerbaijani
+BS = Bosnian
+CS = Tiếng Séc
+CY = Welsh
+DA = Danish
+DE = Tiếng Đức
+ET = Estonian
+FR = Tiếng Pháp
+GA = Irish
+HR = Croatian
+HU = Hungarian
+ID = Tiếng Indonesia
+IS = Icelandic
+KU = Kurdish
+LA = Tiếng La Mã
+LT = Lithuanian
+LV = Latvian
+MI = Mã Lai
+MS = Mã Lai
+MT = Maltese
+NL = Dutch
+NO = Norwegian
+OC = Occitan
+PI = Pali
+PL = Tiếng Ba Lan
+RO = Tiếng Romania
+RS_LATIN = Serbian (Latinh)
+SK = Slovak
+SL = Slovenian
+SQ = Albanian
+SV = Swedish
+SW = Swahili
+TL = Tagalog
+TR = Tiếng Thổ Nhĩ Kỳ
+UZ = Uzbek
+VI = Tiếng Việt
+LATIN = Tiếng La Mã
+FA = Tiếng Ba Tư
+UR = Tiếng Urdu
+RS_CYRILLIC = Serbian (Cyrillic)
+BE = Belarussian
+BG = Bulgarian
+UK = Ukraina
+MN = Mongol
+ABQ = Abaza
+ADY = Adyghe
+KBD = Kabardian
+AVA = Avar
+DAR = Dargwa
+INH = Ingush
+CHE = Chechen
+LBE = Lak
+LEZ = Lezghian
+TAB = Tabassaran
+CYRILLIC = Cyrillic
+HI = Hindi
+MR = Marathi
+NE = Nepali
+BH = Bihari
+MAI = Maithili
+ANG = Angika
+BHO = Bhojpuri
+MAH = Magahi
+SCK = Nagpur
+NEW = Newari
+GOM = Goan Konkani
+SA = Ả Rập Xê Út
+BGC = Haryanvi
+DEVANAGARI = Devanagari
+TA = Tamil
+KN = Kannada
+UG = Uyghur
+TE = Telugu
+KA = Kannada
+
+[SubtitleExtractorGUI]
+Title = Trích xuất phụ đề
+Open = Mở
+AllFile = Tất cả tệp
+Vertical = Thẳng đứng
+Horizontal = Ngang
+Run = Chạy
+Stop = Dừng
+Setting = Cài đặt
+OpenVideoSuccess = Mở video thành công
+OpenVideoFailed = Không thể mở video: {}, định dạng không tương thích hoặc tệp bị hỏng
+OpenVideoFirst = Xin mở video trước đã
+SubtitleArea = Khu vực phụ đề
+VideoPreview = Xem trước video
+ErrorDuringProcessing = Lỗi khi xử lý: {}
+DeleteSelection = Xóa lựa chọn
+
+[Main]
+RecSubLang = Ngôn ngữ phụ đề
+RecMode = Chế độ
+IllegalPathWarning = [Cảnh báo] Chương trình bị gián đoạn! Đường dẫn không hợp lệ! Xin đừng để chương trình trong đường dẫn có dấu cách và tiếng Trung! ! ! Xin sửa tên đường dẫn chương trình và chạy lại chương trình
+AcceleratorWarning = [Thông báo quan trọng] Không sử dụng Task Manager, tỷ lệ sử dụng GPU thấp hoặc thông báo như "PaddlePaddle works on..." để đánh giá việc dùng tài nguyên GPU. Card đồ họa hiện đại có hiệu suất xử lý cực cao, xử lý được hàng ngàn ảnh mỗi giây nên tỷ lệ sử dụng thấp là bình thường. Để kiểm tra trạng thái phân bổ phần cứng, hãy so sánh thời gian chạy giữa phiên bản CPU và GPU trong chế độ nhanh hoặc chế độ chính xác. Chỉ phản hồi khi thời gian xử lý của hai phiên bản gần như tương đương.
+AcceleratorON = Sử dụng {} để tăng tốc
+FrameCount = Số khung hình
+FrameRate = Tốc độ khung hình
+StartProcessFrame = [Đang xử lý] Bắt đầu trích xuất keyframe video...
+FinishProcessFrame = [Đã hoàn thành] Đã hoàn thành việc trích xuất key frame video...
+StartFindSub = [Đang xử lý] Bắt đầu tìm thông tin phụ đề, bước này có thể mất nhiều thời gian, xin kiên nhẫn...
+FinishFindSub = [Đã hoàn thành] Hoàn thành việc tìm kiếm phụ đề, sinh ra tệp nguyên bản của phụ đề...
+StartDetectWaterMark = [Đang xử lý] Bắt đầu phát hiện và lọc khu vực watermark
+checkWaterMark = Có watermark trong video không? Nếu có, nhập "y", nếu không có, nhập "n":
+FinishDetectWaterMark = [Đã hoàn thành] Khu vực watermark đã được lọc thành công
+StartDeleteNonSub = [Đang xử lý] Bắt đầu tìm khu vực không có phụ đề và xóa nội dung trong khu vực không có phụ đề
+FinishDeleteNonSub = [Đã hoàn thành] Khu vực không có phụ đề đã được xóa
+StartGenerateSub = [Đang xử lý] Bắt đầu tạo tệp phụ đề
+FinishGenerateSub = [Đã hoàn thành] Tạo tệp phụ đề thành công
+SubFrameNo = Khung hình phụ đề
+Elapse = thời gian trôi qua
+ChooseSubArea = Xin chỉ định khu vực phụ đề
+WatchPicture = Xin kiểm tra hình ảnh để xác định khu vực watermark
+QuestionDelete = Có xóa phụ đề trong khu vực này? Nhập "y" hoặc "Enter" để xóa, nhập "n" hoặc khác có nghĩa là không xóa:
+FinishDelete = Phụ đề trong khu vực này đã được xóa...
+FinishWaterMarkFilter = Các phụ đề trong khu vực watermark đã được lọc...
+CheckSubArea = Xin kiểm tra hình ảnh để chắc chắn rằng khu vực phụ đề là đúng:
+DeleteNoSubArea = Có xóa phụ đề ngoài khu vực hộp đỏ? Nhập "y" hoặc "Enter" để xóa, nhập "n" hoặc khác có nghĩa là không xóa:
+FinishDeleteNoSubArea = Đã xóa
+SubLocation = [Hoàn tất] Vị trí tệp phụ đề: {}
+InputVideo = Xin nhập đường dẫn đầy đủ của video：
+OnnxExectionProviderNotSupportedSkipped = Nhà cung cấp thực thi ONNX: {} không được hỗ trợ, đã bỏ qua.
+OnnxExecutionProviderDetected = Đã phát hiện nhà cung cấp thực thi ONNX: {}
+OnnxRuntimeNotInstall = Môi trường thực thi ONNX chưa được cài đặt, đã bỏ qua.
+OcrDropNoIntercetion = Ngoài vùng chọn
+OcrDropOutOfBoxRate = Vượt sai số cho phép: {0}%%  Hiện tại: {1}%%
+OcrDropConfidentLow = Độ tin cậy thấp: {0}%%
+OcrResult = √ Độ tin cậy: {1}%% Kết quả: {0}
+OcrResultWithDropReason = × Độ tin cậy: {1}%% Kết quả: {0} Lý do: {2}
+
+[TaskList]
+Pending = Chờ xử lý
+Processing = Đang xử lý
+Completed = Hoàn thành
+Failed = Thất bại
+Name = Tệp
+Progress = Tiến độ
+Status = Trạng thái
+OpenVideoLocation = Mở vị trí video
+OpenSubtitleLocation = Mở vị trí phụ đề
+ResetTaskStatus = Đặt lại trạng thái
+DeleteTask = Xóa
+Warning = Cảnh báo
+UnableToLocateFile = Không tìm thấy tệp, có thể đã bị di chuyển hoặc xóa
+SubtitleNotFound = Tệp phụ đề chưa được tạo, vui lòng đợi tác vụ hoàn thành
+
+[VersionService]
+VersionInfo = Phiên bản hiện tại: {} Phiên bản mới nhất: {}
+RequestError = Không thể truy cập {}, lý do: {}
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español
+Turkish = Türkçe
\ No newline at end of file
diff --git a/backend/main.py b/backend/main.py
new file mode 100644
index 0000000..447616e
--- /dev/null
+++ b/backend/main.py
@@ -0,0 +1,1114 @@
+# -*- coding: utf-8 -*-
+"""
+@Author  : Fang Yao
+@Time    : 2021/3/24 9:28 上午
+@FileName: main.py
+@desc: 主程序入口文件
+"""
+import os
+import re
+import random
+import shutil
+import traceback
+from collections import Counter, namedtuple
+import unicodedata
+from threading import Thread
+from pathlib import Path
+import cv2
+from Levenshtein import ratio
+from PIL import Image
+from numpy import average, dot, linalg
+from tqdm import tqdm
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+import subprocess
+from backend.config import *
+from backend.tools.hardware_accelerator import HardwareAccelerator
+from backend.tools import reformat
+from backend.tools.ocr import OcrRecogniser, get_coordinates
+from backend.tools import subtitle_ocr
+from backend.tools.paddle_model_config import PaddleModelConfig
+from backend.tools.process_manager import ProcessManager
+from backend.tools.subtitle_detect import SubtitleDetect
+from backend.bean.subtitle_area import SubtitleArea
+import threading
+import platform
+import multiprocessing
+import time
+import pysrt
+
+class SubtitleExtractor:
+    """
+    视频字幕提取类
+    """
+
+    def __init__(self, vd_path):
+        # 线程锁
+        self.lock = threading.RLock()
+        # 用户指定的字幕区域位置
+        self.sub_area = None
+        self.hardware_accelerator = HardwareAccelerator.instance()
+        # 是否使用硬件加速
+        self.hardware_accelerator.set_enabled(config.hardwareAcceleration.value)
+        self.model_config = PaddleModelConfig(self.hardware_accelerator)
+        # 创建字幕检测对象
+        self.sub_detector = SubtitleDetect()
+        # 视频路径
+        self.video_path = vd_path
+        self.video_cap = cv2.VideoCapture(vd_path)
+        # 通过视频路径获取视频名称
+        self.vd_name = Path(self.video_path).stem
+        # 临时存储文件夹
+        self.temp_output_dir = os.path.join(os.path.dirname(BASE_DIR), 'output', str(self.vd_name))
+        # 视频帧总数
+        self.frame_count = self.video_cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        # 视频帧率
+        self.fps = self.video_cap.get(cv2.CAP_PROP_FPS)
+        # 视频尺寸
+        self.frame_height = int(self.video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.frame_width = int(self.video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        # 提取的视频帧储存目录
+        self.frame_output_dir = os.path.join(self.temp_output_dir, 'frames')
+        # 提取的字幕文件存储目录
+        self.subtitle_output_dir = os.path.join(self.temp_output_dir, 'subtitle')
+        # 定义是否使用vsf提取字幕帧
+        self.use_vsf = False
+        # 定义vsf的字幕输出路径
+        self.vsf_subtitle = os.path.join(self.subtitle_output_dir, 'raw_vsf.srt')
+        # 提取的原始字幕文本存储路径
+        self.raw_subtitle_path = os.path.join(self.subtitle_output_dir, 'raw.txt')
+        # 定义输出字幕文件路径
+        self.subtitle_output_path = os.path.splitext(self.video_path)[0] + '.srt'
+        # 自定义ocr对象
+        self.ocr = None
+        # 总处理进度（帧提取100 + OCR100 + 后处理100 = 300）
+        self.progress_total = 300
+        # 视频帧提取进度
+        self.progress_frame_extract = 0
+        # OCR识别进度
+        self.progress_ocr = 0
+        # 后处理进度
+        self.progress_post = 0
+        # 是否完成
+        self.isFinished = False
+        # 字幕OCR任务队列
+        self.subtitle_ocr_task_queue = None
+        # 字幕OCR进度队列
+        self.subtitle_ocr_progress_queue = None
+        # vsf运行状态
+        self.vsf_running = False
+        # 进度监听器列表
+        self.progress_listeners = []
+
+    def run(self):
+        """
+        运行整个提取视频的步骤
+        """
+        # 记录开始运行的时间
+        start_time = time.time()
+        self.lock.acquire()
+        # 重置进度条
+        self.update_progress(ocr=0, frame_extract=0, post=0)
+        self.append_output('-----------------------------')
+        # 打印识别语言与识别模式
+        self.append_output(f"  {tr['Main']['RecSubLang']}：{config.language.value}  |  {tr['Main']['RecMode']}：{config.mode.value}")
+        # 如果使用GPU加速，则打印GPU加速提示
+        if self.hardware_accelerator.has_accelerator():
+            self.append_output(f"  {tr['Main']['AcceleratorON'].format(self.hardware_accelerator.accelerator_name)}")
+
+        # 打印视频帧数与帧率
+        self.append_output(f"  {tr['Main']['FrameCount']}：{self.frame_count}"
+              f"  |  {tr['Main']['FrameRate']}：{self.fps}")
+        # 打印加载模型信息
+        self.append_output(f"  DET: {os.path.basename(self.model_config.DET_MODEL_PATH)}  |  REC: {os.path.basename(self.model_config.REC_MODEL_PATH)}")
+        self.append_output('-----------------------------')
+        # 打印视频帧提取开始提示
+        self.append_output(tr['Main']['StartProcessFrame'])
+        # 删除缓存
+        self.__delete_frame_cache()
+        # 若目录不存在，则创建文件夹
+        if not os.path.exists(self.frame_output_dir):
+            os.makedirs(self.frame_output_dir)
+        if not os.path.exists(self.subtitle_output_dir):
+            os.makedirs(self.subtitle_output_dir)
+        self.capture_frame_with_subtitle_area()
+        # 创建一个字幕OCR识别进程
+        subtitle_ocr_process = self.start_subtitle_ocr_async()
+        if self.sub_area is not None:
+            if platform.system() in ['Windows', 'Linux', 'Darwin']:
+                # 使用GPU且使用accurate模式时才开放此方法：
+                if self.hardware_accelerator.has_accelerator() and config.mode.value == 'accurate':
+                    self.extract_frame_by_det()
+                else:
+                    self.extract_frame_by_vsf()
+            else:
+                self.extract_frame_by_fps()
+        else:
+            self.extract_frame_by_fps()
+
+        # 往字幕OCR任务队列中，添加OCR识别任务结束标志
+        # 任务格式为：(total_frame_count总帧数, current_frame_no当前帧, dt_box检测框, rec_res识别结果, 当前帧时间， subtitle_area字幕区域)
+        self.subtitle_ocr_task_queue.put((self.frame_count, -1, None, None, None, None))
+        # 等待子线程完成
+        subtitle_ocr_process.join()
+        # 打印完成提示
+        self.append_output(tr['Main']['FinishProcessFrame'])
+        self.append_output(tr['Main']['FinishFindSub'])
+
+        if self.sub_area is None:
+            self.append_output(tr['Main']['StartDetectWaterMark'])
+            # 询问用户视频是否有水印区域
+            user_input = input(tr['Main']['checkWaterMark']).strip()
+            if user_input == 'y':
+                self.filter_watermark()
+                self.append_output(tr['Main']['FinishDetectWaterMark'])
+            else:
+                self.append_output('-----------------------------')
+
+        if self.sub_area is None:
+            self.append_output(tr['Main']['StartDeleteNonSub'])
+            self.filter_scene_text()
+            self.append_output(tr['Main']['FinishDeleteNonSub'])
+
+        self.update_progress(post=20)
+
+        # 打印开始字幕生成提示
+        self.append_output(tr['Main']['StartGenerateSub'])
+        # 判断是否使用了vsf提取字幕
+        if self.use_vsf:
+            # 如果使用了vsf提取字幕，则使用vsf的字幕生成方法
+            self.generate_subtitle_file_vsf()
+        else:
+            # 如果未使用vsf提取字幕，则使用常规字幕生成方法
+            self.generate_subtitle_file()
+
+        self.update_progress(post=90)
+
+        if config.wordSegmentation.value:
+            reformat.execute(self.subtitle_output_path, config.language.value)
+        self.append_output(tr['Main']['FinishGenerateSub'], f"{round(time.time() - start_time, 2)}s")
+        self.append_output('-----------------------------')
+        self.update_progress(ocr=100, frame_extract=100, post=100)
+        self.isFinished = True
+        # 删除缓存文件
+        self.empty_cache()
+        self.lock.release()
+        if config.generateTxt.value:
+            self.srt2txt(self.subtitle_output_path)
+
+    def capture_frame_with_subtitle_area(self):
+        """
+        截取视频的一帧，并在上面绘制字幕区域，保存到temp_output_dir/sub_area.jpg
+        """
+        # 确保输出目录存在
+        if not os.path.exists(self.temp_output_dir):
+            os.makedirs(self.temp_output_dir)
+            
+        # 确保视频已打开
+        if not self.video_cap.isOpened():
+            self.video_cap = cv2.VideoCapture(self.video_path)
+            
+        # 将视频指针设置到第一帧
+        # self.video_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        
+        # 读取第一帧
+        ret, frame = self.video_cap.read()
+        
+        if ret:
+            # 如果有字幕区域，绘制矩形
+            sub_area = self.sub_area
+            if sub_area is not None:
+                # 绘制绿色矩形框
+                cv2.rectangle(frame, (sub_area.xmin, sub_area.ymin), (sub_area.xmax, sub_area.ymax), (0, 255, 0), 2)
+                # 添加文字标注
+                cv2.putText(frame, "Subtitle Area", (sub_area.xmin, sub_area.ymin - 10), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+            
+            # 保存图像
+            output_path = os.path.join(self.temp_output_dir, 'sub_area.jpg')
+            cv2.imwrite(output_path, frame)
+            
+            # 重置视频指针到第一帧
+            self.video_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+
+    def extract_frame_by_fps(self):
+        """
+        根据帧率，定时提取视频帧，容易丢字幕，但速度快，将提取到的视频帧加入ocr识别任务队列
+        """
+        # 计算采样间隔（每隔多少帧取一帧）
+        frame_interval = int(self.fps // config.extractFrequency.value)
+        if frame_interval < 1:
+            frame_interval = 1
+        # 当前视频帧的帧号
+        current_frame_no = 0
+        total_frames = int(self.frame_count)
+        while current_frame_no < total_frames:
+            # 直接跳到目标帧
+            self.video_cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_no)
+            ret, frame = self.video_cap.read()
+            if not ret:
+                break
+            current_frame_no += 1
+            # subtitle_ocr_task_queue: (total_frame_count总帧数, current_frame_no当前帧, dt_box检测框, rec_res识别结果, 当前帧时间，subtitle_area字幕区域)
+            task = (self.frame_count, current_frame_no, None, None, None, config.subtitleArea.value)
+            self.subtitle_ocr_task_queue.put(task)
+            # 更新进度条
+            self.update_progress(frame_extract=(current_frame_no / self.frame_count) * 100)
+            # 跳到下一个采样帧
+            current_frame_no = current_frame_no + frame_interval - 1
+
+        self.video_cap.release()
+
+    def extract_frame_by_det(self):
+        """
+        通过检测字幕区域位置提取字幕帧
+        """
+
+        # 当前视频帧的帧号
+        current_frame_no = 0
+        frame_lru_list = []
+        frame_lru_list_max_size = 2
+        ocr_args_list = []
+        compare_ocr_result_cache = {}
+        tbar = tqdm(total=int(self.frame_count), unit='f', position=0, file=sys.__stdout__)
+        first_flag = True
+        is_finding_start_frame_no = False
+        is_finding_end_frame_no = False
+        start_frame_no = 0
+        start_end_frame_no = []
+        start_frame = None
+        if self.ocr is None:
+            self.ocr = OcrRecogniser()
+        while self.video_cap.isOpened():
+            ret, frame = self.video_cap.read()
+            # 如果读取视频帧失败（视频读到最后一帧）
+            if not ret:
+                break
+            # 读取视频帧成功
+            current_frame_no += 1
+            tbar.update(1)
+            dt_boxes, elapse = self.sub_detector.detect_subtitle(frame)
+            has_subtitle = False
+            sub_area = self.sub_area
+            if sub_area is not None:
+                coordinate_list = get_coordinates(dt_boxes.tolist())
+                if coordinate_list:
+                    for coordinate in coordinate_list:
+                        xmin, xmax, ymin, ymax = coordinate
+                        if (sub_area.xmin <= xmin and xmax <= sub_area.xmax
+                                and sub_area.ymin <= ymin
+                                and ymax <= sub_area.ymax):
+                            has_subtitle = True
+                            # 检测到字幕时，如果列表为空，则为字幕头
+                            if first_flag:
+                                is_finding_start_frame_no = True
+                                first_flag = False
+                            break
+            else:
+                has_subtitle = len(dt_boxes) > 0
+            # 检测到包含字幕帧的起始帧号与结束帧号
+            if has_subtitle:
+                # 判断是字幕头还是尾
+                if is_finding_start_frame_no:
+                    start_frame_no = current_frame_no
+                    dt_box, rec_res = self.ocr.predict(frame)
+                    area_text1 = "".join(self.__get_area_text((dt_box, rec_res)))
+                    if start_frame_no not in compare_ocr_result_cache.keys():
+                        compare_ocr_result_cache[current_frame_no] = {'text': area_text1, 'dt_box': dt_box, 'rec_res': rec_res}
+                        frame_lru_list.append((frame, current_frame_no))
+                        ocr_args_list.append((self.frame_count, current_frame_no))
+                        # 缓存头帧
+                        start_frame = frame
+                    # 开始找尾
+                    is_finding_start_frame_no = False
+                    is_finding_end_frame_no = True
+                # 判断是否为最后一帧
+                if is_finding_end_frame_no and current_frame_no == self.frame_count:
+                    is_finding_end_frame_no = False
+                    is_finding_start_frame_no = False
+                    end_frame_no = current_frame_no
+                    frame_lru_list.append((frame, current_frame_no))
+                    ocr_args_list.append((self.frame_count, current_frame_no))
+                    start_end_frame_no.append((start_frame_no, end_frame_no))
+                # 如果在找结束帧的时候
+                if is_finding_end_frame_no:
+                    # 判断该帧与头帧ocr内容是否一致,若不一致则找到尾，尾巴为前一帧
+                    if not self._compare_ocr_result(compare_ocr_result_cache, None, start_frame_no, frame, current_frame_no):
+                        is_finding_end_frame_no = False
+                        is_finding_start_frame_no = True
+                        end_frame_no = current_frame_no - 1
+                        frame_lru_list.append((start_frame, end_frame_no))
+                        ocr_args_list.append((self.frame_count, end_frame_no))
+                        start_end_frame_no.append((start_frame_no, end_frame_no))
+
+            else:
+                # 如果检测到字幕头后有没有字幕，则找到结尾，尾巴为前一帧
+                if is_finding_end_frame_no:
+                    end_frame_no = current_frame_no - 1
+                    is_finding_end_frame_no = False
+                    is_finding_start_frame_no = True
+                    frame_lru_list.append((start_frame, end_frame_no))
+                    ocr_args_list.append((self.frame_count, end_frame_no))
+                    start_end_frame_no.append((start_frame_no, end_frame_no))
+
+            while len(frame_lru_list) > frame_lru_list_max_size:
+                frame_lru_list.pop(0)
+
+            # if len(start_end_frame_no) > 0:
+                # self.append_output(start_end_frame_no)
+
+            while len(ocr_args_list) > 1:
+                total_frame_count, ocr_info_frame_no = ocr_args_list.pop(0)
+                if current_frame_no in compare_ocr_result_cache:
+                    predict_result = compare_ocr_result_cache[current_frame_no]
+                    dt_box, rec_res = predict_result['dt_box'], predict_result['rec_res']
+                else:
+                    dt_box, rec_res = None, None
+                # subtitle_ocr_task_queue: (total_frame_count总帧数, current_frame_no当前帧, dt_box检测框, rec_res识别结果, 当前帧时间， subtitle_area字幕区域)
+                task = (total_frame_count, ocr_info_frame_no, dt_box, rec_res, None, config.subtitleArea.value)
+                # 添加任务
+                self.subtitle_ocr_task_queue.put(task)
+                self.update_progress(frame_extract=(current_frame_no / self.frame_count) * 100)
+
+        while len(ocr_args_list) > 0:
+            total_frame_count, ocr_info_frame_no = ocr_args_list.pop(0)
+            if current_frame_no in compare_ocr_result_cache:
+                predict_result = compare_ocr_result_cache[current_frame_no]
+                dt_box, rec_res = predict_result['dt_box'], predict_result['rec_res']
+            else:
+                dt_box, rec_res = None, None
+            task = (total_frame_count, ocr_info_frame_no, dt_box, rec_res, None, config.subtitleArea.value)
+            # 添加任务
+            self.subtitle_ocr_task_queue.put(task)
+        self.video_cap.release()
+
+    def extract_frame_by_vsf(self):
+        """
+       通过调用videoSubFinder获取字幕帧
+       """
+        self.use_vsf = True
+        if self.video_cap:
+            self.video_cap.release()
+            self.video_cap = None
+        def count_process():
+            duration_ms = (self.frame_count / self.fps) * 1000
+            last_total_ms = 0
+            processed_image = set()
+            rgb_images_path = os.path.join(self.temp_output_dir, 'RGBImages')
+            time_pattern = re.compile(r'^\d+_\d+_\d+_\d+__')
+            while self.vsf_running and not self.isFinished:
+                time.sleep(0.2)
+                # 如果还没有rgb_images_path说明vsf还没处理完
+                if not os.path.exists(rgb_images_path):
+                    # 继续等待
+                    continue
+                try:
+                    # 将列表按文件名排序
+                    rgb_images = sorted(os.listdir(rgb_images_path))
+                    for rgb_image in rgb_images:
+                        # 如果当前图片已被处理，则跳过
+                        if rgb_image in processed_image:
+                            continue
+                        if not time_pattern.match(rgb_image):
+                            continue
+                        # self.append_output('rgb_image: ', rgb_image)
+                        processed_image.add(rgb_image)
+                        # 根据vsf生成的文件名读取时间
+                        h, m, s, ms = rgb_image.split('__')[0].split('_')
+                        total_ms = int(ms) + int(s) * 1000 + int(m) * 60 * 1000 + int(h) * 60 * 60 * 1000
+                        if total_ms > last_total_ms:
+                            frame_no = int(total_ms / self.fps)
+                            task = (self.frame_count, frame_no, None, None, total_ms, config.subtitleArea.value)
+                            self.subtitle_ocr_task_queue.put(task)
+                        last_total_ms = total_ms
+                        if total_ms / duration_ms >= 1:
+                            self.update_progress(frame_extract=100)
+                            return
+                        else:
+                            self.update_progress(frame_extract=(total_ms / duration_ms) * 100)
+                # 文件被清理了
+                except FileNotFoundError:
+                    return
+
+        def vsf_output(out, ):
+            duration_ms = (self.frame_count / self.fps) * 1000
+            last_total_ms = 0
+            for line in iter(out.readline, b''):
+                line = line.decode("utf-8")
+                # self.append_output('line', line, type(line), line.startswith('Frame: '))
+                if line.startswith('Frame: '):
+                    line = line.replace("\n", "")
+                    line = line.replace("Frame: ", "")
+                    h, m, s, ms = line.split('__')[0].split('_')
+                    total_ms = int(ms) + int(s) * 1000 + int(m) * 60 * 1000 + int(h) * 60 * 60 * 1000
+                    if total_ms > last_total_ms:
+                        frame_no = int(total_ms / self.fps)
+                        task = (self.frame_count, frame_no, None, None, total_ms, config.subtitleArea.value)
+                        self.subtitle_ocr_task_queue.put(task)
+                    last_total_ms = total_ms
+                    if total_ms / duration_ms >= 1:
+                        self.update_progress(frame_extract=100)
+                        return
+                    else:
+                        self.update_progress(frame_extract=(total_ms / duration_ms) * 100)
+                else:
+                    self.append_output(line.strip())
+            out.close()
+
+        # 定义videoSubFinder所在路径
+        if platform.system() == 'Windows':
+            path_vsf = os.path.join(BASE_DIR, 'subfinder', 'windows', 'VideoSubFinderWXW.exe')
+        elif platform.system() == 'Darwin':
+            path_vsf = os.path.join(BASE_DIR, 'subfinder', 'macos', 'VideoSubFinderCli')
+            os.chmod(path_vsf, 0o775)
+        else:
+            path_vsf = os.path.join(BASE_DIR, 'subfinder', 'linux', 'VideoSubFinderCli.run')
+            os.chmod(path_vsf, 0o775)
+        # ：图像上半部分所占百分比，取值【0-1】
+        top_end = 1 - self.sub_area.ymin / self.frame_height
+        # bottom_end：图像下半部分所占百分比，取值【0-1】
+        bottom_end = 1 - self.sub_area.ymax / self.frame_height
+        # left_end：图像左半部分所占百分比，取值【0-1】
+        left_end = self.sub_area.xmin / self.frame_width
+        # re：图像右半部分所占百分比，取值【0-1】
+        right_end = self.sub_area.xmax / self.frame_width
+        if (not self.hardware_accelerator.has_cuda()) and len(self.hardware_accelerator.onnx_providers) > 0:
+            cpu_count = multiprocessing.cpu_count()
+        else:
+            # 留2核心来给其他任务使用
+            cpu_count = max(multiprocessing.cpu_count() - 2, 1)
+        if config.videoSubFinderCpuCores.value > 0:
+            cpu_count = config.videoSubFinderCpuCores.value
+        if platform.system() == 'Windows':
+            # 定义执行命令
+            cmd = f"{path_vsf} --use_cuda -c -r -i \"{self.video_path}\" -o \"{self.temp_output_dir}\" -ces \"{self.vsf_subtitle}\" "
+            cmd += f"-te {top_end} -be {bottom_end} -le {left_end} -re {right_end} -nthr {cpu_count} -nocrthr {cpu_count} "
+            cmd += f"--open_video_{config.videoSubFinderDecoder.value.value.lower()} "
+            # 计算进度
+            try:
+                self.vsf_running = True
+                Thread(target=count_process, daemon=True).start()       
+                # 已知BUG: test_chinese_cht.flv在net drive上会导致无法停止, 但在本地不会, 可能是vsf的原因
+                p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1,
+                                    close_fds='posix' in sys.builtin_module_names, shell=False, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
+                ProcessManager.instance().add_process(p)
+                self.manage_process(p.pid)
+                p.wait()
+            finally:
+                self.vsf_running = False
+        else:
+            # 定义执行命令
+            cmd = f"{path_vsf} -c -r -i \"{self.video_path}\" -o \"{self.temp_output_dir}\" -ces \"{self.vsf_subtitle}\" "
+            if self.hardware_accelerator.has_accelerator():
+                cmd += "--use_cuda "
+            cmd += f"-te {top_end} -be {bottom_end} -le {left_end} -re {right_end} -nthr {cpu_count} -dsi "
+            cmd += f"--open_video_{config.videoSubFinderDecoder.value.value.lower()} "
+            self.vsf_running = True
+            try:
+                p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1,
+                                    close_fds='posix' in sys.builtin_module_names, shell=True,
+                                    start_new_session=True)
+                Thread(target=vsf_output, daemon=True, args=(p.stderr,)).start()
+                ProcessManager.instance().add_process(p)
+                self.manage_process(p.pid)
+                p.wait()
+            finally:
+                self.vsf_running = False
+    def filter_watermark(self):
+        """
+        去除原始字幕文本中的水印区域的文本
+        """
+        # 获取潜在水印区域
+        watermark_areas = self._detect_watermark_area()
+
+        # 随机选择一帧, 将所水印区域标记出来，用户看图判断是否是水印区域
+        cap = cv2.VideoCapture(self.video_path)
+        ret, sample_frame = False, None
+        for i in range(10):
+            frame_no = random.randint(int(self.frame_count * 0.1), int(self.frame_count * 0.9))
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_no)
+            ret, sample_frame = cap.read()
+            if ret:
+                break
+        cap.release()
+
+        if not ret:
+            self.append_output("Error in filter_watermark: reading frame from video")
+            return
+
+        # 给潜在的水印区域编号
+        area_num = ['E', 'D', 'C', 'B', 'A']
+
+        for watermark_area in watermark_areas:
+            ymin = min(watermark_area[0][2], watermark_area[0][3])
+            ymax = max(watermark_area[0][3], watermark_area[0][2])
+            xmin = min(watermark_area[0][0], watermark_area[0][1])
+            xmax = max(watermark_area[0][1], watermark_area[0][0])
+            cover = sample_frame[ymin:ymax, xmin:xmax]
+            cover = cv2.blur(cover, (10, 10))
+            cv2.rectangle(cover, pt1=(0, cover.shape[0]), pt2=(cover.shape[1], 0), color=(0, 0, 255), thickness=3)
+            sample_frame[ymin:ymax, xmin:xmax] = cover
+            position = ((xmin + xmax) // 2, ymax)
+
+            cv2.putText(sample_frame, text=area_num.pop(), org=position, fontFace=cv2.FONT_HERSHEY_SIMPLEX,
+                        fontScale=1, color=(255, 0, 0), thickness=2, lineType=cv2.LINE_AA)
+
+        sample_frame_file_path = os.path.join(os.path.dirname(self.frame_output_dir), 'watermark_area.jpg')
+        cv2.imwrite(sample_frame_file_path, sample_frame)
+        self.append_output(f"{tr['Main']['WatchPicture']}: {sample_frame_file_path}")
+
+        area_num = ['E', 'D', 'C', 'B', 'A']
+        for watermark_area in watermark_areas:
+            user_input = input(f"{area_num.pop()}{str(watermark_area)} "
+                               f"{tr['Main']['QuestionDelete']}").strip()
+            if user_input == 'y' or user_input == '\n':
+                with open(self.raw_subtitle_path, mode='r+', encoding='utf-8') as f:
+                    content = f.readlines()
+                    f.seek(0)
+                    for i in content:
+                        if i.find(str(watermark_area[0])) == -1:
+                            f.write(i)
+                    f.truncate()
+                self.append_output(tr['Main']['FinishDelete'])
+        self.append_output(tr['Main']['FinishWaterMarkFilter'])
+        # 删除缓存
+        if os.path.exists(sample_frame_file_path):
+            os.remove(sample_frame_file_path)
+
+    def filter_scene_text(self):
+        """
+        将场景里提取的文字过滤，仅保留字幕区域
+        """
+        # 获取潜在字幕区域
+        subtitle_area = self._detect_subtitle_area()[0][0]
+
+        # 随机选择一帧，将所水印区域标记出来，用户看图判断是否是水印区域
+        cap = cv2.VideoCapture(self.video_path)
+        ret, sample_frame = False, None
+        for i in range(10):
+            frame_no = random.randint(int(self.frame_count * 0.1), int(self.frame_count * 0.9))
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_no)
+            ret, sample_frame = cap.read()
+            if ret:
+                break
+        cap.release()
+
+        if not ret:
+            self.append_output("Error in filter_scene_text: reading frame from video")
+            return
+
+        # 为了防止有双行字幕，根据容忍度，将字幕区域y范围加高
+        ymin = abs(subtitle_area[0] - config.subtitleAreaDeviationPixel.value)
+        ymax = subtitle_area[1] + config.subtitleAreaDeviationPixel.value
+        # 画出字幕框的区域
+        cv2.rectangle(sample_frame, pt1=(0, ymin), pt2=(sample_frame.shape[1], ymax), color=(0, 0, 255), thickness=3)
+        sample_frame_file_path = os.path.join(os.path.dirname(self.frame_output_dir), 'subtitle_area.jpg')
+        cv2.imwrite(sample_frame_file_path, sample_frame)
+        self.append_output(f"{tr['Main']['CheckSubArea']} {sample_frame_file_path}")
+
+        user_input = input(f"{(ymin, ymax)} {tr['Main']['DeleteNoSubArea']}").strip()
+        if user_input == 'y' or user_input == '\n':
+            with open(self.raw_subtitle_path, mode='r+', encoding='utf-8') as f:
+                content = f.readlines()
+                f.seek(0)
+                for i in content:
+                    i_ymin = int(i.split('\t')[1].split('(')[1].split(')')[0].split(', ')[2])
+                    i_ymax = int(i.split('\t')[1].split('(')[1].split(')')[0].split(', ')[3])
+                    if ymin <= i_ymin and i_ymax <= ymax:
+                        f.write(i)
+                f.truncate()
+            self.append_output(tr['Main']['FinishDeleteNoSubArea'])
+        # 删除缓存
+        if os.path.exists(sample_frame_file_path):
+            os.remove(sample_frame_file_path)
+
+    def generate_subtitle_file(self):
+        """
+        生成srt格式的字幕文件
+        """
+        if not self.use_vsf:
+            subtitle_content = self._remove_duplicate_subtitle()
+            # 保存持续时间不足1秒的字幕行，用于后续处理
+            post_process_subtitle = []
+            with open(self.subtitle_output_path, mode='w', encoding='utf-8') as f:
+                for index, content in enumerate(subtitle_content):
+                    line_code = index + 1
+                    frame_start = self._frame_to_timecode(int(content[0]))
+                    # 比较起始帧号与结束帧号， 如果字幕持续时间不足1秒，则将显示时间设为1s
+                    if abs(int(content[1]) - int(content[0])) < self.fps:
+                        frame_end = self._frame_to_timecode(int(int(content[0]) + self.fps))
+                        post_process_subtitle.append(line_code)
+                    else:
+                        frame_end = self._frame_to_timecode(int(content[1]))
+                    frame_content = content[2]
+                    subtitle_line = f'{line_code}\n{frame_start} --> {frame_end}\n{frame_content}\n'
+                    f.write(subtitle_line)
+            self.append_output(tr['Main']['SubLocation'].format(self.subtitle_output_path))
+            # 返回持续时间低于1s的字幕行
+            return post_process_subtitle
+
+    def generate_subtitle_file_vsf(self):
+        if not self.use_vsf:
+            return
+        subs = pysrt.open(self.vsf_subtitle)
+        sub_no_map = {}
+        for sub in subs:
+            sub.start.no = self._timestamp_to_frameno(sub.start.ordinal)
+            sub_no_map[sub.start.no] = sub
+
+        subtitle_content = self._remove_duplicate_subtitle()
+        subtitle_content_start_map = {int(a[0]): a for a in subtitle_content}
+        final_subtitles = []
+        for sub in subs:
+            found = sub.start.no in subtitle_content_start_map
+            if found:
+                subtitle_content_line = subtitle_content_start_map[sub.start.no]
+                sub.text = subtitle_content_line[2]
+                end_no = int(subtitle_content_line[1])
+                sub.end = sub_no_map[end_no].end if end_no in sub_no_map else sub.end
+                sub.index = len(final_subtitles) + 1
+                final_subtitles.append(sub)
+
+            if not found and not config.deleteEmptyTimeStamp.value:
+                # 保留时间轴
+                sub.text = ""
+                sub.index = len(final_subtitles) + 1
+                final_subtitles.append(sub)
+                continue
+
+        pysrt.SubRipFile(final_subtitles).save(self.subtitle_output_path, encoding='utf-8')
+        self.append_output(tr['Main']['SubLocation'].format(self.subtitle_output_path))
+
+    def _detect_watermark_area(self):
+        """
+        根据识别出来的raw txt文件中的坐标点信息，查找水印区域
+        假定：水印区域（台标）的坐标在水平和垂直方向都是固定的，也就是具有(xmin, xmax, ymin, ymax)相对固定
+        根据坐标点信息，进行统计，将一直具有固定坐标的文本区域选出
+        :return 返回最有可能的水印区域
+        """
+        with open(self.raw_subtitle_path, mode='r', encoding='utf-8') as f:
+            lines = f.readlines()
+        # 一次性解析所有行
+        parsed = []
+        for line in lines:
+            parts = line.split('\t')
+            if len(parts) < 3:
+                continue
+            frame_no = parts[0]
+            text_position = parts[1].split('(')[1].split(')')[0].split(', ')
+            content = parts[2]
+            coordinate = (int(text_position[0]), int(text_position[1]),
+                          int(text_position[2]), int(text_position[3]))
+            parsed.append((frame_no, coordinate, content))
+
+        frame_no_list = [p[0] for p in parsed]
+        coordinates_list = [p[1] for p in parsed]
+        content_list = [p[2] for p in parsed]
+        # 将坐标列表的相似值统一
+        coordinates_list = self._unite_coordinates(coordinates_list)
+
+        # 将原txt文件的坐标更新为归一后的坐标
+        with open(self.raw_subtitle_path, mode='w', encoding='utf-8') as f:
+            for frame_no, coordinate, content in zip(frame_no_list, coordinates_list, content_list):
+                f.write(f'{frame_no}\t{coordinate}\t{content}')
+
+        count = Counter(coordinates_list).most_common()
+        num = min(config.waterarkAreaNum.value, len(count))
+        return count[:num]
+
+    def _detect_subtitle_area(self):
+        """
+        读取过滤水印区域后的raw txt文件，根据坐标信息，查找字幕区域
+        假定：字幕区域在y轴上有一个相对固定的坐标范围，相对于场景文本，这个范围出现频率更高
+        :return 返回字幕的区域位置
+        """
+        with open(self.raw_subtitle_path, mode='r', encoding='utf-8') as f:
+            lines = f.readlines()
+        y_coordinates_list = []
+        for line in lines:
+            parts = line.split('\t')
+            if len(parts) < 2:
+                continue
+            text_position = parts[1].split('(')[1].split(')')[0].split(', ')
+            y_coordinates_list.append((int(text_position[2]), int(text_position[3])))
+        return Counter(y_coordinates_list).most_common(1)
+
+    def _frame_to_timecode(self, frame_no):
+        """
+        将视频帧转换成时间（纯计算，不打开视频文件）
+        :param frame_no: 视频的帧号，i.e. 第几帧视频帧
+        :returns: SMPTE格式时间戳 as string, 如'01:02:12,032'
+        """
+        total_ms = frame_no / self.fps * 1000
+        total_ms_int = int(total_ms)
+        milliseconds = total_ms_int % 1000
+        total_seconds = total_ms_int // 1000
+        seconds = total_seconds % 60
+        minutes = (total_seconds // 60) % 60
+        hours = total_seconds // 3600
+        return "%02d:%02d:%02d,%03d" % (hours, minutes, seconds, milliseconds)
+
+    def _timestamp_to_frameno(self, time_ms):
+        return int(time_ms / self.fps)
+
+    def _frameno_to_milliseconds(self, frame_no):
+        return float(int(frame_no / self.fps * 1000))
+
+    def _remove_duplicate_subtitle(self):
+        """
+        读取原始的raw txt，去除重复行，返回去除了重复后的字幕列表
+        """
+        self._concat_content_with_same_frameno()
+        with open(self.raw_subtitle_path, mode='r', encoding='utf-8') as r:
+            lines = r.readlines()
+        RawInfo = namedtuple('RawInfo', 'no content')
+        content_list = []
+        for line in lines:
+            frame_no = line.split('\t')[0]
+            content = line.split('\t')[2]
+            content_list.append(RawInfo(frame_no, content))
+        # 去重后的字幕列表
+        unique_subtitle_list = []
+        idx_i = 0
+        content_list_len = len(content_list)
+        # 循环遍历每行字幕，记录开始时间与结束时间
+        last_reported_idx = -1
+        report_interval = max(1, content_list_len // 100)
+        while idx_i < content_list_len:
+            i = content_list[idx_i]
+            start_frame = i.no
+            idx_j = idx_i
+            while idx_j < content_list_len:
+                # 定期更新去重进度（post: 20→85），基于 idx_j 推进
+                if idx_j - last_reported_idx >= report_interval:
+                    last_reported_idx = idx_j
+                    self.update_progress(post=20 + int(65 * idx_j / content_list_len))
+                # 计算当前行与下一行的Levenshtein距离
+                # 判决idx_j的下一帧是否与idx_i不同，若不同（或者是最后一帧）则找到结束帧
+                if idx_j + 1 == content_list_len or ratio(i.content.replace(' ', ''), content_list[idx_j + 1].content.replace(' ', '')) < (config.thresholdTextSimilarity.value / 100.0):
+                    # 若找到终点帧,定义字幕结束帧帧号
+                    end_frame = content_list[idx_j].no
+                    if not self.use_vsf:
+                        if end_frame == start_frame and idx_j + 1 < content_list_len:
+                            # 针对只有一帧的情况，以下一帧的开始时间为准(除非是最后一帧)
+                            end_frame = content_list[idx_j + 1][0]
+                    # 寻找最长字幕
+                    similar_list = content_list[idx_i:idx_j + 1]
+                    similar_content_strip_list = [item.content.replace(' ', '') for item in similar_list]
+                    index, _ = max(enumerate(similar_content_strip_list), key=lambda x: len(x[1]))
+
+                    # 添加进列表
+                    unique_subtitle_list.append((start_frame, end_frame, similar_list[index].content))
+                    idx_i = idx_j + 1
+                    break
+                else:
+                    idx_j += 1
+                    continue
+        return unique_subtitle_list
+
+    def _concat_content_with_same_frameno(self):
+        """
+        将raw txt文本中具有相同帧号的字幕行合并
+        """
+        with open(self.raw_subtitle_path, mode='r', encoding='utf-8') as r:
+            lines = r.readlines()
+
+        # 用dict按frame_no分组，保留原始顺序
+        from collections import OrderedDict
+        grouped = OrderedDict()
+        for line in lines:
+            parts = line.split('\t', 2)
+            if len(parts) < 3:
+                continue
+            frame_no, coordinate, content = parts
+            if frame_no not in grouped:
+                grouped[frame_no] = (coordinate, [])
+            grouped[frame_no][1].append(content)
+
+        with open(self.raw_subtitle_path, mode='w', encoding='utf-8') as f:
+            for frame_no, (coordinate, contents) in grouped.items():
+                merged = ' '.join(contents).replace('\n', ' ')
+                if not merged.endswith('\n'):
+                    merged += '\n'
+                merged = unicodedata.normalize('NFKC', merged)
+                f.write(f'{frame_no}\t{coordinate}\t{merged}')
+
+    def _unite_coordinates(self, coordinates_list):
+        """
+        给定一个坐标列表，将这个列表中相似的坐标统一为一个值
+        e.g. 由于检测框检测的结果不是一致的，相同位置文字的坐标可能一次检测为(255,123,456,789)，另一次检测为(253,122,456,799)
+        因此要对相似的坐标进行值的统一
+        :param coordinates_list 包含坐标点的列表
+        :return: 返回一个统一值后的坐标列表
+        """
+        if not coordinates_list:
+            return coordinates_list
+        # 按xmin排序后用滑动窗口，相似坐标的xmin差值在容忍范围内
+        n = len(coordinates_list)
+        indexed = sorted(enumerate(coordinates_list), key=lambda x: x[1][0])
+        # parent数组用于并查集
+        parent = list(range(n))
+        def find(i):
+            while parent[i] != i:
+                parent[i] = parent[parent[i]]
+                i = parent[i]
+            return i
+        def union(i, j):
+            ri, rj = find(i), find(j)
+            if ri != rj:
+                # 保留较小索引的坐标作为代表
+                if ri > rj:
+                    ri, rj = rj, ri
+                parent[rj] = ri
+        # 滑动窗口：xmin已排序，只要xmin差值超过容忍度就移动左边界
+        left = 0
+        for right in range(n):
+            while left < right and indexed[right][1][0] - indexed[left][1][0] >= config.tolerantPixelX:
+                left += 1
+            # 检查窗口内所有元素与当前元素是否相似
+            for k in range(left, right):
+                if self.__is_coordinate_similar(indexed[k][1], indexed[right][1]):
+                    union(indexed[k][0], indexed[right][0])
+        # 将所有坐标统一为其组代表的坐标
+        result = list(coordinates_list)
+        for i in range(n):
+            result[i] = coordinates_list[find(i)]
+        return result
+
+    def _compute_image_similarity(self, image1, image2):
+        """
+        计算两张图片的余弦相似度
+        """
+        image1 = self.__get_thum(image1)
+        image2 = self.__get_thum(image2)
+        images = [image1, image2]
+        vectors = []
+        norms = []
+        for image in images:
+            vector = []
+            for pixel_tuple in image.getdata():
+                vector.append(average(pixel_tuple))
+            vectors.append(vector)
+            # linalg=linear（线性）+algebra（代数），norm则表示范数
+            # 求图片的范数
+            norms.append(linalg.norm(vector, 2))
+        a, b = vectors
+        a_norm, b_norm = norms
+        # dot返回的是点积，对二维数组（矩阵）进行计算
+        res = dot(a / a_norm, b / b_norm)
+        return res
+
+    def __get_area_text(self, ocr_result):
+        """
+        获取字幕区域内的文本内容
+        """
+        box, text = ocr_result
+        coordinates = get_coordinates(box)
+        area_text = []
+        for content, coordinate in zip(text, coordinates):
+            sub_area = self.sub_area
+            if sub_area is not None:
+                xmin = coordinate[0]
+                xmax = coordinate[1]
+                ymin = coordinate[2]
+                ymax = coordinate[3]
+                if sub_area.xmin <= xmin and xmax <= sub_area.xmax and sub_area.ymin <= ymin and ymax <= sub_area.ymax:
+                    area_text.append(content[0])
+        return area_text
+
+    def _compare_ocr_result(self, result_cache, img1, img1_no, img2, img2_no):
+        """
+        比较两张图片预测出的字幕区域文本是否相同
+        """
+        if self.ocr is None:
+            self.ocr = OcrRecogniser()
+        if img1_no in result_cache:
+            area_text1 = result_cache[img1_no]['text']
+        else:
+            dt_box, rec_res = self.ocr.predict(img1)
+            area_text1 = "".join(self.__get_area_text((dt_box, rec_res)))
+            result_cache[img1_no] = {'text': area_text1, 'dt_box': dt_box, 'rec_res': rec_res}
+
+        if img2_no in result_cache:
+            area_text2 = result_cache[img2_no]['text']
+        else:
+            dt_box, rec_res = self.ocr.predict(img2)
+            area_text2 = "".join(self.__get_area_text((dt_box, rec_res)))
+            result_cache[img2_no] = {'text': area_text2, 'dt_box': dt_box, 'rec_res': rec_res}
+        delete_no_list = []
+        for no in result_cache:
+            if no < min(img1_no, img2_no) - 10:
+                delete_no_list.append(no)
+        for no in delete_no_list:
+            del result_cache[no]
+        if ratio(area_text1, area_text2) > config.thresholdTextSimilarity.value / 100.0:
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def __is_coordinate_similar(coordinate1, coordinate2):
+        """
+        计算两个坐标是否相似，如果两个坐标点的xmin,xmax,ymin,ymax的差值都在像素点容忍度内
+        则认为这两个坐标点相似
+        """
+        return abs(coordinate1[0] - coordinate2[0]) < config.tolerantPixelX and \
+            abs(coordinate1[1] - coordinate2[1]) < config.tolerantPixelX and \
+            abs(coordinate1[2] - coordinate2[2]) < config.tolerantPixelY and \
+            abs(coordinate1[3] - coordinate2[3]) < config.tolerantPixelY
+
+    @staticmethod
+    def __get_thum(image, size=(64, 64), greyscale=False):
+        """
+        对图片进行统一化处理
+        """
+        # 利用image对图像大小重新设置, Image.ANTIALIAS为高质量的
+        image = image.resize(size, Image.ANTIALIAS)
+        if greyscale:
+            # 将图片转换为L模式，其为灰度图，其每个像素用8个bit表示
+            image = image.convert('L')
+        return image
+
+    def __delete_frame_cache(self):
+        if os.path.exists(self.temp_output_dir):
+            shutil.rmtree(self.temp_output_dir, True)
+
+    def empty_cache(self):
+        """
+        删除字幕提取过程中所有生产的缓存文件
+        """
+        if not config.debugNoDeleteCache.value:
+            if os.path.exists(self.temp_output_dir):
+                shutil.rmtree(self.temp_output_dir, True)
+
+    def update_progress(self, ocr=None, frame_extract=None, post=None):
+        """
+        更新进度条
+        :param ocr ocr进度
+        :param frame_extract 视频帧提取进度
+        :param post 后处理进度
+        """
+        if ocr is not None:
+            self.progress_ocr = max(0, min(100, ocr))  # Clamp value between 0 and 100
+        if frame_extract is not None:
+            self.progress_frame_extract = max(0, min(100, frame_extract))
+        if post is not None:
+            self.progress_post = max(0, min(100, post))
+        # 通知所有监听器
+        self.notify_progress_listeners()
+
+    def start_subtitle_ocr_async(self):
+        def get_ocr_progress():
+            """
+            获取ocr识别进度
+            生产者在所有帧入队后发送 (-2, total_tasks) 告知总帧数
+            消费者每处理一帧发送 (frame_no, processed_count)
+            消费者处理完全部帧后发送 (-1, total_tasks)
+            """
+            notify = True
+            total_tasks = None
+            while True:
+                value = self.subtitle_ocr_progress_queue.get(block=True)
+                if notify:
+                    self.append_output(tr['Main']['StartFindSub'])
+                    notify = False
+                # 生产者告知总帧数 value = (-2, total_tasks)
+                if isinstance(value, tuple) and len(value) == 2 and value[0] == -2:
+                    total_tasks = value[1]
+                    continue
+                # 终止条件
+                if value == -1:
+                    self.update_progress(ocr=100)
+                    return
+                if isinstance(value, tuple) and value[0] == -1:
+                    self.update_progress(ocr=100)
+                    return
+                # value = (frame_no, processed_count)
+                if isinstance(value, tuple) and len(value) == 2:
+                    _, processed_count = value
+                    if total_tasks and total_tasks > 0:
+                        ocr_pct = min(99, processed_count / total_tasks * 100)
+                    else:
+                        ocr_pct = min(99, processed_count)
+                    self.update_progress(ocr=ocr_pct)
+        options = {
+            'REC_CHAR_TYPE': config.language.value,
+            'DROP_SCORE': config.dropScore.value / 100.0,
+            'SUB_AREA_DEVIATION_RATE': config.subtitleAreaDeviationRate.value / 100.0,
+            'DEBUG_OCR_LOSS': config.debugOcrLoss.value,
+            'HARDWARD_ACCELERATOR': self.hardware_accelerator,
+        }
+        process, task_queue, progress_queue = subtitle_ocr.async_start(self.video_path, self.raw_subtitle_path, self.sub_area, options)
+        ProcessManager.instance().add_process(process)
+        self.manage_process(process.pid)
+        self.subtitle_ocr_task_queue = task_queue
+        self.subtitle_ocr_progress_queue = progress_queue
+        # 开启线程负责更新OCR进度
+        Thread(target=get_ocr_progress, daemon=True).start()
+        return process
+
+    def srt2txt(self, srt_file):
+        subs = pysrt.open(srt_file, encoding='utf-8')
+        output_path = os.path.join(os.path.dirname(srt_file), Path(srt_file).stem + '.txt')
+        self.append_output(output_path)
+        with open(output_path, 'w', encoding='utf-8') as f:
+            for sub in subs:
+                f.write(f'{sub.text}\n')
+
+    def append_output(self, *args):
+        """输出信息到控制台
+        Args:
+            *args: 要输出的内容，多个参数将用空格连接
+        """
+        print(*args)
+
+    def add_progress_listener(self, listener):
+        """
+        添加进度监听器
+        
+        Args:
+            listener: 一个回调函数，接收参数 (progress_ocr, progress_frame_extract, progress_total, isFinished)
+        """
+        if listener not in self.progress_listeners:
+            self.progress_listeners.append(listener)
+    
+    def remove_progress_listener(self, listener):
+        """
+        移除进度监听器
+        
+        Args:
+            listener: 要移除的监听器函数
+        """
+        if listener in self.progress_listeners:
+            self.progress_listeners.remove(listener)
+            
+    def notify_progress_listeners(self):
+        """
+        通知所有进度监听器当前进度
+        """
+        for listener in self.progress_listeners:
+            try:
+                listener(self.progress_ocr, self.progress_frame_extract, self.progress_total, self.isFinished, self.progress_post)
+            except Exception as e:
+                traceback.print_exc()
+
+    def manage_process(pid):
+        pass
+
+if __name__ == '__main__':
+    multiprocessing.set_start_method("spawn")
+    # 提示用户输入视频路径
+    video_path = input(f"{tr['Main']['InputVideo']}").strip()
+    # 提示用户输入字幕区域
+    try:
+        y_min, y_max, x_min, x_max = map(int, input(
+            f"{tr['Main']['ChooseSubArea']} (ymin ymax xmin xmax)：").split())
+        subtitle_area = SubtitleArea(y_min, y_max, x_min, x_max)
+    except ValueError as e:
+        subtitle_area = None
+    # 新建字幕提取对象
+    se = SubtitleExtractor(video_path)
+    se.sub_area = subtitle_area
+    # 开始提取字幕
+    se.run()
diff --git a/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.json b/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.json
new file mode 100644
index 0000000..6cd678f
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"conv2d_transpose_1.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_1.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,1,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_0.b_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_0.w_0"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,24,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.w_2"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.w_1"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.b_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,6,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,6,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,6,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,6,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[6,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,360,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,42,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,18,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,24,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,12,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.b_0"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[42],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[42,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.b_0"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[18],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[18,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[12],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[12,48,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_188.b_0"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_188.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_187.b_0"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_187.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_186.b_0"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_186.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_185.b_0"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_185.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_184.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_184.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_183.b_0"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_183.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_182.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_182.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,48,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_181.b_0"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_181.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_180.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_180.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_179.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_179.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_178.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_178.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_177.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_177.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_176.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_176.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_175.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_175.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_174.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_174.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_173.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_173.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_172.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_172.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_171.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_171.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_170.b_0"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_170.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_169.b_0"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_169.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_168.b_0"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_168.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,48,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_167.b_0"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_167.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_166.b_0"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_166.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_165.b_0"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_165.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_164.b_0"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_164.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,-1,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":215}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":214},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":266},{"%":209}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":208},{"%":268}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":267},{"%":269}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":213},{"%":270}],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":271},{"%":212}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":48},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":275},{"%":203}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":202},{"%":277}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":276},{"%":278}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":207},{"%":279}],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":280},{"%":206}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":284},{"%":197}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":196},{"%":286}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":285},{"%":287}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":201},{"%":288}],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":289},{"%":200}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":48},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":293},{"%":193}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":192},{"%":295}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":294},{"%":296}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":195},{"%":297}],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":298},{"%":194}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":299},{"%":187}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":186},{"%":301}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":300},{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":305}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":189},{"%":306}],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":307},{"%":188}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":96},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":308},{"%":181}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":180},{"%":310}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":309},{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":314}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":183},{"%":315}],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":316},{"%":182}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":317},{"%":175}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":174},{"%":319}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":318},{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":323}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":177},{"%":324}],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":325},{"%":176}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":96},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":326},{"%":171}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":328}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":327},{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":113}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":112},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":419},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":421},{"%":111}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":423}],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":426},{"%":109}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":108},{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":427},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":430}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":419},{"%":431}],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":432},{"%":103}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":434}],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":437},{"%":106}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":438}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":105},{"%":439}],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":440},{"%":104}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":441},{"%":97}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":96},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":442},{"%":444}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":101},{"%":445}],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":446},{"%":100}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":450},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":452},{"%":95}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":454}],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":457},{"%":93}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":92},{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":458},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":461}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":450},{"%":462}],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":463},{"%":87}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":465}],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":468},{"%":90}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":469}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":89},{"%":470}],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":471},{"%":88}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":472},{"%":81}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":80},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":473},{"%":475}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":85},{"%":476}],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":477},{"%":84}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":481},{"%":75}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":74},{"%":483}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":482},{"%":484}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":79},{"%":485}],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":486},{"%":78}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":490},{"%":69}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":68},{"%":492}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":491},{"%":493}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":73},{"%":494}],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":495},{"%":72}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":499},{"%":63}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":62},{"%":501}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,384,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":500},{"%":502}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":67},{"%":503}],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":504},{"%":66}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D/"},"N":"struct_name"}],"I":[{"%":293},{"%":61}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,12,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":510}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,12,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D/"},"N":"struct_name"}],"I":[{"%":509},{"%":511}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,12,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":326},{"%":59}],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,18,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":58},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,18,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":513},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,18,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":413},{"%":57}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,42,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_2/"},"N":"struct_name"}],"I":[],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":56},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,42,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":517},{"%":519}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,42,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":508},{"%":55}],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,360,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_3/"},"N":"struct_name"}],"I":[],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":54},{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,360,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":521},{"%":523}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,360,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":38}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":525},{"%":526}],"O":[{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":527},{"%":37}],"O":[{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":36},{"%":529}],"O":[{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":528},{"%":530}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/"},"N":"struct_name"}],"I":[{"%":531}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":532},{"%":35}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":34},{"%":534}],"O":[{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":533},{"%":535}],"O":[{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/"},"N":"struct_name"}],"I":[{"%":536}],"O":[{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/SEModule/"},"N":"struct_name"}],"I":[{"%":525},{"%":537}],"O":[{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer/"},"N":"struct_name"}],"I":[{"%":525},{"%":538}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":520},{"%":43}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":540},{"%":541}],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":542},{"%":42}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":41},{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":543},{"%":545}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/"},"N":"struct_name"}],"I":[{"%":546}],"O":[{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":547},{"%":40}],"O":[{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":39},{"%":549}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":548},{"%":550}],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/"},"N":"struct_name"}],"I":[{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/SEModule/"},"N":"struct_name"}],"I":[{"%":540},{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_1/"},"N":"struct_name"}],"I":[{"%":540},{"%":553}],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":516},{"%":48}],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":555},{"%":556}],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":557},{"%":47}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":46},{"%":559}],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":558},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":562},{"%":45}],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":44},{"%":564}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":563},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/SEModule/"},"N":"struct_name"}],"I":[{"%":555},{"%":567}],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_2/"},"N":"struct_name"}],"I":[{"%":555},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":53}],"O":[{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":570},{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":572},{"%":52}],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":51},{"%":574}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":573},{"%":575}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/"},"N":"struct_name"}],"I":[{"%":576}],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":577},{"%":50}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":49},{"%":579}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":578},{"%":580}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/"},"N":"struct_name"}],"I":[{"%":581}],"O":[{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/SEModule/"},"N":"struct_name"}],"I":[{"%":570},{"%":582}],"O":[{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_3/"},"N":"struct_name"}],"I":[{"%":570},{"%":583}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":539},{"%":0},{"%":0},{"%":0}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":554},{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":0},{"%":0}],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":569},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":588},{"%":0},{"%":0},{"%":0}],"O":[{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":584},{"%":589}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":539},{"%":18}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":591},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":593},{"%":17}],"O":[{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":16},{"%":595}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":594},{"%":596}],"O":[{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/"},"N":"struct_name"}],"I":[{"%":597}],"O":[{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":598},{"%":15}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":14},{"%":600}],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":599},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/SEModule/"},"N":"struct_name"}],"I":[{"%":591},{"%":603}],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_4/"},"N":"struct_name"}],"I":[{"%":591},{"%":604}],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/Conv2D/"},"N":"struct_name"}],"I":[{"%":586},{"%":23}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":608},{"%":22}],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":21},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":609},{"%":611}],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/"},"N":"struct_name"}],"I":[{"%":612}],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":613},{"%":20}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":19},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":614},{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/"},"N":"struct_name"}],"I":[{"%":617}],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/SEModule/"},"N":"struct_name"}],"I":[{"%":606},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_5/"},"N":"struct_name"}],"I":[{"%":606},{"%":619}],"O":[{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/Conv2D/"},"N":"struct_name"}],"I":[{"%":588},{"%":28}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":621},{"%":622}],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":623},{"%":27}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":26},{"%":625}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":624},{"%":626}],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/"},"N":"struct_name"}],"I":[{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":628},{"%":25}],"O":[{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":24},{"%":630}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":629},{"%":631}],"O":[{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/"},"N":"struct_name"}],"I":[{"%":632}],"O":[{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/SEModule/"},"N":"struct_name"}],"I":[{"%":621},{"%":633}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_6/"},"N":"struct_name"}],"I":[{"%":621},{"%":634}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/Conv2D/"},"N":"struct_name"}],"I":[{"%":590},{"%":33}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":636},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":638},{"%":32}],"O":[{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":31},{"%":640}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":639},{"%":641}],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/"},"N":"struct_name"}],"I":[{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,6,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":643},{"%":30}],"O":[{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":29},{"%":645}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":644},{"%":646}],"O":[{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.20000000298023224},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/"},"N":"struct_name"}],"I":[{"%":647}],"O":[{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/SEModule/"},"N":"struct_name"}],"I":[{"%":636},{"%":648}],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/RSELayer_7/"},"N":"struct_name"}],"I":[{"%":636},{"%":649}],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":8.0},{"#":"0.a_f32","D":8.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":605},{"%":0},{"%":0},{"%":0}],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":4.0},{"#":"0.a_f32","D":4.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":620},{"%":0},{"%":0},{"%":0}],"O":[{"%":652,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":635},{"%":0},{"%":0},{"%":0}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":651},{"%":652},{"%":653},{"%":650}],"O":[{"%":655,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/RSEFPN/"},"N":"struct_name"}],"I":[{"%":655},{"%":654}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":13}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":false},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/BatchNorm/"},"N":"struct_name"}],"I":[{"%":657},{"%":10},{"%":9},{"%":12},{"%":11}],"O":[{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/BatchNorm/"},"N":"struct_name"}],"I":[{"%":658}],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[],"O":[{"%":665,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[0],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d_transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_array","D":[]},"N":"output_padding"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[{"%":664},{"%":8},{"%":665}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":24},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[{"%":7},{"%":667}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,24,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[{"%":666},{"%":668}],"O":[{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":false},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/BatchNorm_1/"},"N":"struct_name"}],"I":[{"%":669},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[24],"NCHW",[],0]}},{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/BatchNorm_1/"},"N":"struct_name"}],"I":[{"%":670}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,24,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[],"O":[{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[0],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d_transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_array","D":[]},"N":"output_padding"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[{"%":676},{"%":2},{"%":677}],"O":[{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[],"O":[{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[{"%":1},{"%":679}],"O":[{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,1,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[{"%":678},{"%":680}],"O":[{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.sigmoid","A":[{"AT":{"#":"0.a_str","D":"/DBHead/Head/"},"N":"struct_name"}],"I":[{"%":681}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":682}],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.pdiparams b/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.pdiparams
new file mode 100644
index 0000000..f59956d
Binary files /dev/null and b/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.pdiparams differ
diff --git a/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.yml b/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.yml
new file mode 100644
index 0000000..579d106
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_mobile_det_infer/inference.yml
@@ -0,0 +1,53 @@
+Global:
+  model_name: PP-OCRv5_mobile_det
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 32
+          - 32
+        - - 1
+          - 3
+          - 736
+          - 736
+        - - 1
+          - 3
+          - 4000
+          - 4000
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - DetLabelEncode: null
+  - DetResizeForTest:
+      resize_long: 960
+  - NormalizeImage:
+      mean:
+      - 0.485
+      - 0.456
+      - 0.406
+      order: hwc
+      scale: 1./255.
+      std:
+      - 0.229
+      - 0.224
+      - 0.225
+  - ToCHWImage: null
+  - KeepKeys:
+      keep_keys:
+      - image
+      - shape
+      - polys
+      - ignore_tags
+PostProcess:
+  name: DBPostProcess
+  thresh: 0.3
+  box_thresh: 0.6
+  max_candidates: 1000
+  unclip_ratio: 1.5
diff --git a/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..90f76a8
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[18385],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,18385],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..0c59d01
Binary files /dev/null and b/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..176f6d5
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,18426 @@
+Global:
+  model_name: PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - 　
+  - 一
+  - 乙
+  - 二
+  - 十
+  - 丁
+  - 厂
+  - 七
+  - 卜
+  - 八
+  - 人
+  - 入
+  - 儿
+  - 匕
+  - 几
+  - 九
+  - 刁
+  - 了
+  - 刀
+  - 力
+  - 乃
+  - 又
+  - 三
+  - 干
+  - 于
+  - 亏
+  - 工
+  - 土
+  - 士
+  - 才
+  - 下
+  - 寸
+  - 大
+  - 丈
+  - 与
+  - 万
+  - 上
+  - 小
+  - 口
+  - 山
+  - 巾
+  - 千
+  - 乞
+  - 川
+  - 亿
+  - 个
+  - 夕
+  - 久
+  - 么
+  - 勺
+  - 凡
+  - 丸
+  - 及
+  - 广
+  - 亡
+  - 门
+  - 丫
+  - 义
+  - 之
+  - 尸
+  - 己
+  - 已
+  - 巳
+  - 弓
+  - 子
+  - 卫
+  - 也
+  - 女
+  - 刃
+  - 飞
+  - 习
+  - 叉
+  - 马
+  - 乡
+  - 丰
+  - 王
+  - 开
+  - 井
+  - 天
+  - 夫
+  - 元
+  - 无
+  - 云
+  - 专
+  - 丐
+  - 扎
+  - 艺
+  - 木
+  - 五
+  - 支
+  - 厅
+  - 不
+  - 犬
+  - 太
+  - 区
+  - 历
+  - 歹
+  - 友
+  - 尤
+  - 匹
+  - 车
+  - 巨
+  - 牙
+  - 屯
+  - 戈
+  - 比
+  - 互
+  - 切
+  - 瓦
+  - 止
+  - 少
+  - 曰
+  - 日
+  - 中
+  - 贝
+  - 冈
+  - 内
+  - 水
+  - 见
+  - 午
+  - 牛
+  - 手
+  - 气
+  - 毛
+  - 壬
+  - 升
+  - 夭
+  - 长
+  - 仁
+  - 什
+  - 片
+  - 仆
+  - 化
+  - 仇
+  - 币
+  - 仍
+  - 仅
+  - 斤
+  - 爪
+  - 反
+  - 介
+  - 父
+  - 从
+  - 仑
+  - 今
+  - 凶
+  - 分
+  - 乏
+  - 公
+  - 仓
+  - 月
+  - 氏
+  - 勿
+  - 欠
+  - 风
+  - 丹
+  - 匀
+  - 乌
+  - 勾
+  - 凤
+  - 六
+  - 文
+  - 亢
+  - 方
+  - 火
+  - 为
+  - 斗
+  - 忆
+  - 计
+  - 订
+  - 户
+  - 认
+  - 冗
+  - 讥
+  - 心
+  - 尺
+  - 引
+  - 丑
+  - 巴
+  - 孔
+  - 队
+  - 办
+  - 以
+  - 允
+  - 予
+  - 邓
+  - 劝
+  - 双
+  - 书
+  - 幻
+  - 玉
+  - 刊
+  - 未
+  - 末
+  - 示
+  - 击
+  - 打
+  - 巧
+  - 正
+  - 扑
+  - 卉
+  - 扒
+  - 功
+  - 扔
+  - 去
+  - 甘
+  - 世
+  - 艾
+  - 古
+  - 节
+  - 本
+  - 术
+  - 可
+  - 丙
+  - 左
+  - 厉
+  - 石
+  - 右
+  - 布
+  - 夯
+  - 戊
+  - 龙
+  - 平
+  - 灭
+  - 轧
+  - 东
+  - 卡
+  - 北
+  - 占
+  - 凸
+  - 卢
+  - 业
+  - 旧
+  - 帅
+  - 归
+  - 旦
+  - 目
+  - 且
+  - 叶
+  - 甲
+  - 申
+  - 叮
+  - 电
+  - 号
+  - 田
+  - 由
+  - 只
+  - 叭
+  - 史
+  - 央
+  - 兄
+  - 叽
+  - 叼
+  - 叫
+  - 叩
+  - 叨
+  - 另
+  - 叹
+  - 冉
+  - 皿
+  - 凹
+  - 囚
+  - 四
+  - 生
+  - 矢
+  - 失
+  - 乍
+  - 禾
+  - 丘
+  - 付
+  - 仗
+  - 代
+  - 仙
+  - 们
+  - 仪
+  - 白
+  - 仔
+  - 他
+  - 斥
+  - 瓜
+  - 乎
+  - 丛
+  - 令
+  - 用
+  - 甩
+  - 印
+  - 尔
+  - 乐
+  - 句
+  - 匆
+  - 册
+  - 卯
+  - 犯
+  - 外
+  - 处
+  - 冬
+  - 鸟
+  - 务
+  - 包
+  - 饥
+  - 主
+  - 市
+  - 立
+  - 冯
+  - 玄
+  - 闪
+  - 兰
+  - 半
+  - 汁
+  - 汇
+  - 头
+  - 汉
+  - 宁
+  - 穴
+  - 它
+  - 讨
+  - 写
+  - 让
+  - 礼
+  - 训
+  - 议
+  - 必
+  - 讯
+  - 记
+  - 永
+  - 司
+  - 尼
+  - 民
+  - 弗
+  - 弘
+  - 出
+  - 辽
+  - 奶
+  - 奴
+  - 召
+  - 加
+  - 皮
+  - 边
+  - 孕
+  - 发
+  - 圣
+  - 对
+  - 台
+  - 矛
+  - 纠
+  - 母
+  - 幼
+  - 丝
+  - 邦
+  - 式
+  - 迂
+  - 刑
+  - 戎
+  - 动
+  - 扛
+  - 寺
+  - 吉
+  - 扣
+  - 考
+  - 托
+  - 老
+  - 巩
+  - 圾
+  - 执
+  - 扩
+  - 扫
+  - 地
+  - 场
+  - 扬
+  - 耳
+  - 芋
+  - 共
+  - 芒
+  - 亚
+  - 芝
+  - 朽
+  - 朴
+  - 机
+  - 权
+  - 过
+  - 臣
+  - 吏
+  - 再
+  - 协
+  - 西
+  - 压
+  - 厌
+  - 戌
+  - 在
+  - 百
+  - 有
+  - 存
+  - 而
+  - 页
+  - 匠
+  - 夸
+  - 夺
+  - 灰
+  - 达
+  - 列
+  - 死
+  - 成
+  - 夹
+  - 夷
+  - 轨
+  - 邪
+  - 尧
+  - 划
+  - 迈
+  - 毕
+  - 至
+  - 此
+  - 贞
+  - 师
+  - 尘
+  - 尖
+  - 劣
+  - 光
+  - 当
+  - 早
+  - 吁
+  - 吐
+  - 吓
+  - 虫
+  - 曲
+  - 团
+  - 吕
+  - 同
+  - 吊
+  - 吃
+  - 因
+  - 吸
+  - 吗
+  - 吆
+  - 屿
+  - 屹
+  - 岁
+  - 帆
+  - 回
+  - 岂
+  - 则
+  - 刚
+  - 网
+  - 肉
+  - 年
+  - 朱
+  - 先
+  - 丢
+  - 廷
+  - 舌
+  - 竹
+  - 迁
+  - 乔
+  - 迄
+  - 伟
+  - 传
+  - 乒
+  - 乓
+  - 休
+  - 伍
+  - 伏
+  - 优
+  - 臼
+  - 伐
+  - 延
+  - 仲
+  - 件
+  - 任
+  - 伤
+  - 价
+  - 伦
+  - 份
+  - 华
+  - 仰
+  - 仿
+  - 伙
+  - 伪
+  - 自
+  - 伊
+  - 血
+  - 向
+  - 似
+  - 后
+  - 行
+  - 舟
+  - 全
+  - 会
+  - 杀
+  - 合
+  - 兆
+  - 企
+  - 众
+  - 爷
+  - 伞
+  - 创
+  - 肌
+  - 肋
+  - 朵
+  - 杂
+  - 危
+  - 旬
+  - 旨
+  - 旭
+  - 负
+  - 匈
+  - 名
+  - 各
+  - 多
+  - 争
+  - 色
+  - 壮
+  - 冲
+  - 妆
+  - 冰
+  - 庄
+  - 庆
+  - 亦
+  - 刘
+  - 齐
+  - 交
+  - 衣
+  - 次
+  - 产
+  - 决
+  - 亥
+  - 充
+  - 妄
+  - 闭
+  - 问
+  - 闯
+  - 羊
+  - 并
+  - 关
+  - 米
+  - 灯
+  - 州
+  - 汗
+  - 污
+  - 江
+  - 汛
+  - 池
+  - 汝
+  - 汤
+  - 忙
+  - 兴
+  - 宇
+  - 守
+  - 宅
+  - 字
+  - 安
+  - 讲
+  - 讳
+  - 军
+  - 讶
+  - 许
+  - 讹
+  - 论
+  - 讼
+  - 农
+  - 讽
+  - 设
+  - 访
+  - 诀
+  - 寻
+  - 那
+  - 迅
+  - 尽
+  - 导
+  - 异
+  - 弛
+  - 孙
+  - 阵
+  - 阳
+  - 收
+  - 阶
+  - 阴
+  - 防
+  - 奸
+  - 如
+  - 妇
+  - 妃
+  - 好
+  - 她
+  - 妈
+  - 戏
+  - 羽
+  - 观
+  - 欢
+  - 买
+  - 红
+  - 驮
+  - 纤
+  - 驯
+  - 约
+  - 级
+  - 纪
+  - 驰
+  - 纫
+  - 巡
+  - 寿
+  - 弄
+  - 麦
+  - 玖
+  - 玛
+  - 形
+  - 进
+  - 戒
+  - 吞
+  - 远
+  - 违
+  - 韧
+  - 运
+  - 扶
+  - 抚
+  - 坛
+  - 技
+  - 坏
+  - 抠
+  - 扰
+  - 扼
+  - 拒
+  - 找
+  - 批
+  - 址
+  - 扯
+  - 走
+  - 抄
+  - 贡
+  - 汞
+  - 坝
+  - 攻
+  - 赤
+  - 折
+  - 抓
+  - 扳
+  - 抡
+  - 扮
+  - 抢
+  - 孝
+  - 坎
+  - 均
+  - 抑
+  - 抛
+  - 投
+  - 坟
+  - 坑
+  - 抗
+  - 坊
+  - 抖
+  - 护
+  - 壳
+  - 志
+  - 块
+  - 扭
+  - 声
+  - 把
+  - 报
+  - 拟
+  - 却
+  - 抒
+  - 劫
+  - 芙
+  - 芜
+  - 苇
+  - 芽
+  - 花
+  - 芹
+  - 芥
+  - 芬
+  - 苍
+  - 芳
+  - 严
+  - 芦
+  - 芯
+  - 劳
+  - 克
+  - 芭
+  - 苏
+  - 杆
+  - 杠
+  - 杜
+  - 材
+  - 村
+  - 杖
+  - 杏
+  - 杉
+  - 巫
+  - 极
+  - 李
+  - 杨
+  - 求
+  - 甫
+  - 匣
+  - 更
+  - 束
+  - 吾
+  - 豆
+  - 两
+  - 酉
+  - 丽
+  - 医
+  - 辰
+  - 励
+  - 否
+  - 还
+  - 尬
+  - 歼
+  - 来
+  - 连
+  - 轩
+  - 步
+  - 卤
+  - 坚
+  - 肖
+  - 旱
+  - 盯
+  - 呈
+  - 时
+  - 吴
+  - 助
+  - 县
+  - 里
+  - 呆
+  - 吱
+  - 吠
+  - 呕
+  - 园
+  - 旷
+  - 围
+  - 呀
+  - 吨
+  - 足
+  - 邮
+  - 男
+  - 困
+  - 吵
+  - 串
+  - 员
+  - 呐
+  - 听
+  - 吟
+  - 吩
+  - 呛
+  - 吻
+  - 吹
+  - 呜
+  - 吭
+  - 吧
+  - 邑
+  - 吼
+  - 囤
+  - 别
+  - 吮
+  - 岖
+  - 岗
+  - 帐
+  - 财
+  - 针
+  - 钉
+  - 牡
+  - 告
+  - 我
+  - 乱
+  - 利
+  - 秃
+  - 秀
+  - 私
+  - 每
+  - 兵
+  - 估
+  - 体
+  - 何
+  - 佐
+  - 佑
+  - 但
+  - 伸
+  - 佃
+  - 作
+  - 伯
+  - 伶
+  - 佣
+  - 低
+  - 你
+  - 住
+  - 位
+  - 伴
+  - 身
+  - 皂
+  - 伺
+  - 佛
+  - 囱
+  - 近
+  - 彻
+  - 役
+  - 返
+  - 余
+  - 希
+  - 坐
+  - 谷
+  - 妥
+  - 含
+  - 邻
+  - 岔
+  - 肝
+  - 肛
+  - 肚
+  - 肘
+  - 肠
+  - 龟
+  - 甸
+  - 免
+  - 狂
+  - 犹
+  - 狈
+  - 角
+  - 删
+  - 条
+  - 彤
+  - 卵
+  - 灸
+  - 岛
+  - 刨
+  - 迎
+  - 饭
+  - 饮
+  - 系
+  - 言
+  - 冻
+  - 状
+  - 亩
+  - 况
+  - 床
+  - 库
+  - 庇
+  - 疗
+  - 吝
+  - 应
+  - 这
+  - 冷
+  - 庐
+  - 序
+  - 辛
+  - 弃
+  - 冶
+  - 忘
+  - 闰
+  - 闲
+  - 间
+  - 闷
+  - 判
+  - 兑
+  - 灶
+  - 灿
+  - 灼
+  - 弟
+  - 汪
+  - 沐
+  - 沛
+  - 汰
+  - 沥
+  - 沙
+  - 汽
+  - 沃
+  - 沦
+  - 汹
+  - 泛
+  - 沧
+  - 没
+  - 沟
+  - 沪
+  - 沈
+  - 沉
+  - 沁
+  - 怀
+  - 忧
+  - 忱
+  - 快
+  - 完
+  - 宋
+  - 宏
+  - 牢
+  - 究
+  - 穷
+  - 灾
+  - 良
+  - 证
+  - 启
+  - 评
+  - 补
+  - 初
+  - 社
+  - 祀
+  - 识
+  - 诈
+  - 诉
+  - 罕
+  - 诊
+  - 词
+  - 译
+  - 君
+  - 灵
+  - 即
+  - 层
+  - 屁
+  - 尿
+  - 尾
+  - 迟
+  - 局
+  - 改
+  - 张
+  - 忌
+  - 际
+  - 陆
+  - 阿
+  - 陈
+  - 阻
+  - 附
+  - 坠
+  - 妓
+  - 妙
+  - 妖
+  - 姊
+  - 妨
+  - 妒
+  - 努
+  - 忍
+  - 劲
+  - 矣
+  - 鸡
+  - 纬
+  - 驱
+  - 纯
+  - 纱
+  - 纲
+  - 纳
+  - 驳
+  - 纵
+  - 纷
+  - 纸
+  - 纹
+  - 纺
+  - 驴
+  - 纽
+  - 奉
+  - 玩
+  - 环
+  - 武
+  - 青
+  - 责
+  - 现
+  - 玫
+  - 表
+  - 规
+  - 抹
+  - 卦
+  - 坷
+  - 坯
+  - 拓
+  - 拢
+  - 拔
+  - 坪
+  - 拣
+  - 坦
+  - 担
+  - 坤
+  - 押
+  - 抽
+  - 拐
+  - 拖
+  - 者
+  - 拍
+  - 顶
+  - 拆
+  - 拎
+  - 拥
+  - 抵
+  - 拘
+  - 势
+  - 抱
+  - 拄
+  - 垃
+  - 拉
+  - 拦
+  - 幸
+  - 拌
+  - 拧
+  - 拂
+  - 拙
+  - 招
+  - 坡
+  - 披
+  - 拨
+  - 择
+  - 抬
+  - 拇
+  - 拗
+  - 其
+  - 取
+  - 茉
+  - 苦
+  - 昔
+  - 苛
+  - 若
+  - 茂
+  - 苹
+  - 苗
+  - 英
+  - 苟
+  - 苑
+  - 苞
+  - 范
+  - 直
+  - 茁
+  - 茄
+  - 茎
+  - 苔
+  - 茅
+  - 枉
+  - 林
+  - 枝
+  - 杯
+  - 枢
+  - 柜
+  - 枚
+  - 析
+  - 板
+  - 松
+  - 枪
+  - 枫
+  - 构
+  - 杭
+  - 杰
+  - 述
+  - 枕
+  - 丧
+  - 或
+  - 画
+  - 卧
+  - 事
+  - 刺
+  - 枣
+  - 雨
+  - 卖
+  - 郁
+  - 矾
+  - 矿
+  - 码
+  - 厕
+  - 奈
+  - 奔
+  - 奇
+  - 奋
+  - 态
+  - 欧
+  - 殴
+  - 垄
+  - 妻
+  - 轰
+  - 顷
+  - 转
+  - 斩
+  - 轮
+  - 软
+  - 到
+  - 非
+  - 叔
+  - 歧
+  - 肯
+  - 齿
+  - 些
+  - 卓
+  - 虎
+  - 虏
+  - 肾
+  - 贤
+  - 尚
+  - 旺
+  - 具
+  - 味
+  - 果
+  - 昆
+  - 国
+  - 哎
+  - 咕
+  - 昌
+  - 呵
+  - 畅
+  - 明
+  - 易
+  - 咙
+  - 昂
+  - 迪
+  - 典
+  - 固
+  - 忠
+  - 呻
+  - 咒
+  - 咋
+  - 咐
+  - 呼
+  - 鸣
+  - 咏
+  - 呢
+  - 咄
+  - 咖
+  - 岸
+  - 岩
+  - 帖
+  - 罗
+  - 帜
+  - 帕
+  - 岭
+  - 凯
+  - 败
+  - 账
+  - 贩
+  - 贬
+  - 购
+  - 贮
+  - 图
+  - 钓
+  - 制
+  - 知
+  - 迭
+  - 氛
+  - 垂
+  - 牧
+  - 物
+  - 乖
+  - 刮
+  - 秆
+  - 和
+  - 季
+  - 委
+  - 秉
+  - 佳
+  - 侍
+  - 岳
+  - 供
+  - 使
+  - 例
+  - 侠
+  - 侥
+  - 版
+  - 侄
+  - 侦
+  - 侣
+  - 侧
+  - 凭
+  - 侨
+  - 佩
+  - 货
+  - 侈
+  - 依
+  - 卑
+  - 的
+  - 迫
+  - 质
+  - 欣
+  - 征
+  - 往
+  - 爬
+  - 彼
+  - 径
+  - 所
+  - 舍
+  - 金
+  - 刹
+  - 命
+  - 肴
+  - 斧
+  - 爸
+  - 采
+  - 觅
+  - 受
+  - 乳
+  - 贪
+  - 念
+  - 贫
+  - 忿
+  - 肤
+  - 肺
+  - 肢
+  - 肿
+  - 胀
+  - 朋
+  - 股
+  - 肮
+  - 肪
+  - 肥
+  - 服
+  - 胁
+  - 周
+  - 昏
+  - 鱼
+  - 兔
+  - 狐
+  - 忽
+  - 狗
+  - 狞
+  - 备
+  - 饰
+  - 饱
+  - 饲
+  - 变
+  - 京
+  - 享
+  - 庞
+  - 店
+  - 夜
+  - 庙
+  - 府
+  - 底
+  - 疟
+  - 疙
+  - 疚
+  - 剂
+  - 卒
+  - 郊
+  - 庚
+  - 废
+  - 净
+  - 盲
+  - 放
+  - 刻
+  - 育
+  - 氓
+  - 闸
+  - 闹
+  - 郑
+  - 券
+  - 卷
+  - 单
+  - 炬
+  - 炒
+  - 炊
+  - 炕
+  - 炎
+  - 炉
+  - 沫
+  - 浅
+  - 法
+  - 泄
+  - 沽
+  - 河
+  - 沾
+  - 泪
+  - 沮
+  - 油
+  - 泊
+  - 沿
+  - 泡
+  - 注
+  - 泣
+  - 泞
+  - 泻
+  - 泌
+  - 泳
+  - 泥
+  - 沸
+  - 沼
+  - 波
+  - 泼
+  - 泽
+  - 治
+  - 怔
+  - 怯
+  - 怖
+  - 性
+  - 怕
+  - 怜
+  - 怪
+  - 怡
+  - 学
+  - 宝
+  - 宗
+  - 定
+  - 宠
+  - 宜
+  - 审
+  - 宙
+  - 官
+  - 空
+  - 帘
+  - 宛
+  - 实
+  - 试
+  - 郎
+  - 诗
+  - 肩
+  - 房
+  - 诚
+  - 衬
+  - 衫
+  - 视
+  - 祈
+  - 话
+  - 诞
+  - 诡
+  - 询
+  - 该
+  - 详
+  - 建
+  - 肃
+  - 录
+  - 隶
+  - 帚
+  - 屉
+  - 居
+  - 届
+  - 刷
+  - 屈
+  - 弧
+  - 弥
+  - 弦
+  - 承
+  - 孟
+  - 陋
+  - 陌
+  - 孤
+  - 陕
+  - 降
+  - 函
+  - 限
+  - 妹
+  - 姑
+  - 姐
+  - 姓
+  - 妮
+  - 始
+  - 姆
+  - 迢
+  - 驾
+  - 叁
+  - 参
+  - 艰
+  - 线
+  - 练
+  - 组
+  - 绅
+  - 细
+  - 驶
+  - 织
+  - 驹
+  - 终
+  - 驻
+  - 绊
+  - 驼
+  - 绍
+  - 绎
+  - 经
+  - 贯
+  - 契
+  - 贰
+  - 奏
+  - 春
+  - 帮
+  - 玷
+  - 珍
+  - 玲
+  - 玻
+  - 毒
+  - 型
+  - 拭
+  - 挂
+  - 封
+  - 持
+  - 拷
+  - 拱
+  - 项
+  - 垮
+  - 挎
+  - 城
+  - 挟
+  - 挠
+  - 政
+  - 赴
+  - 赵
+  - 挡
+  - 拽
+  - 哉
+  - 挺
+  - 括
+  - 垢
+  - 拴
+  - 拾
+  - 挑
+  - 垛
+  - 指
+  - 垫
+  - 挣
+  - 挤
+  - 拼
+  - 挖
+  - 按
+  - 挥
+  - 挪
+  - 拯
+  - 某
+  - 甚
+  - 荆
+  - 茸
+  - 革
+  - 茬
+  - 荐
+  - 巷
+  - 带
+  - 草
+  - 茧
+  - 茵
+  - 茶
+  - 荒
+  - 茫
+  - 荡
+  - 荣
+  - 荤
+  - 荧
+  - 故
+  - 胡
+  - 荫
+  - 荔
+  - 南
+  - 药
+  - 标
+  - 栈
+  - 柑
+  - 枯
+  - 柄
+  - 栋
+  - 相
+  - 查
+  - 柏
+  - 栅
+  - 柳
+  - 柱
+  - 柿
+  - 栏
+  - 柠
+  - 树
+  - 勃
+  - 要
+  - 柬
+  - 咸
+  - 威
+  - 歪
+  - 研
+  - 砖
+  - 厘
+  - 厚
+  - 砌
+  - 砂
+  - 泵
+  - 砚
+  - 砍
+  - 面
+  - 耐
+  - 耍
+  - 牵
+  - 鸥
+  - 残
+  - 殃
+  - 轴
+  - 轻
+  - 鸦
+  - 皆
+  - 韭
+  - 背
+  - 战
+  - 点
+  - 虐
+  - 临
+  - 览
+  - 竖
+  - 省
+  - 削
+  - 尝
+  - 昧
+  - 盹
+  - 是
+  - 盼
+  - 眨
+  - 哇
+  - 哄
+  - 哑
+  - 显
+  - 冒
+  - 映
+  - 星
+  - 昨
+  - 咧
+  - 昭
+  - 畏
+  - 趴
+  - 胃
+  - 贵
+  - 界
+  - 虹
+  - 虾
+  - 蚁
+  - 思
+  - 蚂
+  - 虽
+  - 品
+  - 咽
+  - 骂
+  - 勋
+  - 哗
+  - 咱
+  - 响
+  - 哈
+  - 哆
+  - 咬
+  - 咳
+  - 咪
+  - 哪
+  - 哟
+  - 炭
+  - 峡
+  - 罚
+  - 贱
+  - 贴
+  - 贻
+  - 骨
+  - 幽
+  - 钙
+  - 钝
+  - 钞
+  - 钟
+  - 钢
+  - 钠
+  - 钥
+  - 钦
+  - 钧
+  - 钩
+  - 钮
+  - 卸
+  - 缸
+  - 拜
+  - 看
+  - 矩
+  - 毡
+  - 氢
+  - 怎
+  - 牲
+  - 选
+  - 适
+  - 秒
+  - 香
+  - 种
+  - 秋
+  - 科
+  - 重
+  - 复
+  - 竿
+  - 段
+  - 便
+  - 俩
+  - 贷
+  - 顺
+  - 修
+  - 俏
+  - 保
+  - 促
+  - 俄
+  - 俐
+  - 侮
+  - 俭
+  - 俗
+  - 俘
+  - 信
+  - 皇
+  - 泉
+  - 鬼
+  - 侵
+  - 禹
+  - 侯
+  - 追
+  - 俊
+  - 盾
+  - 待
+  - 徊
+  - 衍
+  - 律
+  - 很
+  - 须
+  - 叙
+  - 剑
+  - 逃
+  - 食
+  - 盆
+  - 胚
+  - 胧
+  - 胆
+  - 胜
+  - 胞
+  - 胖
+  - 脉
+  - 胎
+  - 勉
+  - 狭
+  - 狮
+  - 独
+  - 狰
+  - 狡
+  - 狱
+  - 狠
+  - 贸
+  - 怨
+  - 急
+  - 饵
+  - 饶
+  - 蚀
+  - 饺
+  - 饼
+  - 峦
+  - 弯
+  - 将
+  - 奖
+  - 哀
+  - 亭
+  - 亮
+  - 度
+  - 迹
+  - 庭
+  - 疮
+  - 疯
+  - 疫
+  - 疤
+  - 咨
+  - 姿
+  - 亲
+  - 音
+  - 帝
+  - 施
+  - 闺
+  - 闻
+  - 闽
+  - 阀
+  - 阁
+  - 差
+  - 养
+  - 美
+  - 姜
+  - 叛
+  - 送
+  - 类
+  - 迷
+  - 籽
+  - 娄
+  - 前
+  - 首
+  - 逆
+  - 兹
+  - 总
+  - 炼
+  - 炸
+  - 烁
+  - 炮
+  - 炫
+  - 烂
+  - 剃
+  - 洼
+  - 洁
+  - 洪
+  - 洒
+  - 柒
+  - 浇
+  - 浊
+  - 洞
+  - 测
+  - 洗
+  - 活
+  - 派
+  - 洽
+  - 染
+  - 洛
+  - 浏
+  - 济
+  - 洋
+  - 洲
+  - 浑
+  - 浓
+  - 津
+  - 恃
+  - 恒
+  - 恢
+  - 恍
+  - 恬
+  - 恤
+  - 恰
+  - 恼
+  - 恨
+  - 举
+  - 觉
+  - 宣
+  - 宦
+  - 室
+  - 宫
+  - 宪
+  - 突
+  - 穿
+  - 窃
+  - 客
+  - 诫
+  - 冠
+  - 诬
+  - 语
+  - 扁
+  - 袄
+  - 祖
+  - 神
+  - 祝
+  - 祠
+  - 误
+  - 诱
+  - 诲
+  - 说
+  - 诵
+  - 垦
+  - 退
+  - 既
+  - 屋
+  - 昼
+  - 屏
+  - 屎
+  - 费
+  - 陡
+  - 逊
+  - 眉
+  - 孩
+  - 陨
+  - 除
+  - 险
+  - 院
+  - 娃
+  - 姥
+  - 姨
+  - 姻
+  - 娇
+  - 姚
+  - 娜
+  - 怒
+  - 架
+  - 贺
+  - 盈
+  - 勇
+  - 怠
+  - 癸
+  - 蚤
+  - 柔
+  - 垒
+  - 绑
+  - 绒
+  - 结
+  - 绕
+  - 骄
+  - 绘
+  - 给
+  - 绚
+  - 骆
+  - 络
+  - 绝
+  - 绞
+  - 骇
+  - 统
+  - 耕
+  - 耘
+  - 耗
+  - 耙
+  - 艳
+  - 泰
+  - 秦
+  - 珠
+  - 班
+  - 素
+  - 匿
+  - 蚕
+  - 顽
+  - 盏
+  - 匪
+  - 捞
+  - 栽
+  - 捕
+  - 埂
+  - 捂
+  - 振
+  - 载
+  - 赶
+  - 起
+  - 盐
+  - 捎
+  - 捍
+  - 捏
+  - 埋
+  - 捉
+  - 捆
+  - 捐
+  - 损
+  - 袁
+  - 捌
+  - 都
+  - 哲
+  - 逝
+  - 捡
+  - 挫
+  - 换
+  - 挽
+  - 挚
+  - 热
+  - 恐
+  - 捣
+  - 壶
+  - 捅
+  - 埃
+  - 挨
+  - 耻
+  - 耿
+  - 耽
+  - 聂
+  - 恭
+  - 莽
+  - 莱
+  - 莲
+  - 莫
+  - 莉
+  - 荷
+  - 获
+  - 晋
+  - 恶
+  - 莹
+  - 莺
+  - 真
+  - 框
+  - 梆
+  - 桂
+  - 桔
+  - 栖
+  - 档
+  - 桐
+  - 株
+  - 桥
+  - 桦
+  - 栓
+  - 桃
+  - 格
+  - 桩
+  - 校
+  - 核
+  - 样
+  - 根
+  - 索
+  - 哥
+  - 速
+  - 逗
+  - 栗
+  - 贾
+  - 酌
+  - 配
+  - 翅
+  - 辱
+  - 唇
+  - 夏
+  - 砸
+  - 砰
+  - 砾
+  - 础
+  - 破
+  - 原
+  - 套
+  - 逐
+  - 烈
+  - 殊
+  - 殉
+  - 顾
+  - 轿
+  - 较
+  - 顿
+  - 毙
+  - 致
+  - 柴
+  - 桌
+  - 虑
+  - 监
+  - 紧
+  - 党
+  - 逞
+  - 晒
+  - 眠
+  - 晓
+  - 哮
+  - 唠
+  - 鸭
+  - 晃
+  - 哺
+  - 晌
+  - 剔
+  - 晕
+  - 蚌
+  - 畔
+  - 蚣
+  - 蚊
+  - 蚪
+  - 蚓
+  - 哨
+  - 哩
+  - 圃
+  - 哭
+  - 哦
+  - 恩
+  - 鸯
+  - 唤
+  - 唁
+  - 哼
+  - 唧
+  - 啊
+  - 唉
+  - 唆
+  - 罢
+  - 峭
+  - 峨
+  - 峰
+  - 圆
+  - 峻
+  - 贼
+  - 贿
+  - 赂
+  - 赃
+  - 钱
+  - 钳
+  - 钻
+  - 钾
+  - 铁
+  - 铃
+  - 铅
+  - 缺
+  - 氧
+  - 氨
+  - 特
+  - 牺
+  - 造
+  - 乘
+  - 敌
+  - 秤
+  - 租
+  - 积
+  - 秧
+  - 秩
+  - 称
+  - 秘
+  - 透
+  - 笔
+  - 笑
+  - 笋
+  - 债
+  - 借
+  - 值
+  - 倚
+  - 俺
+  - 倾
+  - 倒
+  - 倘
+  - 俱
+  - 倡
+  - 候
+  - 赁
+  - 俯
+  - 倍
+  - 倦
+  - 健
+  - 臭
+  - 射
+  - 躬
+  - 息
+  - 倔
+  - 徒
+  - 徐
+  - 殷
+  - 舰
+  - 舱
+  - 般
+  - 航
+  - 途
+  - 拿
+  - 耸
+  - 爹
+  - 舀
+  - 爱
+  - 豺
+  - 豹
+  - 颁
+  - 颂
+  - 翁
+  - 胰
+  - 脆
+  - 脂
+  - 胸
+  - 胳
+  - 脏
+  - 脐
+  - 胶
+  - 脑
+  - 脓
+  - 逛
+  - 狸
+  - 狼
+  - 卿
+  - 逢
+  - 鸵
+  - 留
+  - 鸳
+  - 皱
+  - 饿
+  - 馁
+  - 凌
+  - 凄
+  - 恋
+  - 桨
+  - 浆
+  - 衰
+  - 衷
+  - 高
+  - 郭
+  - 席
+  - 准
+  - 座
+  - 症
+  - 病
+  - 疾
+  - 斋
+  - 疹
+  - 疼
+  - 疲
+  - 脊
+  - 效
+  - 离
+  - 紊
+  - 唐
+  - 瓷
+  - 资
+  - 凉
+  - 站
+  - 剖
+  - 竞
+  - 部
+  - 旁
+  - 旅
+  - 畜
+  - 阅
+  - 羞
+  - 羔
+  - 瓶
+  - 拳
+  - 粉
+  - 料
+  - 益
+  - 兼
+  - 烤
+  - 烘
+  - 烦
+  - 烧
+  - 烛
+  - 烟
+  - 烙
+  - 递
+  - 涛
+  - 浙
+  - 涝
+  - 浦
+  - 酒
+  - 涉
+  - 消
+  - 涡
+  - 浩
+  - 海
+  - 涂
+  - 浴
+  - 浮
+  - 涣
+  - 涤
+  - 流
+  - 润
+  - 涧
+  - 涕
+  - 浪
+  - 浸
+  - 涨
+  - 烫
+  - 涩
+  - 涌
+  - 悖
+  - 悟
+  - 悄
+  - 悍
+  - 悔
+  - 悯
+  - 悦
+  - 害
+  - 宽
+  - 家
+  - 宵
+  - 宴
+  - 宾
+  - 窍
+  - 窄
+  - 容
+  - 宰
+  - 案
+  - 请
+  - 朗
+  - 诸
+  - 诺
+  - 读
+  - 扇
+  - 诽
+  - 袜
+  - 袖
+  - 袍
+  - 被
+  - 祥
+  - 课
+  - 冥
+  - 谁
+  - 调
+  - 冤
+  - 谅
+  - 谆
+  - 谈
+  - 谊
+  - 剥
+  - 恳
+  - 展
+  - 剧
+  - 屑
+  - 弱
+  - 陵
+  - 祟
+  - 陶
+  - 陷
+  - 陪
+  - 娱
+  - 娟
+  - 恕
+  - 娥
+  - 娘
+  - 通
+  - 能
+  - 难
+  - 预
+  - 桑
+  - 绢
+  - 绣
+  - 验
+  - 继
+  - 骏
+  - 球
+  - 琐
+  - 理
+  - 琉
+  - 琅
+  - 捧
+  - 堵
+  - 措
+  - 描
+  - 域
+  - 捺
+  - 掩
+  - 捷
+  - 排
+  - 焉
+  - 掉
+  - 捶
+  - 赦
+  - 堆
+  - 推
+  - 埠
+  - 掀
+  - 授
+  - 捻
+  - 教
+  - 掏
+  - 掐
+  - 掠
+  - 掂
+  - 培
+  - 接
+  - 掷
+  - 控
+  - 探
+  - 据
+  - 掘
+  - 掺
+  - 职
+  - 基
+  - 聆
+  - 勘
+  - 聊
+  - 娶
+  - 著
+  - 菱
+  - 勒
+  - 黄
+  - 菲
+  - 萌
+  - 萝
+  - 菌
+  - 萎
+  - 菜
+  - 萄
+  - 菊
+  - 菩
+  - 萍
+  - 菠
+  - 萤
+  - 营
+  - 乾
+  - 萧
+  - 萨
+  - 菇
+  - 械
+  - 彬
+  - 梦
+  - 婪
+  - 梗
+  - 梧
+  - 梢
+  - 梅
+  - 检
+  - 梳
+  - 梯
+  - 桶
+  - 梭
+  - 救
+  - 曹
+  - 副
+  - 票
+  - 酝
+  - 酗
+  - 厢
+  - 戚
+  - 硅
+  - 硕
+  - 奢
+  - 盔
+  - 爽
+  - 聋
+  - 袭
+  - 盛
+  - 匾
+  - 雪
+  - 辅
+  - 辆
+  - 颅
+  - 虚
+  - 彪
+  - 雀
+  - 堂
+  - 常
+  - 眶
+  - 匙
+  - 晨
+  - 睁
+  - 眯
+  - 眼
+  - 悬
+  - 野
+  - 啪
+  - 啦
+  - 曼
+  - 晦
+  - 晚
+  - 啄
+  - 啡
+  - 距
+  - 趾
+  - 啃
+  - 跃
+  - 略
+  - 蚯
+  - 蛀
+  - 蛇
+  - 唬
+  - 累
+  - 鄂
+  - 唱
+  - 患
+  - 啰
+  - 唾
+  - 唯
+  - 啤
+  - 啥
+  - 啸
+  - 崖
+  - 崎
+  - 崭
+  - 逻
+  - 崔
+  - 帷
+  - 崩
+  - 崇
+  - 崛
+  - 婴
+  - 圈
+  - 铐
+  - 铛
+  - 铝
+  - 铜
+  - 铭
+  - 铲
+  - 银
+  - 矫
+  - 甜
+  - 秸
+  - 梨
+  - 犁
+  - 秽
+  - 移
+  - 笨
+  - 笼
+  - 笛
+  - 笙
+  - 符
+  - 第
+  - 敏
+  - 做
+  - 袋
+  - 悠
+  - 偿
+  - 偶
+  - 偎
+  - 偷
+  - 您
+  - 售
+  - 停
+  - 偏
+  - 躯
+  - 兜
+  - 假
+  - 衅
+  - 徘
+  - 徙
+  - 得
+  - 衔
+  - 盘
+  - 舶
+  - 船
+  - 舵
+  - 斜
+  - 盒
+  - 鸽
+  - 敛
+  - 悉
+  - 欲
+  - 彩
+  - 领
+  - 脚
+  - 脖
+  - 脯
+  - 豚
+  - 脸
+  - 脱
+  - 象
+  - 够
+  - 逸
+  - 猜
+  - 猪
+  - 猎
+  - 猫
+  - 凰
+  - 猖
+  - 猛
+  - 祭
+  - 馅
+  - 馆
+  - 凑
+  - 减
+  - 毫
+  - 烹
+  - 庶
+  - 麻
+  - 庵
+  - 痊
+  - 痒
+  - 痕
+  - 廊
+  - 康
+  - 庸
+  - 鹿
+  - 盗
+  - 章
+  - 竟
+  - 商
+  - 族
+  - 旋
+  - 望
+  - 率
+  - 阎
+  - 阐
+  - 着
+  - 羚
+  - 盖
+  - 眷
+  - 粘
+  - 粗
+  - 粒
+  - 断
+  - 剪
+  - 兽
+  - 焊
+  - 焕
+  - 清
+  - 添
+  - 鸿
+  - 淋
+  - 涯
+  - 淹
+  - 渠
+  - 渐
+  - 淑
+  - 淌
+  - 混
+  - 淮
+  - 淆
+  - 渊
+  - 淫
+  - 渔
+  - 淘
+  - 淳
+  - 液
+  - 淤
+  - 淡
+  - 淀
+  - 深
+  - 涮
+  - 涵
+  - 婆
+  - 梁
+  - 渗
+  - 情
+  - 惜
+  - 惭
+  - 悼
+  - 惧
+  - 惕
+  - 惟
+  - 惊
+  - 惦
+  - 悴
+  - 惋
+  - 惨
+  - 惯
+  - 寇
+  - 寅
+  - 寄
+  - 寂
+  - 宿
+  - 窒
+  - 窑
+  - 密
+  - 谋
+  - 谍
+  - 谎
+  - 谐
+  - 袱
+  - 祷
+  - 祸
+  - 谓
+  - 谚
+  - 谜
+  - 逮
+  - 敢
+  - 尉
+  - 屠
+  - 弹
+  - 隋
+  - 堕
+  - 随
+  - 蛋
+  - 隅
+  - 隆
+  - 隐
+  - 婚
+  - 婶
+  - 婉
+  - 颇
+  - 颈
+  - 绩
+  - 绪
+  - 续
+  - 骑
+  - 绰
+  - 绳
+  - 维
+  - 绵
+  - 绷
+  - 绸
+  - 综
+  - 绽
+  - 绿
+  - 缀
+  - 巢
+  - 琴
+  - 琳
+  - 琢
+  - 琼
+  - 斑
+  - 替
+  - 揍
+  - 款
+  - 堪
+  - 塔
+  - 搭
+  - 堰
+  - 揩
+  - 越
+  - 趁
+  - 趋
+  - 超
+  - 揽
+  - 堤
+  - 提
+  - 博
+  - 揭
+  - 喜
+  - 彭
+  - 揣
+  - 插
+  - 揪
+  - 搜
+  - 煮
+  - 援
+  - 搀
+  - 裁
+  - 搁
+  - 搓
+  - 搂
+  - 搅
+  - 壹
+  - 握
+  - 搔
+  - 揉
+  - 斯
+  - 期
+  - 欺
+  - 联
+  - 葫
+  - 散
+  - 惹
+  - 葬
+  - 募
+  - 葛
+  - 董
+  - 葡
+  - 敬
+  - 葱
+  - 蒋
+  - 蒂
+  - 落
+  - 韩
+  - 朝
+  - 辜
+  - 葵
+  - 棒
+  - 棱
+  - 棋
+  - 椰
+  - 植
+  - 森
+  - 焚
+  - 椅
+  - 椒
+  - 棵
+  - 棍
+  - 椎
+  - 棉
+  - 棚
+  - 棕
+  - 棺
+  - 榔
+  - 椭
+  - 惠
+  - 惑
+  - 逼
+  - 粟
+  - 棘
+  - 酣
+  - 酥
+  - 厨
+  - 厦
+  - 硬
+  - 硝
+  - 确
+  - 硫
+  - 雁
+  - 殖
+  - 裂
+  - 雄
+  - 颊
+  - 雳
+  - 暂
+  - 雅
+  - 翘
+  - 辈
+  - 悲
+  - 紫
+  - 凿
+  - 辉
+  - 敞
+  - 棠
+  - 赏
+  - 掌
+  - 晴
+  - 睐
+  - 暑
+  - 最
+  - 晰
+  - 量
+  - 鼎
+  - 喷
+  - 喳
+  - 晶
+  - 喇
+  - 遇
+  - 喊
+  - 遏
+  - 晾
+  - 景
+  - 畴
+  - 践
+  - 跋
+  - 跌
+  - 跑
+  - 跛
+  - 遗
+  - 蛙
+  - 蛛
+  - 蜓
+  - 蜒
+  - 蛤
+  - 喝
+  - 鹃
+  - 喂
+  - 喘
+  - 喉
+  - 喻
+  - 啼
+  - 喧
+  - 嵌
+  - 幅
+  - 帽
+  - 赋
+  - 赌
+  - 赎
+  - 赐
+  - 赔
+  - 黑
+  - 铸
+  - 铺
+  - 链
+  - 销
+  - 锁
+  - 锄
+  - 锅
+  - 锈
+  - 锋
+  - 锌
+  - 锐
+  - 甥
+  - 掰
+  - 短
+  - 智
+  - 氮
+  - 毯
+  - 氯
+  - 鹅
+  - 剩
+  - 稍
+  - 程
+  - 稀
+  - 税
+  - 筐
+  - 等
+  - 筑
+  - 策
+  - 筛
+  - 筒
+  - 筏
+  - 答
+  - 筋
+  - 筝
+  - 傲
+  - 傅
+  - 牌
+  - 堡
+  - 集
+  - 焦
+  - 傍
+  - 储
+  - 皓
+  - 皖
+  - 粤
+  - 奥
+  - 街
+  - 惩
+  - 御
+  - 循
+  - 艇
+  - 舒
+  - 逾
+  - 番
+  - 释
+  - 禽
+  - 腊
+  - 脾
+  - 腋
+  - 腔
+  - 腕
+  - 鲁
+  - 猩
+  - 猬
+  - 猾
+  - 猴
+  - 惫
+  - 然
+  - 馈
+  - 馋
+  - 装
+  - 蛮
+  - 就
+  - 敦
+  - 斌
+  - 痘
+  - 痢
+  - 痪
+  - 痛
+  - 童
+  - 竣
+  - 阔
+  - 善
+  - 翔
+  - 羡
+  - 普
+  - 粪
+  - 尊
+  - 奠
+  - 道
+  - 遂
+  - 曾
+  - 焰
+  - 港
+  - 滞
+  - 湖
+  - 湘
+  - 渣
+  - 渤
+  - 渺
+  - 湿
+  - 温
+  - 渴
+  - 溃
+  - 溅
+  - 滑
+  - 湃
+  - 渝
+  - 湾
+  - 渡
+  - 游
+  - 滋
+  - 渲
+  - 溉
+  - 愤
+  - 慌
+  - 惰
+  - 愕
+  - 愣
+  - 惶
+  - 愧
+  - 愉
+  - 慨
+  - 割
+  - 寒
+  - 富
+  - 寓
+  - 窜
+  - 窝
+  - 窖
+  - 窗
+  - 窘
+  - 遍
+  - 雇
+  - 裕
+  - 裤
+  - 裙
+  - 禅
+  - 禄
+  - 谢
+  - 谣
+  - 谤
+  - 谦
+  - 犀
+  - 属
+  - 屡
+  - 强
+  - 粥
+  - 疏
+  - 隔
+  - 隙
+  - 隘
+  - 媒
+  - 絮
+  - 嫂
+  - 媚
+  - 婿
+  - 登
+  - 缅
+  - 缆
+  - 缉
+  - 缎
+  - 缓
+  - 缔
+  - 缕
+  - 骗
+  - 编
+  - 骚
+  - 缘
+  - 瑟
+  - 鹉
+  - 瑞
+  - 瑰
+  - 瑙
+  - 魂
+  - 肆
+  - 摄
+  - 摸
+  - 填
+  - 搏
+  - 塌
+  - 鼓
+  - 摆
+  - 携
+  - 搬
+  - 摇
+  - 搞
+  - 塘
+  - 摊
+  - 聘
+  - 斟
+  - 蒜
+  - 勤
+  - 靴
+  - 靶
+  - 鹊
+  - 蓝
+  - 墓
+  - 幕
+  - 蓬
+  - 蓄
+  - 蒲
+  - 蓉
+  - 蒙
+  - 蒸
+  - 献
+  - 椿
+  - 禁
+  - 楚
+  - 楷
+  - 榄
+  - 想
+  - 槐
+  - 榆
+  - 楼
+  - 概
+  - 赖
+  - 酪
+  - 酬
+  - 感
+  - 碍
+  - 碘
+  - 碑
+  - 碎
+  - 碰
+  - 碗
+  - 碌
+  - 尴
+  - 雷
+  - 零
+  - 雾
+  - 雹
+  - 辐
+  - 辑
+  - 输
+  - 督
+  - 频
+  - 龄
+  - 鉴
+  - 睛
+  - 睹
+  - 睦
+  - 瞄
+  - 睫
+  - 睡
+  - 睬
+  - 嗜
+  - 鄙
+  - 嗦
+  - 愚
+  - 暖
+  - 盟
+  - 歇
+  - 暗
+  - 暇
+  - 照
+  - 畸
+  - 跨
+  - 跷
+  - 跳
+  - 跺
+  - 跪
+  - 路
+  - 跤
+  - 跟
+  - 遣
+  - 蜈
+  - 蜗
+  - 蛾
+  - 蜂
+  - 蜕
+  - 嗅
+  - 嗡
+  - 嗓
+  - 署
+  - 置
+  - 罪
+  - 罩
+  - 蜀
+  - 幌
+  - 错
+  - 锚
+  - 锡
+  - 锣
+  - 锤
+  - 锥
+  - 锦
+  - 键
+  - 锯
+  - 锰
+  - 矮
+  - 辞
+  - 稚
+  - 稠
+  - 颓
+  - 愁
+  - 筹
+  - 签
+  - 简
+  - 筷
+  - 毁
+  - 舅
+  - 鼠
+  - 催
+  - 傻
+  - 像
+  - 躲
+  - 魁
+  - 衙
+  - 微
+  - 愈
+  - 遥
+  - 腻
+  - 腰
+  - 腥
+  - 腮
+  - 腹
+  - 腺
+  - 鹏
+  - 腾
+  - 腿
+  - 鲍
+  - 猿
+  - 颖
+  - 触
+  - 解
+  - 煞
+  - 雏
+  - 馍
+  - 馏
+  - 酱
+  - 禀
+  - 痹
+  - 廓
+  - 痴
+  - 痰
+  - 廉
+  - 靖
+  - 新
+  - 韵
+  - 意
+  - 誊
+  - 粮
+  - 数
+  - 煎
+  - 塑
+  - 慈
+  - 煤
+  - 煌
+  - 满
+  - 漠
+  - 滇
+  - 源
+  - 滤
+  - 滥
+  - 滔
+  - 溪
+  - 溜
+  - 漓
+  - 滚
+  - 溢
+  - 溯
+  - 滨
+  - 溶
+  - 溺
+  - 粱
+  - 滩
+  - 慎
+  - 誉
+  - 塞
+  - 寞
+  - 窥
+  - 窟
+  - 寝
+  - 谨
+  - 褂
+  - 裸
+  - 福
+  - 谬
+  - 群
+  - 殿
+  - 辟
+  - 障
+  - 媳
+  - 嫉
+  - 嫌
+  - 嫁
+  - 叠
+  - 缚
+  - 缝
+  - 缠
+  - 缤
+  - 剿
+  - 静
+  - 碧
+  - 璃
+  - 赘
+  - 熬
+  - 墙
+  - 墟
+  - 嘉
+  - 摧
+  - 赫
+  - 截
+  - 誓
+  - 境
+  - 摘
+  - 摔
+  - 撇
+  - 聚
+  - 慕
+  - 暮
+  - 摹
+  - 蔓
+  - 蔑
+  - 蔡
+  - 蔗
+  - 蔽
+  - 蔼
+  - 熙
+  - 蔚
+  - 兢
+  - 模
+  - 槛
+  - 榴
+  - 榜
+  - 榨
+  - 榕
+  - 歌
+  - 遭
+  - 酵
+  - 酷
+  - 酿
+  - 酸
+  - 碟
+  - 碱
+  - 碳
+  - 磁
+  - 愿
+  - 需
+  - 辖
+  - 辗
+  - 雌
+  - 裳
+  - 颗
+  - 瞅
+  - 墅
+  - 嗽
+  - 踊
+  - 蜻
+  - 蜡
+  - 蝇
+  - 蜘
+  - 蝉
+  - 嘛
+  - 嘀
+  - 赚
+  - 锹
+  - 锻
+  - 镀
+  - 舞
+  - 舔
+  - 稳
+  - 熏
+  - 箕
+  - 算
+  - 箩
+  - 管
+  - 箫
+  - 舆
+  - 僚
+  - 僧
+  - 鼻
+  - 魄
+  - 魅
+  - 貌
+  - 膜
+  - 膊
+  - 膀
+  - 鲜
+  - 疑
+  - 孵
+  - 馒
+  - 裹
+  - 敲
+  - 豪
+  - 膏
+  - 遮
+  - 腐
+  - 瘩
+  - 瘟
+  - 瘦
+  - 辣
+  - 彰
+  - 竭
+  - 端
+  - 旗
+  - 精
+  - 粹
+  - 歉
+  - 弊
+  - 熄
+  - 熔
+  - 煽
+  - 潇
+  - 漆
+  - 漱
+  - 漂
+  - 漫
+  - 滴
+  - 漾
+  - 演
+  - 漏
+  - 慢
+  - 慷
+  - 寨
+  - 赛
+  - 寡
+  - 察
+  - 蜜
+  - 寥
+  - 谭
+  - 肇
+  - 褐
+  - 褪
+  - 谱
+  - 隧
+  - 嫩
+  - 翠
+  - 熊
+  - 凳
+  - 骡
+  - 缩
+  - 慧
+  - 撵
+  - 撕
+  - 撒
+  - 撩
+  - 趣
+  - 趟
+  - 撑
+  - 撮
+  - 撬
+  - 播
+  - 擒
+  - 墩
+  - 撞
+  - 撤
+  - 增
+  - 撰
+  - 聪
+  - 鞋
+  - 鞍
+  - 蕉
+  - 蕊
+  - 蔬
+  - 蕴
+  - 横
+  - 槽
+  - 樱
+  - 橡
+  - 樟
+  - 橄
+  - 敷
+  - 豌
+  - 飘
+  - 醋
+  - 醇
+  - 醉
+  - 磕
+  - 磊
+  - 磅
+  - 碾
+  - 震
+  - 霄
+  - 霉
+  - 瞒
+  - 题
+  - 暴
+  - 瞎
+  - 嘻
+  - 嘶
+  - 嘲
+  - 嘹
+  - 影
+  - 踢
+  - 踏
+  - 踩
+  - 踪
+  - 蝶
+  - 蝴
+  - 蝠
+  - 蝎
+  - 蝌
+  - 蝗
+  - 蝙
+  - 嘿
+  - 嘱
+  - 幢
+  - 墨
+  - 镇
+  - 镐
+  - 镑
+  - 靠
+  - 稽
+  - 稻
+  - 黎
+  - 稿
+  - 稼
+  - 箱
+  - 篓
+  - 箭
+  - 篇
+  - 僵
+  - 躺
+  - 僻
+  - 德
+  - 艘
+  - 膝
+  - 膛
+  - 鲤
+  - 鲫
+  - 熟
+  - 摩
+  - 褒
+  - 瘪
+  - 瘤
+  - 瘫
+  - 凛
+  - 颜
+  - 毅
+  - 糊
+  - 遵
+  - 憋
+  - 潜
+  - 澎
+  - 潮
+  - 潭
+  - 鲨
+  - 澳
+  - 潘
+  - 澈
+  - 澜
+  - 澄
+  - 懂
+  - 憔
+  - 懊
+  - 憎
+  - 额
+  - 翩
+  - 褥
+  - 谴
+  - 鹤
+  - 憨
+  - 慰
+  - 劈
+  - 履
+  - 豫
+  - 缭
+  - 撼
+  - 擂
+  - 操
+  - 擅
+  - 燕
+  - 蕾
+  - 薯
+  - 薛
+  - 薇
+  - 擎
+  - 薪
+  - 薄
+  - 颠
+  - 翰
+  - 噩
+  - 橱
+  - 橙
+  - 橘
+  - 整
+  - 融
+  - 瓢
+  - 醒
+  - 霍
+  - 霎
+  - 辙
+  - 冀
+  - 餐
+  - 嘴
+  - 踱
+  - 蹄
+  - 蹂
+  - 蟆
+  - 螃
+  - 器
+  - 噪
+  - 鹦
+  - 赠
+  - 默
+  - 黔
+  - 镜
+  - 赞
+  - 穆
+  - 篮
+  - 篡
+  - 篷
+  - 篱
+  - 儒
+  - 邀
+  - 衡
+  - 膨
+  - 雕
+  - 鲸
+  - 磨
+  - 瘾
+  - 瘸
+  - 凝
+  - 辨
+  - 辩
+  - 糙
+  - 糖
+  - 糕
+  - 燃
+  - 濒
+  - 澡
+  - 激
+  - 懒
+  - 憾
+  - 懈
+  - 窿
+  - 壁
+  - 避
+  - 缰
+  - 缴
+  - 戴
+  - 擦
+  - 藉
+  - 鞠
+  - 藏
+  - 藐
+  - 檬
+  - 檐
+  - 檀
+  - 礁
+  - 磷
+  - 霜
+  - 霞
+  - 瞭
+  - 瞧
+  - 瞬
+  - 瞳
+  - 瞩
+  - 瞪
+  - 曙
+  - 蹋
+  - 蹈
+  - 螺
+  - 蟋
+  - 蟀
+  - 嚎
+  - 赡
+  - 穗
+  - 魏
+  - 簧
+  - 簇
+  - 繁
+  - 徽
+  - 爵
+  - 朦
+  - 臊
+  - 鳄
+  - 癌
+  - 辫
+  - 赢
+  - 糟
+  - 糠
+  - 燥
+  - 懦
+  - 豁
+  - 臀
+  - 臂
+  - 翼
+  - 骤
+  - 藕
+  - 鞭
+  - 藤
+  - 覆
+  - 瞻
+  - 蹦
+  - 嚣
+  - 镰
+  - 翻
+  - 鳍
+  - 鹰
+  - 瀑
+  - 襟
+  - 璧
+  - 戳
+  - 孽
+  - 警
+  - 蘑
+  - 藻
+  - 攀
+  - 曝
+  - 蹲
+  - 蹭
+  - 蹬
+  - 巅
+  - 簸
+  - 簿
+  - 蟹
+  - 颤
+  - 靡
+  - 癣
+  - 瓣
+  - 羹
+  - 鳖
+  - 爆
+  - 疆
+  - 鬓
+  - 壤
+  - 馨
+  - 耀
+  - 躁
+  - 蠕
+  - 嚼
+  - 嚷
+  - 巍
+  - 籍
+  - 鳞
+  - 魔
+  - 糯
+  - 灌
+  - 譬
+  - 蠢
+  - 霸
+  - 露
+  - 霹
+  - 躏
+  - 黯
+  - 髓
+  - 赣
+  - 囊
+  - 镶
+  - 瓤
+  - 罐
+  - 矗
+  - 乂
+  - 乜
+  - 兀
+  - 弋
+  - 孑
+  - 孓
+  - 幺
+  - 亓
+  - 韦
+  - 廿
+  - 丏
+  - 卅
+  - 仄
+  - 厄
+  - 仃
+  - 仉
+  - 仂
+  - 兮
+  - 刈
+  - 爻
+  - 卞
+  - 闩
+  - 讣
+  - 尹
+  - 夬
+  - 爿
+  - 毋
+  - 邗
+  - 邛
+  - 艽
+  - 艿
+  - 札
+  - 叵
+  - 匝
+  - 丕
+  - 匜
+  - 劢
+  - 卟
+  - 叱
+  - 叻
+  - 仨
+  - 仕
+  - 仟
+  - 仡
+  - 仫
+  - 仞
+  - 卮
+  - 氐
+  - 犰
+  - 刍
+  - 邝
+  - 邙
+  - 汀
+  - 讦
+  - 讧
+  - 讪
+  - 讫
+  - 尻
+  - 阡
+  - 尕
+  - 弁
+  - 驭
+  - 匡
+  - 耒
+  - 玎
+  - 玑
+  - 邢
+  - 圩
+  - 圬
+  - 圭
+  - 扦
+  - 圪
+  - 圳
+  - 圹
+  - 扪
+  - 圮
+  - 圯
+  - 芊
+  - 芍
+  - 芄
+  - 芨
+  - 芑
+  - 芎
+  - 芗
+  - 亘
+  - 厍
+  - 夼
+  - 戍
+  - 尥
+  - 乩
+  - 旯
+  - 曳
+  - 岌
+  - 屺
+  - 凼
+  - 囡
+  - 钇
+  - 缶
+  - 氘
+  - 氖
+  - 牝
+  - 伎
+  - 伛
+  - 伢
+  - 佤
+  - 仵
+  - 伥
+  - 伧
+  - 伉
+  - 伫
+  - 囟
+  - 汆
+  - 刖
+  - 夙
+  - 旮
+  - 刎
+  - 犷
+  - 犸
+  - 舛
+  - 凫
+  - 邬
+  - 饧
+  - 汕
+  - 汔
+  - 汐
+  - 汲
+  - 汜
+  - 汊
+  - 忖
+  - 忏
+  - 讴
+  - 讵
+  - 祁
+  - 讷
+  - 聿
+  - 艮
+  - 厾
+  - 阱
+  - 阮
+  - 阪
+  - 丞
+  - 妁
+  - 牟
+  - 纡
+  - 纣
+  - 纥
+  - 纨
+  - 玕
+  - 玙
+  - 抟
+  - 抔
+  - 圻
+  - 坂
+  - 坍
+  - 坞
+  - 抃
+  - 抉
+  - 㧐
+  - 芫
+  - 邯
+  - 芸
+  - 芾
+  - 苈
+  - 苣
+  - 芷
+  - 芮
+  - 苋
+  - 芼
+  - 苌
+  - 苁
+  - 芩
+  - 芪
+  - 芡
+  - 芟
+  - 苄
+  - 苎
+  - 苡
+  - 杌
+  - 杓
+  - 杞
+  - 杈
+  - 忑
+  - 孛
+  - 邴
+  - 邳
+  - 矶
+  - 奁
+  - 豕
+  - 忒
+  - 欤
+  - 轫
+  - 迓
+  - 邶
+  - 忐
+  - 卣
+  - 邺
+  - 旰
+  - 呋
+  - 呒
+  - 呓
+  - 呔
+  - 呖
+  - 呃
+  - 旸
+  - 吡
+  - 町
+  - 虬
+  - 呗
+  - 吽
+  - 吣
+  - 吲
+  - 帏
+  - 岐
+  - 岈
+  - 岘
+  - 岑
+  - 岚
+  - 兕
+  - 囵
+  - 囫
+  - 钊
+  - 钋
+  - 钌
+  - 迕
+  - 氙
+  - 氚
+  - 牤
+  - 佞
+  - 邱
+  - 攸
+  - 佚
+  - 佝
+  - 佟
+  - 佗
+  - 伽
+  - 彷
+  - 佘
+  - 佥
+  - 孚
+  - 豸
+  - 坌
+  - 肟
+  - 邸
+  - 奂
+  - 劬
+  - 狄
+  - 狁
+  - 鸠
+  - 邹
+  - 饨
+  - 饩
+  - 饪
+  - 饫
+  - 饬
+  - 亨
+  - 庑
+  - 庋
+  - 疔
+  - 疖
+  - 肓
+  - 闱
+  - 闳
+  - 闵
+  - 羌
+  - 炀
+  - 沣
+  - 沅
+  - 沔
+  - 沤
+  - 沌
+  - 沏
+  - 沚
+  - 汩
+  - 汨
+  - 沂
+  - 汾
+  - 沨
+  - 汴
+  - 汶
+  - 沆
+  - 沩
+  - 泐
+  - 怃
+  - 怄
+  - 忡
+  - 忤
+  - 忾
+  - 怅
+  - 忻
+  - 忪
+  - 怆
+  - 忭
+  - 忸
+  - 诂
+  - 诃
+  - 诅
+  - 诋
+  - 诌
+  - 诏
+  - 诒
+  - 孜
+  - 陇
+  - 陀
+  - 陂
+  - 陉
+  - 妍
+  - 妩
+  - 妪
+  - 妣
+  - 妊
+  - 妗
+  - 妫
+  - 妞
+  - 姒
+  - 妤
+  - 邵
+  - 劭
+  - 刭
+  - 甬
+  - 邰
+  - 纭
+  - 纰
+  - 纴
+  - 纶
+  - 纾
+  - 玮
+  - 玡
+  - 玭
+  - 玠
+  - 玢
+  - 玥
+  - 玦
+  - 盂
+  - 忝
+  - 匦
+  - 坩
+  - 抨
+  - 拤
+  - 坫
+  - 拈
+  - 垆
+  - 抻
+  - 劼
+  - 拃
+  - 拊
+  - 坼
+  - 坻
+  - 㧟
+  - 坨
+  - 坭
+  - 抿
+  - 坳
+  - 耶
+  - 苷
+  - 苯
+  - 苤
+  - 茏
+  - 苫
+  - 苜
+  - 苴
+  - 苒
+  - 苘
+  - 茌
+  - 苻
+  - 苓
+  - 茚
+  - 茆
+  - 茑
+  - 茓
+  - 茔
+  - 茕
+  - 茀
+  - 苕
+  - 枥
+  - 枇
+  - 杪
+  - 杳
+  - 枧
+  - 杵
+  - 枨
+  - 枞
+  - 枋
+  - 杻
+  - 杷
+  - 杼
+  - 矸
+  - 砀
+  - 刳
+  - 奄
+  - 瓯
+  - 殁
+  - 郏
+  - 轭
+  - 郅
+  - 鸢
+  - 盱
+  - 昊
+  - 昙
+  - 杲
+  - 昃
+  - 咂
+  - 呸
+  - 昕
+  - 昀
+  - 旻
+  - 昉
+  - 炅
+  - 咔
+  - 畀
+  - 虮
+  - 咀
+  - 呷
+  - 黾
+  - 呱
+  - 呤
+  - 咚
+  - 咆
+  - 咛
+  - 呶
+  - 呣
+  - 呦
+  - 咝
+  - 岢
+  - 岿
+  - 岬
+  - 岫
+  - 帙
+  - 岣
+  - 峁
+  - 刿
+  - 迥
+  - 岷
+  - 剀
+  - 帔
+  - 峄
+  - 沓
+  - 囹
+  - 罔
+  - 钍
+  - 钎
+  - 钏
+  - 钒
+  - 钕
+  - 钗
+  - 邾
+  - 迮
+  - 牦
+  - 竺
+  - 迤
+  - 佶
+  - 佬
+  - 佰
+  - 侑
+  - 侉
+  - 臾
+  - 岱
+  - 侗
+  - 侃
+  - 侏
+  - 侩
+  - 佻
+  - 佾
+  - 侪
+  - 佼
+  - 佯
+  - 侬
+  - 帛
+  - 阜
+  - 侔
+  - 徂
+  - 刽
+  - 郄
+  - 怂
+  - 籴
+  - 瓮
+  - 戗
+  - 肼
+  - 䏝
+  - 肽
+  - 肱
+  - 肫
+  - 剁
+  - 迩
+  - 郇
+  - 狙
+  - 狎
+  - 狍
+  - 狒
+  - 咎
+  - 炙
+  - 枭
+  - 饯
+  - 饴
+  - 冽
+  - 冼
+  - 庖
+  - 疠
+  - 疝
+  - 疡
+  - 兖
+  - 妾
+  - 劾
+  - 炜
+  - 𬉼
+  - 炖
+  - 炘
+  - 炝
+  - 炔
+  - 泔
+  - 沭
+  - 泷
+  - 泸
+  - 泱
+  - 泅
+  - 泗
+  - 泠
+  - 泺
+  - 泖
+  - 泫
+  - 泮
+  - 沱
+  - 泯
+  - 泓
+  - 泾
+  - 怙
+  - 怵
+  - 怦
+  - 怛
+  - 怏
+  - 怍
+  - 㤘
+  - 怩
+  - 怫
+  - 怿
+  - 宕
+  - 穹
+  - 宓
+  - 诓
+  - 诔
+  - 诖
+  - 诘
+  - 戾
+  - 诙
+  - 戽
+  - 郓
+  - 衩
+  - 祆
+  - 祎
+  - 祉
+  - 祇
+  - 诛
+  - 诜
+  - 诟
+  - 诠
+  - 诣
+  - 诤
+  - 诧
+  - 诨
+  - 诩
+  - 戕
+  - 孢
+  - 亟
+  - 陔
+  - 妲
+  - 妯
+  - 姗
+  - 帑
+  - 弩
+  - 孥
+  - 驽
+  - 虱
+  - 迦
+  - 迨
+  - 绀
+  - 绁
+  - 绂
+  - 驷
+  - 驸
+  - 绉
+  - 绌
+  - 驿
+  - 骀
+  - 甾
+  - 珏
+  - 珐
+  - 珂
+  - 珑
+  - 玳
+  - 珀
+  - 顸
+  - 珉
+  - 珈
+  - 拮
+  - 垭
+  - 挝
+  - 垣
+  - 挞
+  - 垤
+  - 赳
+  - 贲
+  - 垱
+  - 垌
+  - 郝
+  - 垧
+  - 垓
+  - 挦
+  - 垠
+  - 茜
+  - 荚
+  - 荑
+  - 贳
+  - 荜
+  - 莒
+  - 茼
+  - 茴
+  - 茱
+  - 莛
+  - 荞
+  - 茯
+  - 荏
+  - 荇
+  - 荃
+  - 荟
+  - 荀
+  - 茗
+  - 荠
+  - 茭
+  - 茨
+  - 垩
+  - 荥
+  - 荦
+  - 荨
+  - 荩
+  - 剋
+  - 荪
+  - 茹
+  - 荬
+  - 荮
+  - 柰
+  - 栉
+  - 柯
+  - 柘
+  - 栊
+  - 柩
+  - 枰
+  - 栌
+  - 柙
+  - 枵
+  - 柚
+  - 枳
+  - 柞
+  - 柝
+  - 栀
+  - 柢
+  - 栎
+  - 枸
+  - 柈
+  - 柁
+  - 枷
+  - 柽
+  - 剌
+  - 酊
+  - 郦
+  - 甭
+  - 砗
+  - 砘
+  - 砒
+  - 斫
+  - 砭
+  - 砜
+  - 奎
+  - 耷
+  - 虺
+  - 殂
+  - 殇
+  - 殄
+  - 殆
+  - 轱
+  - 轲
+  - 轳
+  - 轶
+  - 轸
+  - 虿
+  - 毖
+  - 觇
+  - 尜
+  - 哐
+  - 眄
+  - 眍
+  - 𠳐
+  - 郢
+  - 眇
+  - 眊
+  - 眈
+  - 禺
+  - 哂
+  - 咴
+  - 曷
+  - 昴
+  - 昱
+  - 昵
+  - 咦
+  - 哓
+  - 哔
+  - 畎
+  - 毗
+  - 呲
+  - 胄
+  - 畋
+  - 畈
+  - 虼
+  - 虻
+  - 盅
+  - 咣
+  - 哕
+  - 剐
+  - 郧
+  - 咻
+  - 囿
+  - 咿
+  - 哌
+  - 哙
+  - 哚
+  - 咯
+  - 咩
+  - 咤
+  - 哝
+  - 哏
+  - 哞
+  - 峙
+  - 峣
+  - 罘
+  - 帧
+  - 峒
+  - 峤
+  - 峋
+  - 峥
+  - 贶
+  - 钚
+  - 钛
+  - 钡
+  - 钣
+  - 钤
+  - 钨
+  - 钫
+  - 钯
+  - 氡
+  - 氟
+  - 牯
+  - 郜
+  - 秕
+  - 秭
+  - 竽
+  - 笈
+  - 笃
+  - 俦
+  - 俨
+  - 俅
+  - 俪
+  - 叟
+  - 垡
+  - 牮
+  - 俣
+  - 俚
+  - 皈
+  - 俑
+  - 俟
+  - 逅
+  - 徇
+  - 徉
+  - 舢
+  - 俞
+  - 郗
+  - 俎
+  - 郤
+  - 爰
+  - 郛
+  - 瓴
+  - 胨
+  - 胪
+  - 胛
+  - 胂
+  - 胙
+  - 胍
+  - 胗
+  - 胝
+  - 朐
+  - 胫
+  - 鸨
+  - 匍
+  - 狨
+  - 狯
+  - 飑
+  - 狩
+  - 狲
+  - 訇
+  - 逄
+  - 昝
+  - 饷
+  - 饸
+  - 饹
+  - 胤
+  - 孪
+  - 娈
+  - 弈
+  - 奕
+  - 庥
+  - 疬
+  - 疣
+  - 疥
+  - 疭
+  - 庠
+  - 竑
+  - 彦
+  - 飒
+  - 闼
+  - 闾
+  - 闿
+  - 阂
+  - 羑
+  - 迸
+  - 籼
+  - 酋
+  - 炳
+  - 炻
+  - 炽
+  - 炯
+  - 烀
+  - 炷
+  - 烃
+  - 洱
+  - 洹
+  - 洧
+  - 洌
+  - 浃
+  - 洇
+  - 洄
+  - 洙
+  - 涎
+  - 洎
+  - 洫
+  - 浍
+  - 洮
+  - 洵
+  - 浒
+  - 浔
+  - 浕
+  - 洳
+  - 恸
+  - 恓
+  - 恹
+  - 恫
+  - 恺
+  - 恻
+  - 恂
+  - 恪
+  - 恽
+  - 宥
+  - 扃
+  - 衲
+  - 衽
+  - 衿
+  - 袂
+  - 祛
+  - 祜
+  - 祓
+  - 祚
+  - 诮
+  - 祗
+  - 祢
+  - 诰
+  - 诳
+  - 鸩
+  - 昶
+  - 郡
+  - 咫
+  - 弭
+  - 牁
+  - 胥
+  - 陛
+  - 陟
+  - 娅
+  - 姮
+  - 娆
+  - 姝
+  - 姣
+  - 姘
+  - 姹
+  - 怼
+  - 羿
+  - 炱
+  - 矜
+  - 绔
+  - 骁
+  - 骅
+  - 绗
+  - 绛
+  - 骈
+  - 耖
+  - 挈
+  - 珥
+  - 珙
+  - 顼
+  - 珰
+  - 珩
+  - 珧
+  - 珣
+  - 珞
+  - 琤
+  - 珲
+  - 敖
+  - 恚
+  - 埔
+  - 埕
+  - 埘
+  - 埙
+  - 埚
+  - 挹
+  - 耆
+  - 耄
+  - 埒
+  - 捋
+  - 贽
+  - 垸
+  - 捃
+  - 盍
+  - 荸
+  - 莆
+  - 莳
+  - 莴
+  - 莪
+  - 莠
+  - 莓
+  - 莜
+  - 莅
+  - 荼
+  - 莩
+  - 荽
+  - 莸
+  - 荻
+  - 莘
+  - 莎
+  - 莞
+  - 莨
+  - 渇
+  - 鸪
+  - 莼
+  - 栲
+  - 栳
+  - 郴
+  - 桓
+  - 桡
+  - 桎
+  - 桢
+  - 桤
+  - 梃
+  - 栝
+  - 桕
+  - 桁
+  - 桧
+  - 桅
+  - 栟
+  - 桉
+  - 栩
+  - 逑
+  - 逋
+  - 彧
+  - 鬲
+  - 豇
+  - 酐
+  - 逦
+  - 厝
+  - 孬
+  - 砝
+  - 砹
+  - 砺
+  - 砧
+  - 砷
+  - 砟
+  - 砼
+  - 砥
+  - 砣
+  - 剞
+  - 砻
+  - 轼
+  - 轾
+  - 辂
+  - 鸫
+  - 趸
+  - 龀
+  - 鸬
+  - 虔
+  - 逍
+  - 眬
+  - 唛
+  - 晟
+  - 眩
+  - 眙
+  - 哧
+  - 哽
+  - 唔
+  - 晁
+  - 晏
+  - 鸮
+  - 趵
+  - 趿
+  - 畛
+  - 蚨
+  - 蚜
+  - 蚍
+  - 蚋
+  - 蚬
+  - 蚝
+  - 蚧
+  - 唢
+  - 圄
+  - 唣
+  - 唏
+  - 盎
+  - 唑
+  - 崂
+  - 崃
+  - 罡
+  - 罟
+  - 峪
+  - 觊
+  - 赅
+  - 钰
+  - 钲
+  - 钴
+  - 钵
+  - 钹
+  - 钺
+  - 钽
+  - 钼
+  - 钿
+  - 铀
+  - 铂
+  - 铄
+  - 铆
+  - 铈
+  - 铉
+  - 铊
+  - 铋
+  - 铌
+  - 铍
+  - 䥽
+  - 铎
+  - 氩
+  - 氤
+  - 氦
+  - 毪
+  - 舐
+  - 秣
+  - 秫
+  - 盉
+  - 笄
+  - 笕
+  - 笊
+  - 笏
+  - 笆
+  - 俸
+  - 倩
+  - 俵
+  - 偌
+  - 俳
+  - 俶
+  - 倬
+  - 倏
+  - 恁
+  - 倭
+  - 倪
+  - 俾
+  - 倜
+  - 隼
+  - 隽
+  - 倌
+  - 倥
+  - 臬
+  - 皋
+  - 郫
+  - 倨
+  - 衄
+  - 颀
+  - 徕
+  - 舫
+  - 釜
+  - 奚
+  - 衾
+  - 胯
+  - 胱
+  - 胴
+  - 胭
+  - 脍
+  - 胼
+  - 朕
+  - 脒
+  - 胺
+  - 鸱
+  - 玺
+  - 鸲
+  - 狷
+  - 猁
+  - 狳
+  - 猃
+  - 狺
+  - 逖
+  - 桀
+  - 袅
+  - 饽
+  - 凇
+  - 栾
+  - 挛
+  - 亳
+  - 疳
+  - 疴
+  - 疸
+  - 疽
+  - 痈
+  - 疱
+  - 痂
+  - 痉
+  - 衮
+  - 凋
+  - 颃
+  - 恣
+  - 旆
+  - 旄
+  - 旃
+  - 阃
+  - 阄
+  - 訚
+  - 阆
+  - 恙
+  - 粑
+  - 朔
+  - 郸
+  - 烜
+  - 烨
+  - 烩
+  - 烊
+  - 剡
+  - 郯
+  - 烬
+  - 涑
+  - 浯
+  - 涞
+  - 涟
+  - 娑
+  - 涅
+  - 涠
+  - 浞
+  - 涓
+  - 浥
+  - 涔
+  - 浜
+  - 浠
+  - 浣
+  - 浚
+  - 悚
+  - 悭
+  - 悝
+  - 悒
+  - 悌
+  - 悛
+  - 宸
+  - 窈
+  - 剜
+  - 诹
+  - 冢
+  - 诼
+  - 袒
+  - 袢
+  - 祯
+  - 诿
+  - 谀
+  - 谂
+  - 谄
+  - 谇
+  - 屐
+  - 屙
+  - 陬
+  - 勐
+  - 奘
+  - 牂
+  - 蚩
+  - 陲
+  - 姬
+  - 娠
+  - 娌
+  - 娉
+  - 娲
+  - 娩
+  - 娴
+  - 娣
+  - 娓
+  - 婀
+  - 畚
+  - 逡
+  - 绠
+  - 骊
+  - 绡
+  - 骋
+  - 绥
+  - 绦
+  - 绨
+  - 骎
+  - 邕
+  - 鸶
+  - 彗
+  - 耜
+  - 焘
+  - 舂
+  - 琏
+  - 琇
+  - 麸
+  - 揶
+  - 埴
+  - 埯
+  - 捯
+  - 掳
+  - 掴
+  - 埸
+  - 埵
+  - 赧
+  - 埤
+  - 捭
+  - 逵
+  - 埝
+  - 堋
+  - 堍
+  - 掬
+  - 鸷
+  - 掖
+  - 捽
+  - 掊
+  - 堉
+  - 掸
+  - 捩
+  - 掮
+  - 悫
+  - 埭
+  - 埽
+  - 掇
+  - 掼
+  - 聃
+  - 菁
+  - 萁
+  - 菘
+  - 堇
+  - 萘
+  - 萋
+  - 菽
+  - 菖
+  - 萜
+  - 萸
+  - 萑
+  - 棻
+  - 菔
+  - 菟
+  - 萏
+  - 萃
+  - 菏
+  - 菹
+  - 菪
+  - 菅
+  - 菀
+  - 萦
+  - 菰
+  - 菡
+  - 梵
+  - 梿
+  - 梏
+  - 觋
+  - 桴
+  - 桷
+  - 梓
+  - 棁
+  - 桫
+  - 棂
+  - 啬
+  - 郾
+  - 匮
+  - 敕
+  - 豉
+  - 鄄
+  - 酞
+  - 酚
+  - 戛
+  - 硎
+  - 硭
+  - 硒
+  - 硖
+  - 硗
+  - 硐
+  - 硇
+  - 硌
+  - 鸸
+  - 瓠
+  - 匏
+  - 厩
+  - 龚
+  - 殒
+  - 殓
+  - 殍
+  - 赉
+  - 雩
+  - 辄
+  - 堑
+  - 眭
+  - 眦
+  - 啧
+  - 晡
+  - 晤
+  - 眺
+  - 眵
+  - 眸
+  - 圊
+  - 喏
+  - 喵
+  - 啉
+  - 勖
+  - 晞
+  - 唵
+  - 晗
+  - 冕
+  - 啭
+  - 畦
+  - 趺
+  - 啮
+  - 跄
+  - 蚶
+  - 蛄
+  - 蛎
+  - 蛆
+  - 蚰
+  - 蛊
+  - 圉
+  - 蚱
+  - 蛉
+  - 蛏
+  - 蚴
+  - 啁
+  - 啕
+  - 唿
+  - 啐
+  - 唼
+  - 唷
+  - 啖
+  - 啵
+  - 啶
+  - 啷
+  - 唳
+  - 唰
+  - 啜
+  - 帻
+  - 崚
+  - 崦
+  - 帼
+  - 崮
+  - 崤
+  - 崆
+  - 赇
+  - 赈
+  - 赊
+  - 铑
+  - 铒
+  - 铗
+  - 铙
+  - 铟
+  - 铠
+  - 铡
+  - 铢
+  - 铣
+  - 铤
+  - 铧
+  - 铨
+  - 铩
+  - 铪
+  - 铫
+  - 铬
+  - 铮
+  - 铯
+  - 铰
+  - 铱
+  - 铳
+  - 铵
+  - 铷
+  - 氪
+  - 牾
+  - 鸹
+  - 秾
+  - 逶
+  - 笺
+  - 筇
+  - 笸
+  - 笪
+  - 笮
+  - 笠
+  - 笥
+  - 笤
+  - 笳
+  - 笾
+  - 笞
+  - 偾
+  - 偃
+  - 偕
+  - 偈
+  - 傀
+  - 偬
+  - 偻
+  - 皑
+  - 皎
+  - 鸻
+  - 徜
+  - 舸
+  - 舻
+  - 舴
+  - 舷
+  - 龛
+  - 翎
+  - 脬
+  - 脘
+  - 脲
+  - 匐
+  - 猗
+  - 猡
+  - 猞
+  - 猝
+  - 斛
+  - 猕
+  - 馗
+  - 馃
+  - 馄
+  - 鸾
+  - 孰
+  - 庹
+  - 庾
+  - 痔
+  - 痍
+  - 疵
+  - 翊
+  - 旌
+  - 旎
+  - 袤
+  - 阇
+  - 阈
+  - 阉
+  - 阊
+  - 阋
+  - 阍
+  - 阏
+  - 羟
+  - 粝
+  - 粕
+  - 敝
+  - 焐
+  - 烯
+  - 焓
+  - 烽
+  - 焖
+  - 烷
+  - 焗
+  - 渍
+  - 渚
+  - 淇
+  - 淅
+  - 淞
+  - 渎
+  - 涿
+  - 淖
+  - 挲
+  - 淠
+  - 涸
+  - 渑
+  - 淦
+  - 淝
+  - 淬
+  - 涪
+  - 淙
+  - 涫
+  - 渌
+  - 淄
+  - 惬
+  - 悻
+  - 悱
+  - 惝
+  - 惘
+  - 悸
+  - 惆
+  - 惚
+  - 惇
+  - 惮
+  - 窕
+  - 谌
+  - 谏
+  - 扈
+  - 皲
+  - 谑
+  - 裆
+  - 袷
+  - 裉
+  - 谒
+  - 谔
+  - 谕
+  - 谖
+  - 谗
+  - 谙
+  - 谛
+  - 谝
+  - 逯
+  - 郿
+  - 隈
+  - 粜
+  - 隍
+  - 隗
+  - 婧
+  - 婊
+  - 婕
+  - 娼
+  - 婢
+  - 婵
+  - 胬
+  - 袈
+  - 翌
+  - 恿
+  - 欸
+  - 绫
+  - 骐
+  - 绮
+  - 绯
+  - 绱
+  - 骒
+  - 绲
+  - 骓
+  - 绶
+  - 绺
+  - 绻
+  - 绾
+  - 骖
+  - 缁
+  - 耠
+  - 琫
+  - 琵
+  - 琶
+  - 琪
+  - 瑛
+  - 琦
+  - 琥
+  - 琨
+  - 靓
+  - 琰
+  - 琮
+  - 琯
+  - 琬
+  - 琛
+  - 琚
+  - 辇
+  - 鼋
+  - 揳
+  - 堞
+  - 搽
+  - 揸
+  - 揠
+  - 堙
+  - 趄
+  - 揖
+  - 颉
+  - 塄
+  - 揿
+  - 耋
+  - 揄
+  - 蛩
+  - 蛰
+  - 塆
+  - 摒
+  - 揆
+  - 掾
+  - 聒
+  - 葑
+  - 葚
+  - 靰
+  - 靸
+  - 葳
+  - 葺
+  - 葸
+  - 萼
+  - 葆
+  - 葩
+  - 葶
+  - 蒌
+  - 萱
+  - 戟
+  - 葭
+  - 楮
+  - 棼
+  - 椟
+  - 棹
+  - 椤
+  - 棰
+  - 赍
+  - 椋
+  - 椁
+  - 椪
+  - 棣
+  - 椐
+  - 鹁
+  - 覃
+  - 酤
+  - 酢
+  - 酡
+  - 鹂
+  - 厥
+  - 殚
+  - 殛
+  - 雯
+  - 雱
+  - 辊
+  - 辋
+  - 椠
+  - 辍
+  - 辎
+  - 斐
+  - 睄
+  - 睑
+  - 睇
+  - 睃
+  - 戢
+  - 喋
+  - 嗒
+  - 喃
+  - 喱
+  - 喹
+  - 晷
+  - 喈
+  - 跖
+  - 跗
+  - 跞
+  - 跚
+  - 跎
+  - 跏
+  - 跆
+  - 蛱
+  - 蛲
+  - 蛭
+  - 蛳
+  - 蛐
+  - 蛔
+  - 蛞
+  - 蛴
+  - 蛟
+  - 蛘
+  - 喁
+  - 喟
+  - 啾
+  - 嗖
+  - 喑
+  - 嗟
+  - 喽
+  - 嗞
+  - 喀
+  - 喔
+  - 喙
+  - 嵘
+  - 嵖
+  - 崴
+  - 遄
+  - 詈
+  - 嵎
+  - 崽
+  - 嵬
+  - 嵛
+  - 嵯
+  - 嵝
+  - 嵫
+  - 幄
+  - 嵋
+  - 赕
+  - 铻
+  - 铼
+  - 铿
+  - 锃
+  - 锂
+  - 锆
+  - 锇
+  - 锉
+  - 锏
+  - 锑
+  - 锒
+  - 锔
+  - 锕
+  - 掣
+  - 矬
+  - 氰
+  - 毳
+  - 毽
+  - 犊
+  - 犄
+  - 犋
+  - 鹄
+  - 犍
+  - 嵇
+  - 黍
+  - 稃
+  - 稂
+  - 筚
+  - 筵
+  - 筌
+  - 傣
+  - 傈
+  - 舄
+  - 牍
+  - 傥
+  - 傧
+  - 遑
+  - 傩
+  - 遁
+  - 徨
+  - 媭
+  - 畲
+  - 弑
+  - 颌
+  - 翕
+  - 釉
+  - 鹆
+  - 舜
+  - 貂
+  - 腈
+  - 腌
+  - 腓
+  - 腆
+  - 腴
+  - 腑
+  - 腚
+  - 腱
+  - 鱿
+  - 鲀
+  - 鲂
+  - 颍
+  - 猢
+  - 猹
+  - 猥
+  - 飓
+  - 觞
+  - 觚
+  - 猱
+  - 颎
+  - 飧
+  - 馇
+  - 馊
+  - 亵
+  - 脔
+  - 裒
+  - 痣
+  - 痨
+  - 痦
+  - 痞
+  - 痤
+  - 痫
+  - 痧
+  - 赓
+  - 竦
+  - 瓿
+  - 啻
+  - 颏
+  - 鹇
+  - 阑
+  - 阒
+  - 阕
+  - 粞
+  - 遒
+  - 孳
+  - 焯
+  - 焜
+  - 焙
+  - 焱
+  - 鹈
+  - 湛
+  - 渫
+  - 湮
+  - 湎
+  - 湜
+  - 渭
+  - 湍
+  - 湫
+  - 溲
+  - 湟
+  - 溆
+  - 湲
+  - 湔
+  - 湉
+  - 渥
+  - 湄
+  - 滁
+  - 愠
+  - 惺
+  - 愦
+  - 惴
+  - 愀
+  - 愎
+  - 愔
+  - 喾
+  - 寐
+  - 谟
+  - 扉
+  - 裢
+  - 裎
+  - 裥
+  - 祾
+  - 祺
+  - 谠
+  - 幂
+  - 谡
+  - 谥
+  - 谧
+  - 遐
+  - 孱
+  - 弼
+  - 巽
+  - 骘
+  - 媪
+  - 媛
+  - 婷
+  - 巯
+  - 翚
+  - 皴
+  - 婺
+  - 骛
+  - 缂
+  - 缃
+  - 缄
+  - 彘
+  - 缇
+  - 缈
+  - 缌
+  - 缑
+  - 缒
+  - 缗
+  - 飨
+  - 耢
+  - 瑚
+  - 瑁
+  - 瑜
+  - 瑗
+  - 瑄
+  - 瑕
+  - 遨
+  - 骜
+  - 韫
+  - 髡
+  - 塬
+  - 鄢
+  - 趔
+  - 趑
+  - 摅
+  - 摁
+  - 蜇
+  - 搋
+  - 搪
+  - 搐
+  - 搛
+  - 搠
+  - 摈
+  - 彀
+  - 毂
+  - 搦
+  - 搡
+  - 蓁
+  - 戡
+  - 蓍
+  - 鄞
+  - 靳
+  - 蓐
+  - 蓦
+  - 鹋
+  - 蒽
+  - 蓓
+  - 蓖
+  - 蓊
+  - 蒯
+  - 蓟
+  - 蓑
+  - 蒿
+  - 蒺
+  - 蓠
+  - 蒟
+  - 蒡
+  - 蒹
+  - 蒴
+  - 蒗
+  - 蓥
+  - 颐
+  - 楔
+  - 楠
+  - 楂
+  - 楝
+  - 楫
+  - 楸
+  - 椴
+  - 槌
+  - 楯
+  - 皙
+  - 榈
+  - 槎
+  - 榉
+  - 楦
+  - 楣
+  - 楹
+  - 椽
+  - 裘
+  - 剽
+  - 甄
+  - 酮
+  - 酰
+  - 酯
+  - 酩
+  - 蜃
+  - 碛
+  - 碓
+  - 硼
+  - 碉
+  - 碚
+  - 碇
+  - 碜
+  - 鹌
+  - 辏
+  - 龃
+  - 龅
+  - 訾
+  - 粲
+  - 虞
+  - 睚
+  - 嗪
+  - 韪
+  - 嗷
+  - 嗉
+  - 睨
+  - 睢
+  - 雎
+  - 睥
+  - 嘟
+  - 嗑
+  - 嗫
+  - 嗬
+  - 嗔
+  - 嗝
+  - 戥
+  - 嗄
+  - 煦
+  - 暄
+  - 遢
+  - 暌
+  - 跬
+  - 跶
+  - 跸
+  - 跐
+  - 跣
+  - 跹
+  - 跻
+  - 蛸
+  - 蜊
+  - 蜍
+  - 蜉
+  - 蜣
+  - 畹
+  - 蛹
+  - 嗣
+  - 嗯
+  - 嗥
+  - 嗲
+  - 嗳
+  - 嗌
+  - 嗍
+  - 嗨
+  - 嗐
+  - 嗤
+  - 嗵
+  - 罨
+  - 嵊
+  - 嵩
+  - 嵴
+  - 骰
+  - 锗
+  - 锛
+  - 锜
+  - 锝
+  - 锞
+  - 锟
+  - 锢
+  - 锨
+  - 锩
+  - 锭
+  - 锱
+  - 雉
+  - 氲
+  - 犏
+  - 歃
+  - 稞
+  - 稗
+  - 稔
+  - 筠
+  - 筢
+  - 筮
+  - 筲
+  - 筱
+  - 牒
+  - 煲
+  - 敫
+  - 徭
+  - 愆
+  - 艄
+  - 觎
+  - 毹
+  - 貊
+  - 貅
+  - 貉
+  - 颔
+  - 腠
+  - 腩
+  - 腼
+  - 腭
+  - 腧
+  - 塍
+  - 媵
+  - 詹
+  - 鲅
+  - 鲆
+  - 鲇
+  - 鲈
+  - 稣
+  - 鲋
+  - 鲐
+  - 肄
+  - 鹐
+  - 飕
+  - 觥
+  - 遛
+  - 馐
+  - 鹑
+  - 亶
+  - 瘃
+  - 痱
+  - 痼
+  - 痿
+  - 瘐
+  - 瘁
+  - 瘆
+  - 麂
+  - 裔
+  - 歆
+  - 旒
+  - 雍
+  - 阖
+  - 阗
+  - 阙
+  - 羧
+  - 豢
+  - 粳
+  - 猷
+  - 煳
+  - 煜
+  - 煨
+  - 煅
+  - 煊
+  - 煸
+  - 煺
+  - 滟
+  - 溱
+  - 溘
+  - 漭
+  - 滢
+  - 溥
+  - 溧
+  - 溽
+  - 裟
+  - 溻
+  - 溷
+  - 滗
+  - 滫
+  - 溴
+  - 滏
+  - 滃
+  - 滦
+  - 溏
+  - 滂
+  - 滓
+  - 溟
+  - 滪
+  - 愫
+  - 慑
+  - 慊
+  - 鲎
+  - 骞
+  - 窦
+  - 窠
+  - 窣
+  - 裱
+  - 褚
+  - 裨
+  - 裾
+  - 裰
+  - 禊
+  - 谩
+  - 谪
+  - 媾
+  - 嫫
+  - 媲
+  - 嫒
+  - 嫔
+  - 媸
+  - 缙
+  - 缜
+  - 缛
+  - 辔
+  - 骝
+  - 缟
+  - 缡
+  - 缢
+  - 缣
+  - 骟
+  - 耥
+  - 璈
+  - 瑶
+  - 瑭
+  - 獒
+  - 觏
+  - 慝
+  - 嫠
+  - 韬
+  - 叆
+  - 髦
+  - 摽
+  - 墁
+  - 撂
+  - 摞
+  - 撄
+  - 翥
+  - 踅
+  - 摭
+  - 墉
+  - 墒
+  - 榖
+  - 綦
+  - 蔫
+  - 蔷
+  - 靺
+  - 靼
+  - 鞅
+  - 靿
+  - 甍
+  - 蔸
+  - 蔟
+  - 蔺
+  - 戬
+  - 蕖
+  - 蔻
+  - 蓿
+  - 斡
+  - 鹕
+  - 蓼
+  - 榛
+  - 榧
+  - 榻
+  - 榫
+  - 榭
+  - 槔
+  - 榱
+  - 槁
+  - 槟
+  - 槠
+  - 榷
+  - 僰
+  - 酽
+  - 酶
+  - 酹
+  - 厮
+  - 碡
+  - 碴
+  - 碣
+  - 碲
+  - 磋
+  - 臧
+  - 豨
+  - 殡
+  - 霆
+  - 霁
+  - 辕
+  - 蜚
+  - 裴
+  - 翡
+  - 龇
+  - 龈
+  - 睿
+  - 䁖
+  - 睽
+  - 嘞
+  - 嘈
+  - 嘌
+  - 嘁
+  - 嘎
+  - 暧
+  - 暝
+  - 踌
+  - 踉
+  - 蜞
+  - 蜥
+  - 蜮
+  - 蝈
+  - 蜴
+  - 蜱
+  - 蜩
+  - 蜷
+  - 蜿
+  - 螂
+  - 蜢
+  - 嘘
+  - 嘡
+  - 鹗
+  - 嘣
+  - 嘤
+  - 嘚
+  - 嗾
+  - 嘧
+  - 罴
+  - 罱
+  - 幔
+  - 嶂
+  - 幛
+  - 赙
+  - 罂
+  - 骷
+  - 骶
+  - 鹘
+  - 锲
+  - 锴
+  - 锶
+  - 锷
+  - 锸
+  - 锵
+  - 镁
+  - 镂
+  - 犒
+  - 箐
+  - 箦
+  - 箧
+  - 箍
+  - 箸
+  - 箬
+  - 箅
+  - 箪
+  - 箔
+  - 箜
+  - 箢
+  - 箓
+  - 毓
+  - 僖
+  - 儆
+  - 僳
+  - 僭
+  - 劁
+  - 僮
+  - 魃
+  - 魆
+  - 睾
+  - 艋
+  - 鄱
+  - 膈
+  - 膑
+  - 鲑
+  - 鲔
+  - 鲚
+  - 鲛
+  - 鲟
+  - 獐
+  - 觫
+  - 雒
+  - 夤
+  - 馑
+  - 銮
+  - 塾
+  - 麽
+  - 瘌
+  - 瘊
+  - 瘘
+  - 瘙
+  - 廖
+  - 韶
+  - 旖
+  - 膂
+  - 阚
+  - 鄯
+  - 鲞
+  - 粿
+  - 粼
+  - 粽
+  - 糁
+  - 槊
+  - 鹚
+  - 熘
+  - 熥
+  - 潢
+  - 漕
+  - 滹
+  - 漯
+  - 漶
+  - 潋
+  - 潴
+  - 漪
+  - 漉
+  - 漳
+  - 漩
+  - 澉
+  - 潍
+  - 慵
+  - 搴
+  - 窨
+  - 寤
+  - 綮
+  - 谮
+  - 褡
+  - 褙
+  - 褓
+  - 褛
+  - 褊
+  - 谯
+  - 谰
+  - 谲
+  - 暨
+  - 屣
+  - 鹛
+  - 嫣
+  - 嫱
+  - 嫖
+  - 嫦
+  - 嫚
+  - 嫘
+  - 嫡
+  - 鼐
+  - 翟
+  - 瞀
+  - 鹜
+  - 骠
+  - 缥
+  - 缦
+  - 缧
+  - 缨
+  - 骢
+  - 缪
+  - 缫
+  - 耦
+  - 耧
+  - 瑾
+  - 璜
+  - 璀
+  - 璎
+  - 璁
+  - 璋
+  - 璇
+  - 奭
+  - 髯
+  - 髫
+  - 撷
+  - 撅
+  - 赭
+  - 撸
+  - 鋆
+  - 撙
+  - 撺
+  - 墀
+  - 聩
+  - 觐
+  - 鞑
+  - 蕙
+  - 鞒
+  - 蕈
+  - 蕨
+  - 蕤
+  - 蕞
+  - 蕺
+  - 瞢
+  - 蕃
+  - 蕲
+  - 赜
+  - 槿
+  - 樯
+  - 槭
+  - 樗
+  - 樘
+  - 樊
+  - 槲
+  - 醌
+  - 醅
+  - 靥
+  - 魇
+  - 餍
+  - 磔
+  - 磙
+  - 霈
+  - 辘
+  - 龉
+  - 龊
+  - 觑
+  - 瞌
+  - 瞋
+  - 瞑
+  - 嘭
+  - 噎
+  - 噶
+  - 颙
+  - 暹
+  - 噘
+  - 踔
+  - 踝
+  - 踟
+  - 踒
+  - 踬
+  - 踮
+  - 踯
+  - 踺
+  - 踞
+  - 蝽
+  - 蝾
+  - 蝻
+  - 蝰
+  - 蝮
+  - 螋
+  - 蝓
+  - 蝣
+  - 蝼
+  - 噗
+  - 嘬
+  - 颚
+  - 噍
+  - 噢
+  - 噙
+  - 噜
+  - 噌
+  - 噔
+  - 颛
+  - 幞
+  - 幡
+  - 嶙
+  - 嶝
+  - 骺
+  - 骼
+  - 骸
+  - 镊
+  - 镉
+  - 镌
+  - 镍
+  - 镏
+  - 镒
+  - 镓
+  - 镔
+  - 稷
+  - 箴
+  - 篑
+  - 篁
+  - 篌
+  - 篆
+  - 牖
+  - 儋
+  - 徵
+  - 磐
+  - 虢
+  - 鹞
+  - 膘
+  - 滕
+  - 鲠
+  - 鲡
+  - 鲢
+  - 鲣
+  - 鲥
+  - 鲧
+  - 鲩
+  - 獗
+  - 獠
+  - 觯
+  - 馓
+  - 馔
+  - 麾
+  - 廛
+  - 瘛
+  - 瘼
+  - 瘢
+  - 瘠
+  - 齑
+  - 羯
+  - 羰
+  - 𥻗
+  - 遴
+  - 糌
+  - 糍
+  - 糅
+  - 熜
+  - 熵
+  - 熠
+  - 澍
+  - 澌
+  - 潸
+  - 潦
+  - 潲
+  - 鋈
+  - 潟
+  - 潼
+  - 潺
+  - 憬
+  - 憧
+  - 寮
+  - 窳
+  - 谳
+  - 褴
+  - 褟
+  - 褫
+  - 谵
+  - 熨
+  - 屦
+  - 嬉
+  - 勰
+  - 戮
+  - 蝥
+  - 缬
+  - 缮
+  - 缯
+  - 骣
+  - 畿
+  - 耩
+  - 耨
+  - 耪
+  - 璞
+  - 璟
+  - 靛
+  - 璠
+  - 璘
+  - 聱
+  - 螯
+  - 髻
+  - 髭
+  - 髹
+  - 擀
+  - 熹
+  - 甏
+  - 擞
+  - 縠
+  - 磬
+  - 颞
+  - 蕻
+  - 鞘
+  - 颟
+  - 薤
+  - 薨
+  - 檠
+  - 薏
+  - 薮
+  - 薜
+  - 薅
+  - 樾
+  - 橛
+  - 橇
+  - 樵
+  - 檎
+  - 橹
+  - 樽
+  - 樨
+  - 橼
+  - 墼
+  - 橐
+  - 翮
+  - 醛
+  - 醐
+  - 醍
+  - 醚
+  - 磲
+  - 赝
+  - 飙
+  - 殪
+  - 霖
+  - 霏
+  - 霓
+  - 錾
+  - 辚
+  - 臻
+  - 遽
+  - 氅
+  - 瞟
+  - 瞠
+  - 瞰
+  - 嚄
+  - 嚆
+  - 噤
+  - 暾
+  - 蹀
+  - 踹
+  - 踵
+  - 踽
+  - 蹉
+  - 蹁
+  - 螨
+  - 蟒
+  - 螈
+  - 螅
+  - 螭
+  - 螠
+  - 螟
+  - 噱
+  - 噬
+  - 噫
+  - 噻
+  - 噼
+  - 罹
+  - 圜
+  - 䦃
+  - 镖
+  - 镗
+  - 镘
+  - 镚
+  - 镛
+  - 镝
+  - 镞
+  - 镠
+  - 氇
+  - 氆
+  - 憩
+  - 穑
+  - 篝
+  - 篥
+  - 篦
+  - 篪
+  - 篙
+  - 盥
+  - 劓
+  - 翱
+  - 魉
+  - 魈
+  - 徼
+  - 歙
+  - 膳
+  - 膦
+  - 膙
+  - 鲮
+  - 鲱
+  - 鲲
+  - 鲳
+  - 鲴
+  - 鲵
+  - 鲷
+  - 鲻
+  - 獴
+  - 獭
+  - 獬
+  - 邂
+  - 鹧
+  - 廨
+  - 赟
+  - 瘰
+  - 廪
+  - 瘿
+  - 瘵
+  - 瘴
+  - 癃
+  - 瘳
+  - 斓
+  - 麇
+  - 麈
+  - 嬴
+  - 壅
+  - 羲
+  - 糗
+  - 瞥
+  - 甑
+  - 燎
+  - 燠
+  - 燔
+  - 燧
+  - 濑
+  - 濉
+  - 潞
+  - 澧
+  - 澹
+  - 澥
+  - 澶
+  - 濂
+  - 褰
+  - 寰
+  - 窸
+  - 褶
+  - 禧
+  - 嬖
+  - 犟
+  - 隰
+  - 嬗
+  - 颡
+  - 缱
+  - 缲
+  - 缳
+  - 璨
+  - 璩
+  - 璐
+  - 璪
+  - 螫
+  - 擤
+  - 壕
+  - 觳
+  - 罄
+  - 擢
+  - 薹
+  - 鞡
+  - 鞬
+  - 薷
+  - 薰
+  - 藓
+  - 藁
+  - 檄
+  - 檩
+  - 懋
+  - 醢
+  - 翳
+  - 礅
+  - 磴
+  - 鹩
+  - 龋
+  - 龌
+  - 豳
+  - 壑
+  - 黻
+  - 嚏
+  - 嚅
+  - 蹑
+  - 蹒
+  - 蹊
+  - 蟥
+  - 螬
+  - 螵
+  - 疃
+  - 螳
+  - 蟑
+  - 嚓
+  - 羁
+  - 罽
+  - 罾
+  - 嶷
+  - 黜
+  - 黝
+  - 髁
+  - 髀
+  - 镡
+  - 镢
+  - 镣
+  - 镦
+  - 镧
+  - 镩
+  - 镪
+  - 镫
+  - 罅
+  - 黏
+  - 簌
+  - 篾
+  - 篼
+  - 簖
+  - 簋
+  - 鼢
+  - 黛
+  - 儡
+  - 鹪
+  - 鼾
+  - 皤
+  - 魍
+  - 龠
+  - 繇
+  - 貘
+  - 邈
+  - 貔
+  - 臌
+  - 膻
+  - 臆
+  - 臃
+  - 鲼
+  - 鲽
+  - 鳀
+  - 鳃
+  - 鳅
+  - 鳇
+  - 鳊
+  - 螽
+  - 燮
+  - 鹫
+  - 襄
+  - 糜
+  - 縻
+  - 膺
+  - 癍
+  - 麋
+  - 懑
+  - 濡
+  - 濮
+  - 濞
+  - 濠
+  - 濯
+  - 蹇
+  - 謇
+  - 邃
+  - 襁
+  - 檗
+  - 擘
+  - 孺
+  - 隳
+  - 嬷
+  - 蟊
+  - 鹬
+  - 鍪
+  - 鏊
+  - 鳌
+  - 鬈
+  - 鬃
+  - 瞽
+  - 鞯
+  - 鞨
+  - 鞫
+  - 鞧
+  - 鞣
+  - 藜
+  - 藠
+  - 藩
+  - 醪
+  - 蹙
+  - 礓
+  - 燹
+  - 餮
+  - 瞿
+  - 曛
+  - 颢
+  - 曜
+  - 躇
+  - 蹚
+  - 鹭
+  - 蟛
+  - 蟪
+  - 蟠
+  - 蟮
+  - 鹮
+  - 黠
+  - 黟
+  - 髅
+  - 髂
+  - 镬
+  - 镭
+  - 镯
+  - 馥
+  - 簟
+  - 簪
+  - 鼬
+  - 雠
+  - 艟
+  - 鳎
+  - 鳏
+  - 鳐
+  - 癞
+  - 癔
+  - 癜
+  - 癖
+  - 糨
+  - 蹩
+  - 鎏
+  - 懵
+  - 彝
+  - 邋
+  - 鬏
+  - 攉
+  - 攒
+  - 鞲
+  - 鞴
+  - 藿
+  - 蘧
+  - 蘅
+  - 麓
+  - 醮
+  - 醯
+  - 酃
+  - 霪
+  - 霭
+  - 霨
+  - 黼
+  - 嚯
+  - 蹰
+  - 蹶
+  - 蹽
+  - 蹼
+  - 蹴
+  - 蹾
+  - 蹿
+  - 蠖
+  - 蠓
+  - 蟾
+  - 蠊
+  - 黢
+  - 髋
+  - 髌
+  - 镲
+  - 籀
+  - 籁
+  - 齁
+  - 魑
+  - 艨
+  - 鳓
+  - 鳔
+  - 鳕
+  - 鳗
+  - 鳙
+  - 麒
+  - 鏖
+  - 羸
+  - 㸆
+  - 瀚
+  - 瀣
+  - 瀛
+  - 襦
+  - 谶
+  - 襞
+  - 骥
+  - 缵
+  - 瓒
+  - 攘
+  - 蘩
+  - 蘖
+  - 醴
+  - 霰
+  - 酆
+  - 矍
+  - 曦
+  - 躅
+  - 鼍
+  - 巉
+  - 黩
+  - 黥
+  - 黪
+  - 镳
+  - 镴
+  - 黧
+  - 纂
+  - 璺
+  - 鼯
+  - 臜
+  - 鳜
+  - 鳝
+  - 鳟
+  - 獾
+  - 孀
+  - 骧
+  - 瓘
+  - 鼙
+  - 醺
+  - 礴
+  - 颦
+  - 曩
+  - 鳢
+  - 癫
+  - 麝
+  - 夔
+  - 爝
+  - 灏
+  - 禳
+  - 鐾
+  - 羼
+  - 蠡
+  - 耱
+  - 懿
+  - 蘸
+  - 鹳
+  - 霾
+  - 氍
+  - 饕
+  - 躐
+  - 髑
+  - 镵
+  - 穰
+  - 饔
+  - 鬻
+  - 鬟
+  - 趱
+  - 攫
+  - 攥
+  - 颧
+  - 躜
+  - 鼹
+  - 癯
+  - 麟
+  - 蠲
+  - 蠹
+  - 躞
+  - 衢
+  - 鑫
+  - 灞
+  - 襻
+  - 纛
+  - 鬣
+  - 攮
+  - 囔
+  - 馕
+  - 戆
+  - 爨
+  - 齉
+  - 亍
+  - 尢
+  - 彳
+  - 卬
+  - 殳
+  - 𠙶
+  - 毌
+  - 邘
+  - 戋
+  - 圢
+  - 氕
+  - 伋
+  - 仝
+  - 冮
+  - 氿
+  - 汈
+  - 氾
+  - 忉
+  - 宄
+  - 讱
+  - 扞
+  - 圲
+  - 圫
+  - 芏
+  - 芃
+  - 朳
+  - 朸
+  - 𨙸
+  - 邨
+  - 吒
+  - 吖
+  - 屼
+  - 屾
+  - 辿
+  - 钆
+  - 仳
+  - 伣
+  - 伈
+  - 癿
+  - 甪
+  - 邠
+  - 犴
+  - 冱
+  - 邡
+  - 闫
+  - 汋
+  - 䜣
+  - 讻
+  - 孖
+  - 纩
+  - 玒
+  - 玓
+  - 玘
+  - 玚
+  - 刬
+  - 坜
+  - 坉
+  - 扽
+  - 坋
+  - 扺
+  - 㧑
+  - 毐
+  - 芰
+  - 芣
+  - 苊
+  - 苉
+  - 芘
+  - 芴
+  - 芠
+  - 芤
+  - 杕
+  - 杙
+  - 杄
+  - 杧
+  - 杩
+  - 尪
+  - 尨
+  - 轪
+  - 坒
+  - 芈
+  - 旴
+  - 旵
+  - 呙
+  - 㕮
+  - 岍
+  - 岠
+  - 岜
+  - 呇
+  - 冏
+  - 觃
+  - 岙
+  - 伾
+  - 㑇
+  - 伭
+  - 佖
+  - 伲
+  - 佁
+  - 飏
+  - 狃
+  - 闶
+  - 汧
+  - 汫
+  - 𣲘
+  - 𣲗
+  - 沄
+  - 沘
+  - 汭
+  - 㳇
+  - 沇
+  - 忮
+  - 忳
+  - 忺
+  - 祃
+  - 诇
+  - 邲
+  - 诎
+  - 诐
+  - 屃
+  - 岊
+  - 阽
+  - 䢺
+  - 阼
+  - 妧
+  - 妘
+  - 𨚕
+  - 纮
+  - 驲
+  - 纻
+  - 纼
+  - 玤
+  - 玞
+  - 玱
+  - 玟
+  - 邽
+  - 邿
+  - 坥
+  - 坰
+  - 坬
+  - 坽
+  - 弆
+  - 耵
+  - 䢼
+  - 𦭜
+  - 茋
+  - 苧
+  - 苾
+  - 苠
+  - 枅
+  - 㭎
+  - 枘
+  - 枍
+  - 矼
+  - 矻
+  - 匼
+  - 旿
+  - 昇
+  - 昄
+  - 昒
+  - 昈
+  - 咉
+  - 咇
+  - 咍
+  - 岵
+  - 岽
+  - 岨
+  - 岞
+  - 峂
+  - 㟃
+  - 囷
+  - 钐
+  - 钔
+  - 钖
+  - 牥
+  - 佴
+  - 垈
+  - 侁
+  - 侹
+  - 佸
+  - 佺
+  - 隹
+  - 㑊
+  - 侂
+  - 佽
+  - 侘
+  - 郈
+  - 舠
+  - 郐
+  - 郃
+  - 攽
+  - 肭
+  - 肸
+  - 肷
+  - 狉
+  - 狝
+  - 饳
+  - 忞
+  - 於
+  - 炌
+  - 炆
+  - 泙
+  - 沺
+  - 泂
+  - 泜
+  - 泃
+  - 泇
+  - 怊
+  - 峃
+  - 穸
+  - 祋
+  - 祊
+  - 鸤
+  - 弢
+  - 弨
+  - 陑
+  - 陎
+  - 卺
+  - 乸
+  - 妭
+  - 姈
+  - 迳
+  - 叕
+  - 驵
+  - 䌹
+  - 驺
+  - 绋
+  - 绐
+  - 砉
+  - 耔
+  - 㛃
+  - 玶
+  - 珇
+  - 珅
+  - 珋
+  - 玹
+  - 珌
+  - 玿
+  - 韨
+  - 垚
+  - 垯
+  - 垙
+  - 垲
+  - 埏
+  - 垍
+  - 耇
+  - 垎
+  - 垴
+  - 垟
+  - 垞
+  - 挓
+  - 垵
+  - 垏
+  - 拶
+  - 荖
+  - 荁
+  - 荙
+  - 荛
+  - 茈
+  - 茽
+  - 荄
+  - 茺
+  - 荓
+  - 茳
+  - 𦰡
+  - 茛
+  - 荭
+  - 㭕
+  - 柷
+  - 柃
+  - 柊
+  - 枹
+  - 栐
+  - 柖
+  - 郚
+  - 剅
+  - 䴓
+  - 迺
+  - 厖
+  - 砆
+  - 砑
+  - 砄
+  - 耏
+  - 奓
+  - 䶮
+  - 轵
+  - 轷
+  - 轹
+  - 轺
+  - 昺
+  - 昽
+  - 盷
+  - 咡
+  - 咺
+  - 昳
+  - 昣
+  - 哒
+  - 昤
+  - 昫
+  - 昡
+  - 咥
+  - 昪
+  - 虷
+  - 虸
+  - 哃
+  - 峘
+  - 耑
+  - 峛
+  - 峗
+  - 峧
+  - 帡
+  - 钘
+  - 钜
+  - 钪
+  - 钬
+  - 钭
+  - 矧
+  - 秬
+  - 俫
+  - 舁
+  - 俜
+  - 俙
+  - 俍
+  - 垕
+  - 衎
+  - 舣
+  - 弇
+  - 侴
+  - 鸧
+  - 䏡
+  - 胠
+  - 𦙶
+  - 胈
+  - 胩
+  - 胣
+  - 朏
+  - 飐
+  - 訄
+  - 饻
+  - 庤
+  - 疢
+  - 炣
+  - 炟
+  - 㶲
+  - 洭
+  - 洘
+  - 洓
+  - 洿
+  - 㳚
+  - 泚
+  - 浈
+  - 浉
+  - 洸
+  - 洑
+  - 洢
+  - 洈
+  - 洚
+  - 洺
+  - 洨
+  - 浐
+  - 㳘
+  - 洴
+  - 洣
+  - 恔
+  - 宬
+  - 窀
+  - 扂
+  - 袆
+  - 祏
+  - 祐
+  - 祕
+  - 叚
+  - 陧
+  - 陞
+  - 娀
+  - 姞
+  - 姱
+  - 姤
+  - 姶
+  - 姽
+  - 枲
+  - 绖
+  - 骃
+  - 彖
+  - 骉
+  - 恝
+  - 珪
+  - 珛
+  - 珹
+  - 琊
+  - 玼
+  - 珖
+  - 珽
+  - 珦
+  - 珫
+  - 珒
+  - 珢
+  - 珕
+  - 珝
+  - 埗
+  - 垾
+  - 垺
+  - 埆
+  - 垿
+  - 埌
+  - 埇
+  - 莰
+  - 茝
+  - 鄀
+  - 莶
+  - 莝
+  - 䓖
+  - 莙
+  - 栻
+  - 桠
+  - 桄
+  - 梠
+  - 栴
+  - 梴
+  - 栒
+  - 酎
+  - 酏
+  - 砵
+  - 砠
+  - 砫
+  - 砬
+  - 硁
+  - 恧
+  - 翃
+  - 郪
+  - 𨐈
+  - 辀
+  - 辁
+  - 剕
+  - 赀
+  - 哢
+  - 晅
+  - 晊
+  - 唝
+  - 哳
+  - 哱
+  - 冔
+  - 晔
+  - 晐
+  - 晖
+  - 畖
+  - 蚄
+  - 蚆
+  - 帱
+  - 崁
+  - 峿
+  - 崄
+  - 帨
+  - 崀
+  - 赆
+  - 钷
+  - 眚
+  - 甡
+  - 笫
+  - 倻
+  - 倴
+  - 脩
+  - 倮
+  - 倕
+  - 倞
+  - 倓
+  - 倧
+  - 衃
+  - 虒
+  - 舭
+  - 舯
+  - 舥
+  - 瓞
+  - 鬯
+  - 鸰
+  - 脎
+  - 朓
+  - 胲
+  - 虓
+  - 鱽
+  - 狴
+  - 峱
+  - 狻
+  - 眢
+  - 勍
+  - 痄
+  - 疰
+  - 痃
+  - 竘
+  - 羖
+  - 羓
+  - 桊
+  - 敉
+  - 烠
+  - 烔
+  - 烶
+  - 烻
+  - 涍
+  - 浡
+  - 浭
+  - 浬
+  - 涄
+  - 涢
+  - 涐
+  - 浰
+  - 浟
+  - 浛
+  - 浼
+  - 浲
+  - 涘
+  - 悈
+  - 悃
+  - 悢
+  - 宧
+  - 窅
+  - 窊
+  - 窎
+  - 扅
+  - 扆
+  - 袪
+  - 袗
+  - 袯
+  - 祧
+  - 隺
+  - 堲
+  - 疍
+  - 𨺙
+  - 陴
+  - 烝
+  - 砮
+  - 㛚
+  - 哿
+  - 翀
+  - 翂
+  - 剟
+  - 绤
+  - 骍
+  - 䂮
+  - 琎
+  - 珸
+  - 珵
+  - 琄
+  - 琈
+  - 琀
+  - 珺
+  - 掭
+  - 堎
+  - 堐
+  - 埼
+  - 掎
+  - 埫
+  - 堌
+  - 晢
+  - 掞
+  - 埪
+  - 壸
+  - 㙍
+  - 聍
+  - 菝
+  - 萚
+  - 菥
+  - 莿
+  - 䓫
+  - 勚
+  - 䓬
+  - 萆
+  - 菂
+  - 菍
+  - 菼
+  - 萣
+  - 䓨
+  - 菉
+  - 䓛
+  - 梼
+  - 梽
+  - 桲
+  - 梾
+  - 桯
+  - 梣
+  - 梌
+  - 桹
+  - 敔
+  - 厣
+  - 硔
+  - 硙
+  - 硚
+  - 硊
+  - 硍
+  - 勔
+  - 䴕
+  - 龁
+  - 逴
+  - 唪
+  - 啫
+  - 翈
+  - 㫰
+  - 晙
+  - 畤
+  - 趼
+  - 跂
+  - 蛃
+  - 蚲
+  - 蚺
+  - 啴
+  - 䎃
+  - 崧
+  - 崟
+  - 崞
+  - 崒
+  - 崌
+  - 崡
+  - 铏
+  - 铕
+  - 铖
+  - 铘
+  - 铚
+  - 铞
+  - 铥
+  - 铴
+  - 牻
+  - 牿
+  - 稆
+  - 笱
+  - 笯
+  - 偰
+  - 偡
+  - 鸺
+  - 偭
+  - 偲
+  - 偁
+  - 㿠
+  - 鄅
+  - 偓
+  - 徛
+  - 衒
+  - 舳
+  - 舲
+  - 鸼
+  - 悆
+  - 鄃
+  - 瓻
+  - 䝙
+  - 脶
+  - 脞
+  - 脟
+  - 䏲
+  - 鱾
+  - 猇
+  - 猊
+  - 猄
+  - 觖
+  - 𠅤
+  - 庱
+  - 庼
+  - 庳
+  - 痓
+  - 䴔
+  - 竫
+  - 堃
+  - 阌
+  - 羝
+  - 羕
+  - 焆
+  - 烺
+  - 焌
+  - 淏
+  - 淟
+  - 淜
+  - 淴
+  - 淯
+  - 湴
+  - 涴
+  - 㥄
+  - 惛
+  - 惔
+  - 悰
+  - 惙
+  - 寁
+  - 逭
+  - 袼
+  - 裈
+  - 祲
+  - 谞
+  - 艴
+  - 弸
+  - 弶
+  - 隃
+  - 婞
+  - 娵
+  - 婼
+  - 媖
+  - 婳
+  - 婍
+  - 婌
+  - 婫
+  - 婤
+  - 婘
+  - 婠
+  - 绹
+  - 骕
+  - 絜
+  - 珷
+  - 琲
+  - 琡
+  - 琟
+  - 琔
+  - 琭
+  - 堾
+  - 堼
+  - 揕
+  - 㙘
+  - 堧
+  - 喆
+  - 堨
+  - 塅
+  - 堠
+  - 絷
+  - 𡎚
+  - 葜
+  - 惎
+  - 萳
+  - 葙
+  - 靬
+  - 葴
+  - 蒇
+  - 蒈
+  - 鄚
+  - 蒉
+  - 蓇
+  - 萩
+  - 蒐
+  - 葰
+  - 葎
+  - 鄑
+  - 蒎
+  - 葖
+  - 蒄
+  - 萹
+  - 棤
+  - 棽
+  - 棫
+  - 椓
+  - 椑
+  - 鹀
+  - 椆
+  - 棓
+  - 棬
+  - 棪
+  - 椀
+  - 楗
+  - 甦
+  - 酦
+  - 觌
+  - 奡
+  - 皕
+  - 硪
+  - 欹
+  - 詟
+  - 辌
+  - 棐
+  - 龂
+  - 黹
+  - 牚
+  - 睎
+  - 晫
+  - 晪
+  - 晱
+  - 𧿹
+  - 蛑
+  - 畯
+  - 斝
+  - 喤
+  - 崶
+  - 嵁
+  - 崾
+  - 嵅
+  - 崿
+  - 嵚
+  - 翙
+  - 圌
+  - 圐
+  - 赑
+  - 淼
+  - 赒
+  - 铹
+  - 铽
+  - 𨱇
+  - 锊
+  - 锍
+  - 锎
+  - 锓
+  - 犇
+  - 颋
+  - 稌
+  - 筀
+  - 筘
+  - 筜
+  - 筥
+  - 筅
+  - 傃
+  - 傉
+  - 翛
+  - 傒
+  - 傕
+  - 舾
+  - 畬
+  - 脿
+  - 腘
+  - 䐃
+  - 腙
+  - 腒
+  - 鲃
+  - 猰
+  - 猯
+  - 㺄
+  - 馉
+  - 鄗
+  - 廋
+  - 廆
+  - 鄌
+  - 粢
+  - 遆
+  - 旐
+  - 焞
+  - 欻
+  - 𣸣
+  - 溚
+  - 溁
+  - 湝
+  - 渰
+  - 湓
+  - 㴔
+  - 渟
+  - 溠
+  - 渼
+  - 溇
+  - 湣
+  - 湑
+  - 溞
+  - 愐
+  - 愃
+  - 敩
+  - 甯
+  - 棨
+  - 扊
+  - 裣
+  - 祼
+  - 婻
+  - 媆
+  - 媞
+  - 㛹
+  - 媓
+  - 媂
+  - 媄
+  - 毵
+  - 矞
+  - 缊
+  - 缐
+  - 骙
+  - 瑃
+  - 瑓
+  - 瑅
+  - 瑆
+  - 䴖
+  - 瑖
+  - 瑝
+  - 瑔
+  - 瑀
+  - 𤧛
+  - 瑳
+  - 瑂
+  - 嶅
+  - 瑑
+  - 遘
+  - 髢
+  - 塥
+  - 堽
+  - 赪
+  - 摛
+  - 塝
+  - 搒
+  - 搌
+  - 蒱
+  - 蒨
+  - 蓏
+  - 蔀
+  - 蓢
+  - 蓂
+  - 蒻
+  - 蓣
+  - 椹
+  - 楪
+  - 榃
+  - 榅
+  - 楒
+  - 楞
+  - 楩
+  - 榇
+  - 椸
+  - 楙
+  - 歅
+  - 碃
+  - 碏
+  - 碈
+  - 䃅
+  - 硿
+  - 鄠
+  - 辒
+  - 龆
+  - 觜
+  - 䣘
+  - 暕
+  - 鹍
+  - 㬊
+  - 暅
+  - 跱
+  - 蜐
+  - 蜎
+  - 嵲
+  - 赗
+  - 骱
+  - 锖
+  - 锘
+  - 锳
+  - 锧
+  - 锪
+  - 锫
+  - 锬
+  - 稑
+  - 稙
+  - 䅟
+  - 筻
+  - 筼
+  - 筶
+  - 筦
+  - 筤
+  - 傺
+  - 鹎
+  - 僇
+  - 艅
+  - 艉
+  - 谼
+  - 貆
+  - 腽
+  - 腨
+  - 腯
+  - 鲉
+  - 鲊
+  - 鲌
+  - 䲟
+  - 鲏
+  - 雊
+  - 猺
+  - 飔
+  - 觟
+  - 𦝼
+  - 馌
+  - 裛
+  - 廒
+  - 瘀
+  - 瘅
+  - 鄘
+  - 鹒
+  - 鄜
+  - 麀
+  - 鄣
+  - 阘
+  - 煁
+  - 煃
+  - 煴
+  - 煋
+  - 煟
+  - 煓
+  - 滠
+  - 溍
+  - 溹
+  - 滆
+  - 滉
+  - 溦
+  - 溵
+  - 漷
+  - 滧
+  - 滘
+  - 滍
+  - 愭
+  - 慥
+  - 慆
+  - 塱
+  - 裼
+  - 禋
+  - 禔
+  - 禘
+  - 禒
+  - 谫
+  - 鹔
+  - 愍
+  - 嫄
+  - 媱
+  - 戤
+  - 戣
+  - 缞
+  - 耤
+  - 瑧
+  - 瑨
+  - 瑱
+  - 瑷
+  - 瑢
+  - 斠
+  - 摏
+  - 墕
+  - 墈
+  - 墐
+  - 墘
+  - 摴
+  - 銎
+  - 𡐓
+  - 墚
+  - 撖
+  - 靽
+  - 鞁
+  - 蔌
+  - 蔈
+  - 蓰
+  - 蔹
+  - 蔊
+  - 嘏
+  - 榰
+  - 榑
+  - 槚
+  - 𣗋
+  - 槜
+  - 榍
+  - 疐
+  - 酺
+  - 酾
+  - 酲
+  - 酴
+  - 碶
+  - 䃎
+  - 碨
+  - 𥔲
+  - 碹
+  - 碥
+  - 劂
+  - 䴗
+  - 夥
+  - 瞍
+  - 鹖
+  - 㬎
+  - 跽
+  - 蜾
+  - 幖
+  - 嶍
+  - 圙
+  - 𨱏
+  - 锺
+  - 锼
+  - 锽
+  - 锾
+  - 锿
+  - 镃
+  - 镄
+  - 镅
+  - 馝
+  - 鹙
+  - 箨
+  - 箖
+  - 劄
+  - 僬
+  - 僦
+  - 僔
+  - 僎
+  - 槃
+  - 㙦
+  - 鲒
+  - 鲕
+  - 鲖
+  - 鲗
+  - 鲘
+  - 鲙
+  - 𩽾
+  - 夐
+  - 獍
+  - 飗
+  - 凘
+  - 廑
+  - 廙
+  - 瘗
+  - 瘥
+  - 瘕
+  - 鲝
+  - 鄫
+  - 熇
+  - 漹
+  - 漖
+  - 潆
+  - 漤
+  - 潩
+  - 漼
+  - 漴
+  - 㽏
+  - 漈
+  - 漋
+  - 漻
+  - 慬
+  - 窬
+  - 窭
+  - 㮾
+  - 褕
+  - 禛
+  - 禚
+  - 隩
+  - 嫕
+  - 嫭
+  - 嫜
+  - 嫪
+  - 㻬
+  - 麹
+  - 璆
+  - 漦
+  - 叇
+  - 墣
+  - 墦
+  - 墡
+  - 劐
+  - 薁
+  - 蕰
+  - 蔃
+  - 鼒
+  - 槱
+  - 鹝
+  - 磏
+  - 磉
+  - 殣
+  - 慭
+  - 霅
+  - 暵
+  - 暲
+  - 暶
+  - 踦
+  - 踣
+  - 䗖
+  - 蝘
+  - 蝲
+  - 蝤
+  - 噇
+  - 噂
+  - 噀
+  - 罶
+  - 嶲
+  - 嶓
+  - 㠇
+  - 嶟
+  - 嶒
+  - 镆
+  - 镈
+  - 镋
+  - 镎
+  - 镕
+  - 稹
+  - 儇
+  - 皞
+  - 皛
+  - 䴘
+  - 艎
+  - 艏
+  - 鹟
+  - 𩾃
+  - 鲦
+  - 鲪
+  - 鲬
+  - 橥
+  - 觭
+  - 鹠
+  - 鹡
+  - 糇
+  - 糈
+  - 翦
+  - 鹢
+  - 鹣
+  - 熛
+  - 潖
+  - 潵
+  - 㵐
+  - 澂
+  - 澛
+  - 瑬
+  - 潽
+  - 潾
+  - 潏
+  - 憭
+  - 憕
+  - 戭
+  - 褯
+  - 禤
+  - 嫽
+  - 遹
+  - 璥
+  - 璲
+  - 璒
+  - 憙
+  - 擐
+  - 鄹
+  - 薳
+  - 鞔
+  - 黇
+  - 蕗
+  - 薢
+  - 蕹
+  - 橞
+  - 橑
+  - 橦
+  - 醑
+  - 觱
+  - 磡
+  - 𥕢
+  - 磜
+  - 豮
+  - 鹾
+  - 虤
+  - 暿
+  - 曌
+  - 曈
+  - 㬚
+  - 蹅
+  - 踶
+  - 䗛
+  - 螗
+  - 疁
+  - 㠓
+  - 幪
+  - 嶦
+  - 𨱑
+  - 馞
+  - 穄
+  - 篚
+  - 篯
+  - 簉
+  - 鼽
+  - 衠
+  - 盦
+  - 螣
+  - 縢
+  - 鲭
+  - 鲯
+  - 鲰
+  - 鲺
+  - 鲹
+  - 亸
+  - 癀
+  - 瘭
+  - 羱
+  - 糒
+  - 燋
+  - 熻
+  - 燊
+  - 燚
+  - 燏
+  - 濩
+  - 濋
+  - 澪
+  - 澽
+  - 澴
+  - 澭
+  - 澼
+  - 憷
+  - 憺
+  - 懔
+  - 黉
+  - 嬛
+  - 鹨
+  - 翯
+  - 璱
+  - 𤩽
+  - 璬
+  - 璮
+  - 髽
+  - 擿
+  - 薿
+  - 薸
+  - 檑
+  - 櫆
+  - 檞
+  - 醨
+  - 繄
+  - 磹
+  - 磻
+  - 瞫
+  - 瞵
+  - 蹐
+  - 蟏
+  - 㘎
+  - 镤
+  - 镥
+  - 镨
+  - 𨱔
+  - 矰
+  - 穙
+  - 穜
+  - 穟
+  - 簕
+  - 簃
+  - 簏
+  - 儦
+  - 魋
+  - 斶
+  - 艚
+  - 谿
+  - 䲠
+  - 鲾
+  - 鲿
+  - 鳁
+  - 鳂
+  - 鳈
+  - 鳉
+  - 獯
+  - 䗪
+  - 馘
+  - 襕
+  - 襚
+  - 螱
+  - 甓
+  - 嬬
+  - 嬥
+  - 𦈡
+  - 瓀
+  - 釐
+  - 鬶
+  - 爇
+  - 鞳
+  - 鞮
+  - 藟
+  - 藦
+  - 藨
+  - 鹲
+  - 檫
+  - 黡
+  - 礞
+  - 礌
+  - 𥖨
+  - 蹢
+  - 蹜
+  - 蟫
+  - 䗴
+  - 嚚
+  - 髃
+  - 镮
+  - 镱
+  - 酂
+  - 馧
+  - 簠
+  - 簝
+  - 簰
+  - 鼫
+  - 鼩
+  - 皦
+  - 臑
+  - 䲢
+  - 鳑
+  - 鳒
+  - 鹱
+  - 鹯
+  - 癗
+  - 𦒍
+  - 旞
+  - 翷
+  - 冁
+  - 䎖
+  - 瀔
+  - 瀍
+  - 瀌
+  - 襜
+  - 䴙
+  - 嚭
+  - 㰀
+  - 鬷
+  - 醭
+  - 蹯
+  - 蠋
+  - 翾
+  - 鳘
+  - 儳
+  - 儴
+  - 鼗
+  - 𩾌
+  - 鳚
+  - 鳛
+  - 麑
+  - 麖
+  - 蠃
+  - 彟
+  - 嬿
+  - 鬒
+  - 蘘
+  - 欂
+  - 醵
+  - 颥
+  - 甗
+  - 𨟠
+  - 巇
+  - 酅
+  - 髎
+  - 犨
+  - 𨭉
+  - 㸌
+  - 爔
+  - 瀱
+  - 瀹
+  - 瀼
+  - 瀵
+  - 襫
+  - 孅
+  - 骦
+  - 耰
+  - 𤫉
+  - 瓖
+  - 鬘
+  - 趯
+  - 罍
+  - 鼱
+  - 鳠
+  - 鳡
+  - 鳣
+  - 爟
+  - 爚
+  - 灈
+  - 韂
+  - 糵
+  - 蘼
+  - 礵
+  - 鹴
+  - 躔
+  - 皭
+  - 龢
+  - 鳤
+  - 亹
+  - 籥
+  - 鼷
+  - 玃
+  - 醾
+  - 齇
+  - 觿
+  - 蠼
+  - 𬣙
+  - 𬇕
+  - 𬣞
+  - 𬘓
+  - 𫭟
+  - 𫭢
+  - 𫇭
+  - 𫐄
+  - 𫵷
+  - 𬇙
+  - 𬣡
+  - 𫸩
+  - 𫘜
+  - 𬘘
+  - 𫘝
+  - 𬨂
+  - 𬀩
+  - 𬀪
+  - 𬬩
+  - 𫍣
+  - 𬣳
+  - 𬩽
+  - 𬮿
+  - 𬯀
+  - 𫰛
+  - 𬳵
+  - 𬳶
+  - 𫠊
+  - 𬍛
+  - 鿍
+  - 𬜬
+  - 𪾢
+  - 𪨰
+  - 𫓧
+  - 𬬮
+  - 𬬱
+  - 𬬭
+  - 𬘡
+  - 𬳽
+  - 𬘩
+  - 𫄧
+  - 𪟝
+  - 𬍤
+  - 𫭼
+  - 𬜯
+  - 𬂩
+  - 𫠆
+  - 𬌗
+  - 𫑡
+  - 𪨶
+  - 𬬸
+  - 𬬻
+  - 𬬹
+  - 𬬿
+  - 𬭁
+  - 𫢸
+  - 𫗧
+  - 𬊈
+  - 𬒈
+  - 𬳿
+  - 𫄨
+  - 𬘫
+  - 𫮃
+  - 鿎
+  - 𬱖
+  - 𬟽
+  - 𫓯
+  - 𫟹
+  - 𫟼
+  - 𬇹
+  - 𬍡
+  - 𬤇
+  - 𫍯
+  - 𬤊
+  - 𫍲
+  - 𬯎
+  - 𬘬
+  - 𬘭
+  - 𬴂
+  - 𫘦
+  - 𫟅
+  - 𬘯
+  - 𫘧
+  - 𪣻
+  - 𬃊
+  - 𬷕
+  - 𫐐
+  - 𬹼
+  - 𫶇
+  - 𫖮
+  - 鿏
+  - 𬭊
+  - 𫓶
+  - 𬭎
+  - 𫖯
+  - 𬱟
+  - 𫛭
+  - 𫷷
+  - 𬮱
+  - 𬊤
+  - 𬴃
+  - 𫘨
+  - 𬪩
+  - 𬒔
+  - 𬨎
+  - 𫐓
+  - 𫫇
+  - 𫓹
+  - 𬭚
+  - 𬭛
+  - 𬕂
+  - 𬶋
+  - 𬶍
+  - 𫔶
+  - 𫌀
+  - 𫖳
+  - 𫘪
+  - 𫘬
+  - 𫞩
+  - 𪤗
+  - 𬸘
+  - 𬒗
+  - 𫚖
+  - 𬭤
+  - 𫚕
+  - 𬶐
+  - 𬶏
+  - 𬸚
+  - 𬤝
+  - 𬙂
+  - 𬭩
+  - 𬸣
+  - 𫍽
+  - 𬴊
+  - 𬞟
+  - 𫟦
+  - 𬺈
+  - 𫠜
+  - 𪩘
+  - 𬭬
+  - 𬭯
+  - 𫗴
+  - 𬸦
+  - 𫄷
+  - 𬭳
+  - 𬭶
+  - 𫔍
+  - 𬭸
+  - 𬭼
+  - 𫔎
+  - 𬸪
+  - 𬶟
+  - 𬶠
+  - 𬶨
+  - 𫄸
+  - 𬟁
+  - 𬙊
+  - 𬶭
+  - 𬶮
+  - 𬙋
+  - 𬺓
+  - 𫚭
+  - 廠
+  - 蔔
+  - 兒
+  - 幾
+  - 幹
+  - 虧
+  - 纔
+  - 與
+  - 萬
+  - 韆
+  - 億
+  - 個
+  - 廣
+  - 門
+  - 義
+  - 衛
+  - 飛
+  - 習
+  - 馬
+  - 鄉
+  - 豐
+  - 開
+  - 無
+  - 雲
+  - 專
+  - 藝
+  - 廳
+  - 區
+  - 歷
+  - 曆
+  - 車
+  - 貝
+  - 岡
+  - 見
+  - 氣
+  - 長
+  - 僕
+  - 幣
+  - 僅
+  - 從
+  - 侖
+  - 倉
+  - 風
+  - 烏
+  - 鳳
+  - 爲
+  - 鬥
+  - 憶
+  - 計
+  - 訂
+  - 認
+  - 譏
+  - 醜
+  - 隊
+  - 辦
+  - 鄧
+  - 勸
+  - 雙
+  - 書
+  - 擊
+  - 撲
+  - 節
+  - 術
+  - 厲
+  - 龍
+  - 滅
+  - 軋
+  - 東
+  - 盧
+  - 業
+  - 舊
+  - 帥
+  - 歸
+  - 葉
+  - 電
+  - 號
+  - 衹
+  - 隻
+  - 嘰
+  - 嘆
+  - 們
+  - 儀
+  - 叢
+  - 爾
+  - 樂
+  - 處
+  - 鼕
+  - 鳥
+  - 務
+  - 飢
+  - 饑
+  - 馮
+  - 閃
+  - 蘭
+  - 匯
+  - 彙
+  - 頭
+  - 漢
+  - 寧
+  - 討
+  - 寫
+  - 讓
+  - 禮
+  - 訓
+  - 議
+  - 訊
+  - 記
+  - 齣
+  - 遼
+  - 邊
+  - 發
+  - 髮
+  - 聖
+  - 對
+  - 臺
+  - 颱
+  - 檯
+  - 糾
+  - 絲
+  - 動
+  - 鞏
+  - 執
+  - 擴
+  - 掃
+  - 場
+  - 揚
+  - 亞
+  - 樸
+  - 機
+  - 權
+  - 過
+  - 協
+  - 壓
+  - 厭
+  - 頁
+  - 誇
+  - 奪
+  - 達
+  - 夾
+  - 軌
+  - 堯
+  - 劃
+  - 邁
+  - 畢
+  - 貞
+  - 師
+  - 塵
+  - 當
+  - 噹
+  - 籲
+  - 嚇
+  - 蟲
+  - 麯
+  - 團
+  - 糰
+  - 嗎
+  - 嶼
+  - 歲
+  - 迴
+  - 豈
+  - 則
+  - 剛
+  - 網
+  - 硃
+  - 遷
+  - 喬
+  - 偉
+  - 傳
+  - 優
+  - 傷
+  - 價
+  - 倫
+  - 華
+  - 僞
+  - 嚮
+  - 後
+  - 會
+  - 殺
+  - 閤
+  - 衆
+  - 爺
+  - 傘
+  - 創
+  - 雜
+  - 負
+  - 壯
+  - 衝
+  - 妝
+  - 莊
+  - 慶
+  - 劉
+  - 齊
+  - 産
+  - 閉
+  - 問
+  - 闖
+  - 關
+  - 燈
+  - 湯
+  - 興
+  - 講
+  - 諱
+  - 軍
+  - 訝
+  - 許
+  - 訛
+  - 論
+  - 訟
+  - 農
+  - 諷
+  - 設
+  - 訪
+  - 訣
+  - 尋
+  - 盡
+  - 儘
+  - 導
+  - 孫
+  - 陣
+  - 陽
+  - 階
+  - 陰
+  - 婦
+  - 媽
+  - 戲
+  - 觀
+  - 歡
+  - 買
+  - 紅
+  - 馱
+  - 纖
+  - 縴
+  - 馴
+  - 約
+  - 級
+  - 紀
+  - 馳
+  - 紉
+  - 壽
+  - 麥
+  - 瑪
+  - 進
+  - 遠
+  - 違
+  - 韌
+  - 運
+  - 撫
+  - 壇
+  - 罎
+  - 壞
+  - 摳
+  - 擾
+  - 貢
+  - 垻
+  - 壩
+  - 摺
+  - 掄
+  - 搶
+  - 墳
+  - 護
+  - 殻
+  - 塊
+  - 聲
+  - 報
+  - 擬
+  - 蕪
+  - 葦
+  - 蒼
+  - 嚴
+  - 蘆
+  - 勞
+  - 蘇
+  - 囌
+  - 極
+  - 楊
+  - 兩
+  - 麗
+  - 醫
+  - 勵
+  - 還
+  - 殲
+  - 來
+  - 連
+  - 軒
+  - 鹵
+  - 滷
+  - 堅
+  - 時
+  - 縣
+  - 裏
+  - 嘔
+  - 園
+  - 曠
+  - 圍
+  - 噸
+  - 郵
+  - 睏
+  - 員
+  - 聽
+  - 嗆
+  - 嗚
+  - 彆
+  - 嶇
+  - 崗
+  - 帳
+  - 財
+  - 針
+  - 釘
+  - 亂
+  - 體
+  - 傭
+  - 徹
+  - 餘
+  - 穀
+  - 鄰
+  - 腸
+  - 龜
+  - 猶
+  - 狽
+  - 條
+  - 島
+  - 飯
+  - 飲
+  - 係
+  - 繫
+  - 凍
+  - 狀
+  - 畝
+  - 庫
+  - 療
+  - 應
+  - 這
+  - 廬
+  - 閏
+  - 閑
+  - 間
+  - 悶
+  - 竈
+  - 燦
+  - 瀝
+  - 淪
+  - 滄
+  - 溝
+  - 滬
+  - 瀋
+  - 懷
+  - 憂
+  - 窮
+  - 證
+  - 啓
+  - 評
+  - 補
+  - 識
+  - 詐
+  - 訴
+  - 診
+  - 詞
+  - 譯
+  - 靈
+  - 層
+  - 遲
+  - 張
+  - 際
+  - 陸
+  - 陳
+  - 墜
+  - 勁
+  - 鷄
+  - 緯
+  - 驅
+  - 純
+  - 紗
+  - 綱
+  - 納
+  - 駁
+  - 縱
+  - 紛
+  - 紙
+  - 紋
+  - 紡
+  - 驢
+  - 紐
+  - 環
+  - 責
+  - 現
+  - 錶
+  - 規
+  - 攏
+  - 揀
+  - 擔
+  - 頂
+  - 擁
+  - 勢
+  - 攔
+  - 擰
+  - 撥
+  - 擇
+  - 蘋
+  - 範
+  - 莖
+  - 樞
+  - 櫃
+  - 闆
+  - 鬆
+  - 槍
+  - 楓
+  - 構
+  - 喪
+  - 畫
+  - 棗
+  - 賣
+  - 鬱
+  - 礬
+  - 礦
+  - 碼
+  - 厠
+  - 奮
+  - 態
+  - 歐
+  - 毆
+  - 壟
+  - 轟
+  - 頃
+  - 轉
+  - 斬
+  - 輪
+  - 軟
+  - 齒
+  - 虜
+  - 腎
+  - 賢
+  - 國
+  - 暢
+  - 嚨
+  - 鳴
+  - 羅
+  - 幟
+  - 嶺
+  - 凱
+  - 敗
+  - 賬
+  - 販
+  - 貶
+  - 購
+  - 貯
+  - 圖
+  - 釣
+  - 製
+  - 颳
+  - 俠
+  - 僥
+  - 偵
+  - 側
+  - 憑
+  - 僑
+  - 貨
+  - 質
+  - 徑
+  - 捨
+  - 覓
+  - 貪
+  - 貧
+  - 膚
+  - 腫
+  - 脹
+  - 骯
+  - 脅
+  - 魚
+  - 獰
+  - 備
+  - 飾
+  - 飽
+  - 飼
+  - 變
+  - 龐
+  - 廟
+  - 瘧
+  - 劑
+  - 廢
+  - 閘
+  - 鬧
+  - 鄭
+  - 捲
+  - 單
+  - 爐
+  - 淺
+  - 濘
+  - 瀉
+  - 潑
+  - 澤
+  - 憐
+  - 學
+  - 寶
+  - 寵
+  - 審
+  - 簾
+  - 實
+  - 試
+  - 詩
+  - 誠
+  - 襯
+  - 視
+  - 話
+  - 誕
+  - 詭
+  - 詢
+  - 該
+  - 詳
+  - 肅
+  - 録
+  - 隸
+  - 彌
+  - 瀰
+  - 陝
+  - 駕
+  - 參
+  - 艱
+  - 綫
+  - 練
+  - 組
+  - 紳
+  - 細
+  - 駛
+  - 織
+  - 駒
+  - 終
+  - 駐
+  - 絆
+  - 駝
+  - 紹
+  - 繹
+  - 經
+  - 貫
+  - 貳
+  - 幫
+  - 項
+  - 挾
+  - 撓
+  - 趙
+  - 擋
+  - 墊
+  - 擠
+  - 揮
+  - 薦
+  - 帶
+  - 繭
+  - 蕩
+  - 榮
+  - 葷
+  - 熒
+  - 鬍
+  - 蔭
+  - 藥
+  - 標
+  - 棧
+  - 棟
+  - 欄
+  - 檸
+  - 樹
+  - 鹹
+  - 磚
+  - 硯
+  - 麵
+  - 牽
+  - 鷗
+  - 殘
+  - 軸
+  - 輕
+  - 鴉
+  - 戰
+  - 點
+  - 臨
+  - 覽
+  - 竪
+  - 嘗
+  - 啞
+  - 顯
+  - 貴
+  - 蝦
+  - 蟻
+  - 螞
+  - 雖
+  - 駡
+  - 勛
+  - 嘩
+  - 響
+  - 喲
+  - 峽
+  - 罰
+  - 賤
+  - 貼
+  - 貽
+  - 鈣
+  - 鈍
+  - 鈔
+  - 鍾
+  - 鐘
+  - 鋼
+  - 鈉
+  - 鑰
+  - 欽
+  - 鈞
+  - 鈎
+  - 鈕
+  - 氈
+  - 氫
+  - 選
+  - 適
+  - 種
+  - 鞦
+  - 復
+  - 複
+  - 倆
+  - 貸
+  - 順
+  - 儉
+  - 須
+  - 鬚
+  - 劍
+  - 朧
+  - 膽
+  - 勝
+  - 狹
+  - 獅
+  - 獨
+  - 獄
+  - 貿
+  - 餌
+  - 饒
+  - 蝕
+  - 餃
+  - 餅
+  - 巒
+  - 彎
+  - 將
+  - 奬
+  - 瘡
+  - 瘋
+  - 親
+  - 閨
+  - 聞
+  - 閩
+  - 閥
+  - 閣
+  - 養
+  - 薑
+  - 類
+  - 婁
+  - 總
+  - 煉
+  - 爍
+  - 爛
+  - 窪
+  - 潔
+  - 灑
+  - 澆
+  - 濁
+  - 測
+  - 瀏
+  - 濟
+  - 渾
+  - 濃
+  - 惱
+  - 舉
+  - 覺
+  - 憲
+  - 竊
+  - 誡
+  - 誣
+  - 語
+  - 襖
+  - 誤
+  - 誘
+  - 誨
+  - 説
+  - 誦
+  - 墾
+  - 晝
+  - 費
+  - 遜
+  - 隕
+  - 險
+  - 嬌
+  - 賀
+  - 壘
+  - 綁
+  - 絨
+  - 結
+  - 繞
+  - 驕
+  - 繪
+  - 給
+  - 絢
+  - 駱
+  - 絡
+  - 絶
+  - 絞
+  - 駭
+  - 統
+  - 艷
+  - 蠶
+  - 頑
+  - 盞
+  - 撈
+  - 載
+  - 趕
+  - 鹽
+  - 損
+  - 撿
+  - 摯
+  - 剝
+  - 熱
+  - 搗
+  - 壺
+  - 聶
+  - 萊
+  - 蓮
+  - 獲
+  - 穫
+  - 惡
+  - 噁
+  - 瑩
+  - 鶯
+  - 檔
+  - 橋
+  - 樺
+  - 樁
+  - 樣
+  - 賈
+  - 礫
+  - 礎
+  - 顧
+  - 轎
+  - 較
+  - 頓
+  - 斃
+  - 緻
+  - 慮
+  - 監
+  - 緊
+  - 黨
+  - 曬
+  - 曉
+  - 嘮
+  - 鴨
+  - 暈
+  - 鴦
+  - 罷
+  - 圓
+  - 賊
+  - 賄
+  - 賂
+  - 贜
+  - 錢
+  - 鉗
+  - 鑽
+  - 鉀
+  - 鐵
+  - 鈴
+  - 鉛
+  - 犧
+  - 敵
+  - 積
+  - 稱
+  - 筆
+  - 債
+  - 傾
+  - 賃
+  - 艦
+  - 艙
+  - 聳
+  - 愛
+  - 頒
+  - 頌
+  - 臟
+  - 髒
+  - 臍
+  - 膠
+  - 腦
+  - 膿
+  - 鴕
+  - 鴛
+  - 皺
+  - 餓
+  - 餒
+  - 戀
+  - 槳
+  - 漿
+  - 準
+  - 癥
+  - 齋
+  - 離
+  - 資
+  - 競
+  - 閲
+  - 煩
+  - 燒
+  - 燭
+  - 遞
+  - 濤
+  - 澇
+  - 渦
+  - 塗
+  - 滌
+  - 潤
+  - 澗
+  - 漲
+  - 燙
+  - 澀
+  - 憫
+  - 寬
+  - 傢
+  - 賓
+  - 竅
+  - 請
+  - 諸
+  - 諾
+  - 讀
+  - 誹
+  - 襪
+  - 課
+  - 誰
+  - 調
+  - 諒
+  - 諄
+  - 談
+  - 誼
+  - 懇
+  - 劇
+  - 難
+  - 預
+  - 絹
+  - 綉
+  - 驗
+  - 繼
+  - 駿
+  - 瑣
+  - 擲
+  - 據
+  - 摻
+  - 職
+  - 蘿
+  - 螢
+  - 營
+  - 蕭
+  - 薩
+  - 夢
+  - 檢
+  - 醖
+  - 碩
+  - 聾
+  - 襲
+  - 輔
+  - 輛
+  - 顱
+  - 懸
+  - 躍
+  - 纍
+  - 囉
+  - 嘯
+  - 嶄
+  - 邏
+  - 嬰
+  - 銬
+  - 鐺
+  - 鋁
+  - 銅
+  - 銘
+  - 鏟
+  - 銀
+  - 矯
+  - 穢
+  - 籠
+  - 償
+  - 軀
+  - 釁
+  - 銜
+  - 盤
+  - 鴿
+  - 斂
+  - 領
+  - 臉
+  - 獵
+  - 餡
+  - 館
+  - 癢
+  - 鏇
+  - 閻
+  - 闡
+  - 蓋
+  - 斷
+  - 獸
+  - 鴻
+  - 漸
+  - 淵
+  - 漁
+  - 澱
+  - 滲
+  - 慚
+  - 懼
+  - 驚
+  - 慘
+  - 慣
+  - 謀
+  - 諜
+  - 謊
+  - 諧
+  - 禱
+  - 禍
+  - 謂
+  - 諺
+  - 謎
+  - 彈
+  - 墮
+  - 隨
+  - 隱
+  - 嬸
+  - 頗
+  - 頸
+  - 績
+  - 緒
+  - 續
+  - 騎
+  - 綽
+  - 繩
+  - 維
+  - 綿
+  - 綳
+  - 綢
+  - 綜
+  - 綻
+  - 緑
+  - 綴
+  - 瓊
+  - 趨
+  - 攬
+  - 攙
+  - 擱
+  - 摟
+  - 攪
+  - 聯
+  - 蔣
+  - 韓
+  - 橢
+  - 確
+  - 頰
+  - 靂
+  - 暫
+  - 翹
+  - 輩
+  - 鑿
+  - 輝
+  - 賞
+  - 睞
+  - 噴
+  - 疇
+  - 踐
+  - 遺
+  - 鵑
+  - 賦
+  - 賭
+  - 贖
+  - 賜
+  - 賠
+  - 鑄
+  - 鋪
+  - 鏈
+  - 銷
+  - 鎖
+  - 鋤
+  - 鍋
+  - 銹
+  - 鋒
+  - 鋅
+  - 鋭
+  - 鵝
+  - 築
+  - 篩
+  - 儲
+  - 懲
+  - 禦
+  - 釋
+  - 臘
+  - 魯
+  - 憊
+  - 饋
+  - 饞
+  - 裝
+  - 蠻
+  - 闊
+  - 糞
+  - 滯
+  - 濕
+  - 潰
+  - 濺
+  - 灣
+  - 憤
+  - 竄
+  - 窩
+  - 褲
+  - 禪
+  - 謝
+  - 謡
+  - 謗
+  - 謙
+  - 屬
+  - 屢
+  - 緬
+  - 纜
+  - 緝
+  - 緞
+  - 緩
+  - 締
+  - 縷
+  - 騙
+  - 編
+  - 騷
+  - 緣
+  - 鵡
+  - 攝
+  - 擺
+  - 襬
+  - 攤
+  - 鵲
+  - 藍
+  - 濛
+  - 懞
+  - 矇
+  - 獻
+  - 欖
+  - 樓
+  - 賴
+  - 礙
+  - 尷
+  - 霧
+  - 輻
+  - 輯
+  - 輸
+  - 頻
+  - 齡
+  - 鑒
+  - 蹺
+  - 蝸
+  - 錯
+  - 錨
+  - 錫
+  - 鑼
+  - 錘
+  - 錐
+  - 錦
+  - 鍵
+  - 鋸
+  - 錳
+  - 辭
+  - 頽
+  - 籌
+  - 簽
+  - 籤
+  - 簡
+  - 膩
+  - 鵬
+  - 騰
+  - 鮑
+  - 穎
+  - 觸
+  - 雛
+  - 饃
+  - 餾
+  - 醬
+  - 謄
+  - 糧
+  - 數
+  - 滿
+  - 濾
+  - 濫
+  - 灕
+  - 濱
+  - 灘
+  - 譽
+  - 窺
+  - 寢
+  - 謹
+  - 謬
+  - 闢
+  - 縛
+  - 縫
+  - 纏
+  - 繽
+  - 贅
+  - 墻
+  - 衊
+  - 藹
+  - 檻
+  - 釀
+  - 願
+  - 轄
+  - 輾
+  - 顆
+  - 踴
+  - 蠟
+  - 蠅
+  - 蟬
+  - 賺
+  - 鍬
+  - 鍛
+  - 鍍
+  - 穩
+  - 籮
+  - 簫
+  - 輿
+  - 鮮
+  - 饅
+  - 瀟
+  - 賽
+  - 譚
+  - 譜
+  - 騾
+  - 縮
+  - 攆
+  - 聰
+  - 藴
+  - 櫻
+  - 飄
+  - 黴
+  - 瞞
+  - 題
+  - 囑
+  - 鎮
+  - 鎬
+  - 鎊
+  - 簍
+  - 鯉
+  - 鯽
+  - 癟
+  - 癱
+  - 顔
+  - 鯊
+  - 瀾
+  - 額
+  - 譴
+  - 鶴
+  - 繚
+  - 顛
+  - 轍
+  - 鸚
+  - 贈
+  - 鏡
+  - 贊
+  - 籃
+  - 籬
+  - 鯨
+  - 癮
+  - 辯
+  - 瀕
+  - 懶
+  - 繮
+  - 繳
+  - 矚
+  - 贍
+  - 鰐
+  - 辮
+  - 贏
+  - 驟
+  - 囂
+  - 鐮
+  - 鰭
+  - 鷹
+  - 巔
+  - 顫
+  - 癬
+  - 鱉
+  - 鬢
+  - 鱗
+  - 躪
+  - 贛
+  - 鑲
+  - 韋
+  - 閂
+  - 訃
+  - 勱
+  - 芻
+  - 鄺
+  - 訐
+  - 訌
+  - 訕
+  - 訖
+  - 馭
+  - 璣
+  - 壙
+  - 捫
+  - 薌
+  - 厙
+  - 釔
+  - 傴
+  - 倀
+  - 傖
+  - 獷
+  - 獁
+  - 鳬
+  - 鄔
+  - 餳
+  - 懺
+  - 謳
+  - 詎
+  - 訥
+  - 紆
+  - 紂
+  - 紇
+  - 紈
+  - 璵
+  - 摶
+  - 塢
+  - 㩳
+  - 蕓
+  - 藶
+  - 莧
+  - 萇
+  - 蓯
+  - 磯
+  - 奩
+  - 歟
+  - 軔
+  - 鄴
+  - 嘸
+  - 囈
+  - 嚦
+  - 暘
+  - 唄
+  - 幃
+  - 峴
+  - 嵐
+  - 圇
+  - 釗
+  - 釙
+  - 釕
+  - 僉
+  - 鳩
+  - 鄒
+  - 飩
+  - 餼
+  - 飪
+  - 飫
+  - 飭
+  - 廡
+  - 癤
+  - 闈
+  - 閎
+  - 閔
+  - 煬
+  - 灃
+  - 漚
+  - 渢
+  - 潙
+  - 憮
+  - 慪
+  - 愾
+  - 悵
+  - 愴
+  - 詁
+  - 訶
+  - 詛
+  - 詆
+  - 謅
+  - 詔
+  - 詒
+  - 隴
+  - 陘
+  - 嫵
+  - 嫗
+  - 嬀
+  - 剄
+  - 紜
+  - 紕
+  - 紝
+  - 綸
+  - 紓
+  - 瑋
+  - 匭
+  - 壚
+  - 擓
+  - 蘢
+  - 蔦
+  - 塋
+  - 煢
+  - 櫪
+  - 梘
+  - 棖
+  - 樅
+  - 碭
+  - 甌
+  - 郟
+  - 軛
+  - 鳶
+  - 曇
+  - 蟣
+  - 黽
+  - 嚀
+  - 噝
+  - 巋
+  - 劌
+  - 剴
+  - 嶧
+  - 釷
+  - 釺
+  - 釧
+  - 釩
+  - 釹
+  - 釵
+  - 儈
+  - 儕
+  - 儂
+  - 劊
+  - 慫
+  - 糴
+  - 戧
+  - 膞
+  - 邇
+  - 梟
+  - 餞
+  - 飴
+  - 癘
+  - 瘍
+  - 煒
+  - 熰
+  - 熗
+  - 瀧
+  - 瀘
+  - 濼
+  - 涇
+  - 㥮
+  - 懌
+  - 誆
+  - 誄
+  - 詿
+  - 詰
+  - 詼
+  - 鄆
+  - 禕
+  - 誅
+  - 詵
+  - 詬
+  - 詮
+  - 詣
+  - 諍
+  - 詫
+  - 諢
+  - 詡
+  - 駑
+  - 紺
+  - 紲
+  - 紱
+  - 駟
+  - 駙
+  - 縐
+  - 絀
+  - 驛
+  - 駘
+  - 瓏
+  - 頇
+  - 埡
+  - 撾
+  - 撻
+  - 賁
+  - 壋
+  - 撏
+  - 莢
+  - 貰
+  - 蓽
+  - 蕎
+  - 薈
+  - 薺
+  - 堊
+  - 滎
+  - 犖
+  - 蕁
+  - 藎
+  - 蓀
+  - 蕒
+  - 葤
+  - 櫛
+  - 櫳
+  - 櫨
+  - 櫟
+  - 檉
+  - 酈
+  - 硨
+  - 碸
+  - 殤
+  - 軲
+  - 軻
+  - 轤
+  - 軼
+  - 軫
+  - 蠆
+  - 覘
+  - 瞘
+  - 嘵
+  - 嗶
+  - 噦
+  - 剮
+  - 鄖
+  - 噲
+  - 噥
+  - 嶢
+  - 幀
+  - 嶠
+  - 貺
+  - 鈈
+  - 鈦
+  - 鋇
+  - 鈑
+  - 鈐
+  - 鎢
+  - 鈁
+  - 鈀
+  - 篤
+  - 儔
+  - 儼
+  - 儷
+  - 腖
+  - 臚
+  - 脛
+  - 鴇
+  - 獪
+  - 颮
+  - 猻
+  - 餉
+  - 餄
+  - 餎
+  - 孿
+  - 孌
+  - 癧
+  - 瘲
+  - 颯
+  - 闥
+  - 閭
+  - 闓
+  - 閡
+  - 熾
+  - 烴
+  - 浹
+  - 澮
+  - 滸
+  - 潯
+  - 濜
+  - 慟
+  - 懨
+  - 愷
+  - 惻
+  - 惲
+  - 誚
+  - 禰
+  - 誥
+  - 誑
+  - 鴆
+  - 婭
+  - 嬈
+  - 懟
+  - 絝
+  - 驍
+  - 驊
+  - 絎
+  - 絳
+  - 駢
+  - 頊
+  - 璫
+  - 琿
+  - 塒
+  - 塤
+  - 堝
+  - 贄
+  - 蒔
+  - 萵
+  - 蕕
+  - 鴣
+  - 蒓
+  - 橈
+  - 楨
+  - 榿
+  - 檜
+  - 邐
+  - 礪
+  - 礱
+  - 軾
+  - 輊
+  - 輅
+  - 鶇
+  - 躉
+  - 齔
+  - 鸕
+  - 矓
+  - 嘜
+  - 鴞
+  - 蜆
+  - 嗩
+  - 嶗
+  - 崍
+  - 覬
+  - 賅
+  - 鈺
+  - 鉦
+  - 鈷
+  - 鉢
+  - 鈸
+  - 鉞
+  - 鉭
+  - 鉬
+  - 鈿
+  - 鈾
+  - 鉑
+  - 鑠
+  - 鉚
+  - 鈰
+  - 鉉
+  - 鉈
+  - 鉍
+  - 鈮
+  - 鈹
+  - 鏺
+  - 鐸
+  - 氬
+  - 筧
+  - 頎
+  - 徠
+  - 膾
+  - 鴟
+  - 璽
+  - 鴝
+  - 獫
+  - 裊
+  - 餑
+  - 欒
+  - 攣
+  - 癰
+  - 痙
+  - 頏
+  - 閫
+  - 鬮
+  - 誾
+  - 閬
+  - 鄲
+  - 燁
+  - 燴
+  - 燼
+  - 淶
+  - 漣
+  - 潿
+  - 慳
+  - 諏
+  - 諑
+  - 禎
+  - 諉
+  - 諛
+  - 諗
+  - 諂
+  - 誶
+  - 媧
+  - 嫻
+  - 綆
+  - 驪
+  - 綃
+  - 騁
+  - 綏
+  - 縧
+  - 綈
+  - 駸
+  - 鷥
+  - 燾
+  - 璉
+  - 麩
+  - 擄
+  - 摑
+  - 鷙
+  - 撣
+  - 慤
+  - 摜
+  - 縈
+  - 槤
+  - 覡
+  - 欞
+  - 嗇
+  - 匱
+  - 硤
+  - 磽
+  - 鴯
+  - 龔
+  - 殞
+  - 殮
+  - 賚
+  - 輒
+  - 塹
+  - 嘖
+  - 囀
+  - 嚙
+  - 蹌
+  - 蠣
+  - 蠱
+  - 蟶
+  - 幘
+  - 幗
+  - 賕
+  - 賑
+  - 賒
+  - 銠
+  - 鉺
+  - 鋏
+  - 鐃
+  - 銦
+  - 鎧
+  - 鍘
+  - 銖
+  - 銑
+  - 鋌
+  - 鏵
+  - 銓
+  - 鎩
+  - 鉿
+  - 銚
+  - 鉻
+  - 錚
+  - 銫
+  - 鉸
+  - 銥
+  - 銃
+  - 銨
+  - 銣
+  - 鴰
+  - 穠
+  - 箋
+  - 籩
+  - 僨
+  - 僂
+  - 皚
+  - 鴴
+  - 艫
+  - 龕
+  - 玀
+  - 獼
+  - 餜
+  - 餛
+  - 鸞
+  - 闍
+  - 閾
+  - 閹
+  - 閶
+  - 鬩
+  - 閽
+  - 閼
+  - 羥
+  - 糲
+  - 燜
+  - 漬
+  - 瀆
+  - 澠
+  - 愜
+  - 憚
+  - 諶
+  - 諫
+  - 皸
+  - 謔
+  - 襠
+  - 謁
+  - 諤
+  - 諭
+  - 諼
+  - 讒
+  - 諳
+  - 諦
+  - 諞
+  - 糶
+  - 嬋
+  - 綾
+  - 騏
+  - 綺
+  - 緋
+  - 緔
+  - 騍
+  - 緄
+  - 騅
+  - 綬
+  - 綹
+  - 綣
+  - 綰
+  - 驂
+  - 緇
+  - 靚
+  - 輦
+  - 黿
+  - 頡
+  - 撳
+  - 蟄
+  - 壪
+  - 蔞
+  - 櫝
+  - 欏
+  - 賫
+  - 鵓
+  - 鸝
+  - 殫
+  - 輥
+  - 輞
+  - 槧
+  - 輟
+  - 輜
+  - 瞼
+  - 躒
+  - 蛺
+  - 蟯
+  - 螄
+  - 蠐
+  - 嘍
+  - 嶸
+  - 嶁
+  - 賧
+  - 鋙
+  - 錸
+  - 鏗
+  - 鋥
+  - 鋰
+  - 鋯
+  - 鋨
+  - 銼
+  - 鐧
+  - 銻
+  - 鋃
+  - 鋦
+  - 錒
+  - 犢
+  - 鵠
+  - 篳
+  - 牘
+  - 儻
+  - 儐
+  - 儺
+  - 嬃
+  - 頜
+  - 鵒
+  - 魷
+  - 魨
+  - 魴
+  - 潁
+  - 颶
+  - 觴
+  - 熲
+  - 餷
+  - 餿
+  - 褻
+  - 臠
+  - 癆
+  - 癇
+  - 賡
+  - 頦
+  - 鷳
+  - 闌
+  - 闃
+  - 闋
+  - 鵜
+  - 憒
+  - 嚳
+  - 謨
+  - 褳
+  - 襇
+  - 讜
+  - 謖
+  - 謚
+  - 謐
+  - 騭
+  - 巰
+  - 翬
+  - 騖
+  - 緙
+  - 緗
+  - 緘
+  - 緹
+  - 緲
+  - 緦
+  - 緱
+  - 縋
+  - 緡
+  - 饗
+  - 耮
+  - 驁
+  - 韞
+  - 攄
+  - 擯
+  - 轂
+  - 驀
+  - 鶓
+  - 薊
+  - 蘺
+  - 鎣
+  - 頤
+  - 櫚
+  - 櫸
+  - 磧
+  - 磣
+  - 鵪
+  - 輳
+  - 齟
+  - 齙
+  - 韙
+  - 囁
+  - 躂
+  - 蹕
+  - 躚
+  - 躋
+  - 噯
+  - 鍺
+  - 錛
+  - 錡
+  - 鍀
+  - 錁
+  - 錕
+  - 錮
+  - 鍁
+  - 錈
+  - 錠
+  - 錙
+  - 覦
+  - 頷
+  - 鮁
+  - 鮃
+  - 鮎
+  - 鱸
+  - 穌
+  - 鮒
+  - 鮐
+  - 鵮
+  - 颼
+  - 饈
+  - 鶉
+  - 瘮
+  - 闔
+  - 闐
+  - 闕
+  - 灧
+  - 瀅
+  - 潷
+  - 灤
+  - 澦
+  - 懾
+  - 鱟
+  - 騫
+  - 竇
+  - 謾
+  - 謫
+  - 嬡
+  - 嬪
+  - 縉
+  - 縝
+  - 縟
+  - 轡
+  - 騮
+  - 縞
+  - 縭
+  - 縊
+  - 縑
+  - 騸
+  - 覯
+  - 韜
+  - 靉
+  - 攖
+  - 薔
+  - 藺
+  - 鶘
+  - 檳
+  - 櫧
+  - 釅
+  - 殯
+  - 霽
+  - 轅
+  - 齜
+  - 齦
+  - 瞜
+  - 曖
+  - 躊
+  - 蟈
+  - 鶚
+  - 嚶
+  - 羆
+  - 賻
+  - 罌
+  - 鶻
+  - 鍥
+  - 鍇
+  - 鍶
+  - 鍔
+  - 鍤
+  - 鏘
+  - 鎂
+  - 鏤
+  - 簀
+  - 篋
+  - 簞
+  - 籙
+  - 臏
+  - 鮭
+  - 鮪
+  - 鱭
+  - 鮫
+  - 鱘
+  - 饉
+  - 鑾
+  - 瘻
+  - 闞
+  - 鮝
+  - 糝
+  - 鷀
+  - 瀲
+  - 濰
+  - 譖
+  - 褸
+  - 譙
+  - 讕
+  - 譎
+  - 鶥
+  - 嬙
+  - 鶩
+  - 驃
+  - 縹
+  - 縵
+  - 縲
+  - 纓
+  - 驄
+  - 繆
+  - 繅
+  - 耬
+  - 瓔
+  - 擷
+  - 擼
+  - 攛
+  - 聵
+  - 覲
+  - 韃
+  - 鞽
+  - 蘄
+  - 賾
+  - 檣
+  - 靨
+  - 魘
+  - 饜
+  - 轆
+  - 齬
+  - 齪
+  - 覷
+  - 顒
+  - 躓
+  - 躑
+  - 蠑
+  - 螻
+  - 顎
+  - 嚕
+  - 顓
+  - 鑷
+  - 鎘
+  - 鎸
+  - 鎳
+  - 鎦
+  - 鎰
+  - 鎵
+  - 鑌
+  - 簣
+  - 鷂
+  - 鯁
+  - 鱺
+  - 鰱
+  - 鰹
+  - 鰣
+  - 鯀
+  - 鯇
+  - 觶
+  - 饊
+  - 饌
+  - 齏
+  - 讞
+  - 襤
+  - 譫
+  - 屨
+  - 纈
+  - 繕
+  - 繒
+  - 驏
+  - 擻
+  - 顳
+  - 顢
+  - 藪
+  - 櫓
+  - 櫞
+  - 贋
+  - 飆
+  - 鏨
+  - 轔
+  - 蟎
+  - 鐯
+  - 鏢
+  - 鏜
+  - 鏝
+  - 鏰
+  - 鏞
+  - 鏑
+  - 鏃
+  - 鏐
+  - 氌
+  - 穡
+  - 魎
+  - 鯪
+  - 鯡
+  - 鯤
+  - 鯧
+  - 鯝
+  - 鯢
+  - 鯛
+  - 鯔
+  - 獺
+  - 鷓
+  - 贇
+  - 癭
+  - 斕
+  - 瀨
+  - 顙
+  - 繾
+  - 繰
+  - 繯
+  - 蘚
+  - 鷯
+  - 齲
+  - 齷
+  - 躡
+  - 蹣
+  - 羈
+  - 鐔
+  - 鐝
+  - 鐐
+  - 鐓
+  - 鑭
+  - 鑹
+  - 鏹
+  - 鐙
+  - 籪
+  - 鷦
+  - 鱝
+  - 鰈
+  - 鯷
+  - 鰓
+  - 鰍
+  - 鰉
+  - 鯿
+  - 鷲
+  - 懣
+  - 鷸
+  - 鰲
+  - 韉
+  - 顥
+  - 鷺
+  - 䴉
+  - 髏
+  - 鑊
+  - 鐳
+  - 鐲
+  - 讎
+  - 鰨
+  - 鰥
+  - 鰩
+  - 癩
+  - 攢
+  - 靄
+  - 躥
+  - 髖
+  - 髕
+  - 鑔
+  - 籟
+  - 鰳
+  - 鰾
+  - 鱈
+  - 鰻
+  - 鱅
+  - 讖
+  - 驥
+  - 纘
+  - 瓚
+  - 鼉
+  - 黷
+  - 黲
+  - 鑣
+  - 鑞
+  - 臢
+  - 鱖
+  - 鱔
+  - 鱒
+  - 驤
+  - 顰
+  - 鱧
+  - 癲
+  - 灝
+  - 鸛
+  - 鑱
+  - 趲
+  - 顴
+  - 躦
+  - 饢
+  - 戇
+  - 戔
+  - 訏
+  - 訒
+  - 釓
+  - 俔
+  - 閆
+  - 澫
+  - 訢
+  - 訩
+  - 詝
+  - 紃
+  - 纊
+  - 瑒
+  - 剗
+  - 塸
+  - 壢
+  - 埨
+  - 撝
+  - 蔿
+  - 榪
+  - 軑
+  - 軏
+  - 咼
+  - 㠣
+  - 覎
+  - 㑳
+  - 颺
+  - 閌
+  - 潕
+  - 湋
+  - 澐
+  - 浿
+  - 諓
+  - 禡
+  - 詗
+  - 詘
+  - 詖
+  - 屓
+  - 彄
+  - 紘
+  - 馹
+  - 馼
+  - 紵
+  - 紞
+  - 駃
+  - 紖
+  - 瑲
+  - 薴
+  - 棡
+  - 軝
+  - 暐
+  - 晛
+  - 崬
+  - 釴
+  - 釤
+  - 鍆
+  - 鍚
+  - 鄶
+  - 獮
+  - 飿
+  - 嶨
+  - 詷
+  - 詪
+  - 鄩
+  - 鳲
+  - 隑
+  - 隮
+  - 娙
+  - 逕
+  - 駓
+  - 駔
+  - 駉
+  - 絅
+  - 騶
+  - 䮄
+  - 紼
+  - 紿
+  - 瓅
+  - 韍
+  - 墶
+  - 塏
+  - 薘
+  - 蕘
+  - 蔄
+  - 葒
+  - 鳾
+  - 龑
+  - 軹
+  - 軤
+  - 轢
+  - 軺
+  - 睍
+  - 曨
+  - 噠
+  - 鈃
+  - 鈇
+  - 鉅
+  - 鋹
+  - 釿
+  - 錀
+  - 鈧
+  - 鈥
+  - 鈄
+  - 倈
+  - 艤
+  - 鶬
+  - 颭
+  - 餏
+  - 湞
+  - 溮
+  - 滻
+  - 褘
+  - 絰
+  - 駰
+  - 絪
+  - 駪
+  - 綎
+  - 綖
+  - 驫
+  - 勣
+  - 璕
+  - 𡑍
+  - 䓣
+  - 薟
+  - 藭
+  - 椏
+  - 梜
+  - 頍
+  - 硜
+  - 輄
+  - 輈
+  - 輇
+  - 貲
+  - 嗊
+  - 曄
+  - 暉
+  - 鄳
+  - 幬
+  - 輋
+  - 嶮
+  - 贐
+  - 鉥
+  - 鉕
+  - 鑪
+  - 鉮
+  - 鉊
+  - 鉧
+  - 僤
+  - 鴒
+  - 魛
+  - 餗
+  - 燖
+  - 溳
+  - 礐
+  - 窵
+  - 襏
+  - 駼
+  - 絺
+  - 綌
+  - 騂
+  - 綄
+  - 璡
+  - 墠
+  - 壼
+  - 聹
+  - 蘀
+  - 勩
+  - 罃
+  - 檮
+  - 棶
+  - 厴
+  - 䃮
+  - 磑
+  - 礄
+  - 鴷
+  - 齕
+  - 頔
+  - 廼
+  - 凢
+  - 亾
+  - 枒
+  - 屍
+  - 匃
+  - 匄
+  - 紥
+  - 紮
+  - 疋
+  - 殀
+  - 讐
+  - 觔
+  - 兇
+  - 宂
+  - 㕥
+  - 㠯
+  - 栞
+  - 佈
+  - 佔
+  - 呌
+  - 敂
+  - 冄
+  - 坵
+  - 僊
+  - 怱
+  - 悤
+  - 冊
+  - 夘
+  - 戼
+  - 牠
+  - 妳
+  - 嬭
+  - 摃
+  - 釦
+  - 攷
+  - 託
+  - 衺
+  - 衕
+  - 弔
+  - 喫
+  - 囙
+  - 㠶
+  - 颿
+  - 秊
+  - 倣
+  - 髣
+  - 佀
+  - 朶
+  - 氷
+  - 決
+  - 併
+  - 並
+  - 竝
+  - 汙
+  - 汚
+  - 異
+  - 姦
+  - 廵
+  - 挵
+  - 衖
+  - 搤
+  - 阯
+  - 撦
+  - 埳
+  - 阬
+  - 誌
+  - 㕁
+  - 卻
+  - 刦
+  - 刧
+  - 刼
+  - 芲
+  - 蘤
+  - 桿
+  - 槓
+  - 荳
+  - 獃
+  - 唫
+  - 脗
+  - 皁
+  - 彿
+  - 髴
+  - 疘
+  - 刪
+  - 鉋
+  - 鑤
+  - 況
+  - 牀
+  - 恡
+  - 棄
+  - 洶
+  - 汎
+  - 災
+  - 烖
+  - 菑
+  - 禩
+  - 侷
+  - 跼
+  - 坿
+  - 玅
+  - 姉
+  - 妬
+  - 翫
+  - 搨
+  - 柺
+  - 拕
+  - 牴
+  - 觝
+  - 倖
+  - 抝
+  - 盃
+  - 桮
+  - 傑
+  - 逩
+  - 肎
+  - 菓
+  - 崐
+  - 崑
+  - 呪
+  - 虖
+  - 嘑
+  - 謼
+  - 詠
+  - 㟁
+  - 嵒
+  - 巗
+  - 巖
+  - 雰
+  - 稈
+  - 咊
+  - 嶽
+  - 妷
+  - 姪
+  - 廹
+  - 徃
+  - 餚
+  - 採
+  - 寀
+  - 唸
+  - 週
+  - 昬
+  - 兎
+  - 兔
+  - 亯
+  - 亱
+  - 䘚
+  - 淨
+  - 劵
+  - 匟
+  - 㳒
+  - 灋
+  - 洩
+  - 霑
+  - 淚
+  - 註
+  - 恠
+  - 箒
+  - 屆
+  - 絃
+  - 圅
+  - 旾
+  - 珎
+  - 掛
+  - 垜
+  - 艸
+  - 茘
+  - 査
+  - 栢
+  - 柵
+  - 栁
+  - 桺
+  - 柹
+  - 韮
+  - 揹
+  - 昰
+  - 閧
+  - 鬨
+  - 冐
+  - 暎
+  - 嚥
+  - 倃
+  - 𠴰
+  - 偺
+  - 喒
+  - 齩
+  - 欬
+  - 榘
+  - 㑺
+  - 儁
+  - 敍
+  - 敘
+  - 肧
+  - 脈
+  - 䘑
+  - 衇
+  - 跡
+  - 蹟
+  - 砲
+  - 礮
+  - 薙
+  - 鬀
+  - 恆
+  - 怳
+  - 卹
+  - 䘏
+  - 賉
+  - 婣
+  - 畊
+  - 揑
+  - 綑
+  - 輓
+  - 恥
+  - 躭
+  - 晉
+  - 棲
+  - 覈
+  - 慄
+  - 翄
+  - 脣
+  - 槕
+  - 㨪
+  - 螡
+  - 蟁
+  - 㤙
+  - 陗
+  - 峩
+  - 峯
+  - 乗
+  - 椉
+  - 咲
+  - 筍
+  - 俛
+  - 頫
+  - 勌
+  - 䠶
+  - 躳
+  - 慇
+  - 拏
+  - 㧱
+  - 挐
+  - 脃
+  - 胷
+  - 肐
+  - 貍
+  - 㽞
+  - 畱
+  - 淒
+  - 悽
+  - 蓆
+  - 効
+  - 傚
+  - 涼
+  - 缾
+  - 菸
+  - 煙
+  - 淛
+  - 湧
+  - 誖
+  - 猂
+  - 醼
+  - 讌
+  - 㝠
+  - 寃
+  - 孃
+  - 桒
+  - 毬
+  - 瑠
+  - 璢
+  - 瑯
+  - 㨗
+  - 搥
+  - 搯
+  - 蔆
+  - 惏
+  - 楳
+  - 槑
+  - 捄
+  - 廂
+  - 慽
+  - 慼
+  - 瞇
+  - 埜
+  - 畧
+  - 虵
+  - 稭
+  - 棃
+  - 犂
+  - 迻
+  - 媮
+  - 兠
+  - 舩
+  - 慾
+  - 綵
+  - 腳
+  - 𩓐
+  - 夠
+  - 豬
+  - 貓
+  - 湊
+  - 減
+  - 庻
+  - 蔴
+  - 菴
+  - 朢
+  - 睠
+  - 觕
+  - 麤
+  - 釬
+  - 銲
+  - 痳
+  - 殽
+  - 婬
+  - 滛
+  - 湻
+  - 㴱
+  - 樑
+  - 顇
+  - 㝛
+  - 窰
+  - 窯
+  - 琹
+  - 欵
+  - 墖
+  - 趂
+  - 隄
+  - 愽
+  - 揷
+  - 揫
+  - 煑
+  - 朞
+  - 㪚
+  - 塟
+  - 蔥
+  - 蔕
+  - 稜
+  - 棊
+  - 碁
+  - 椶
+  - 偪
+  - 㕑
+  - 廚
+  - 廈
+  - 鴈
+  - 冣
+  - 㝡
+  - 晳
+  - 鼃
+  - 餧
+  - 餵
+  - 嗁
+  - 諠
+  - 㡌
+  - 賸
+  - 筴
+  - 筞
+  - 筩
+  - 栰
+  - 暠
+  - 皜
+  - 踰
+  - 蝟
+  - 㪟
+  - 燄
+  - 遊
+  - 媿
+  - 嘅
+  - 庽
+  - 窓
+  - 牎
+  - 牕
+  - 窻
+  - 徧
+  - 僱
+  - 帬
+  - 裠
+  - 強
+  - 彊
+  - 疎
+  - 壻
+  - 瓌
+  - 䰟
+  - 皷
+  - 擕
+  - 㩗
+  - 㩦
+  - 攜
+  - 懃
+  - 鞾
+  - 幙
+  - 㮣
+  - 酧
+  - 詶
+  - 醻
+  - 掽
+  - 踫
+  - 㼝
+  - 盌
+  - 磟
+  - 覩
+  - 倸
+  - 㬉
+  - 煗
+  - 煖
+  - 晻
+  - 闇
+  - 炤
+  - 跥
+  - 䗬
+  - 蠭
+  - 寘
+  - 辠
+  - 稺
+  - 穉
+  - 燬
+  - 譭
+  - 瘉
+  - 癒
+  - 顋
+  - 骽
+  - 猨
+  - 蝯
+  - 稟
+  - 痺
+  - 癡
+  - 亷
+  - 㢘
+  - 韻
+  - 泝
+  - 遡
+  - 昚
+  - 躶
+  - 臝
+  - 羣
+  - 㬪
+  - 曡
+  - 疊
+  - 勦
+  - 琍
+  - 瓈
+  - 𤋮
+  - 熈
+  - 牓
+  - 搾
+  - 謌
+  - 堿
+  - 鹻
+  - 鹼
+  - 矁
+  - 燻
+  - 髈
+  - 𤺥
+  - 辢
+  - 旂
+  - 𡚁
+  - 潄
+  - 砦
+  - 詧
+  - 嫰
+  - 櫈
+  - 撐
+  - 墪
+  - 譔
+  - 鞵
+  - 鞌
+  - 蕋
+  - 橤
+  - 蘂
+  - 醕
+  - 譆
+  - 跴
+  - 蹤
+  - 蜨
+  - 蠍
+  - 稾
+  - 殭
+  - 惪
+  - 厀
+  - 襃
+  - 癅
+  - 䊀
+  - 餬
+  - 潛
+  - 癄
+  - 顦
+  - 鷰
+  - 藷
+  - 櫥
+  - 螎
+  - 蹏
+  - 蟇
+  - 譟
+  - 簒
+  - 彫
+  - 琱
+  - 鵰
+  - 餹
+  - 餻
+  - 簷
+  - 粦
+  - 燐
+  - 緐
+  - 幑
+  - 蹧
+  - 粇
+  - 穅
+  - 臋
+  - 籐
+  - 繙
+  - 飜
+  - 孼
+  - 蠏
+  - 燿
+  - 蝡
+  - 稬
+  - 穤
+  - 惷
+  - 覇
+  - 鑵
+  - 戹
+  - 阨
+  - 剳
+  - 帀
+  - 巵
+  - 亙
+  - 佇
+  - 竚
+  - 穽
+  - 岅
+  - 虯
+  - 𦍑
+  - 羗
+  - 啎
+  - 姙
+  - 㘭
+  - 袟
+  - 袠
+  - 逈
+  - 㒺
+  - 犛
+  - 氂
+  - 偘
+  - 甕
+  - 罋
+  - 冺
+  - 姍
+  - 蝨
+  - 琺
+  - 瑇
+  - 尅
+  - 梔
+  - 斮
+  - 斲
+  - 斵
+  - 暱
+  - 毘
+  - 蝱
+  - 吚
+  - 哶
+  - 峝
+  - 粃
+  - 竢
+  - 狥
+  - 秈
+  - 烱
+  - 㳄
+  - 袵
+  - 盇
+  - 涖
+  - 蒞
+  - 碪
+  - 蠔
+  - 唕
+  - 倐
+  - 儵
+  - 雋
+  - 皐
+  - 臯
+  - 衂
+  - 䶊
+  - 臙
+  - 獧
+  - 痾
+  - 皰
+  - 湼
+  - 澣
+  - 濬
+  - 塚
+  - 襢
+  - 娿
+  - 勅
+  - 勑
+  - 戞
+  - 廐
+  - 廄
+  - 眥
+  - 覜
+  - 勗
+  - 啗
+  - 噉
+  - 傯
+  - 挱
+  - 㥫
+  - 惥
+  - 慂
+  - 陻
+  - 蕚
+  - 萲
+  - 蕿
+  - 蘐
+  - 藼
+  - 櫂
+  - 箠
+  - 槨
+  - 啑
+  - 蹠
+  - 蚘
+  - 痐
+  - 蛕
+  - 蜖
+  - 瘖
+  - 遯
+  - 醃
+  - 飱
+  - 冪
+  - 簑
+  - 枏
+  - 柟
+  - 檝
+  - 楥
+  - 矴
+  - 椗
+  - 嘷
+  - 獋
+  - 粺
+  - 䈰
+  - 諐
+  - 齶
+  - 堘
+  - 疿
+  - 雝
+  - 秔
+  - 稉
+  - 槀
+  - 搉
+  - 廝
+  - 叡
+  - 嘠
+  - 蜋
+  - 筯
+  - 篛
+  - 麞
+  - 糉
+  - 緥
+  - 璿
+  - 髥
+  - 臕
+  - 餈
+  - 剹
+  - 橜
+  - 罇
+  - 蜺
+  - 矙
+  - 憇
+  - 翺
+  - 饍
+  - 瞖
+  - 羴
+  - 羶
+  - 爕
+  - 繦
+  - 騌
+  - 鬉
+  - 騣
+  - 蔾
+  - 䠀
+  - 簮
+  - 躕
+  - 蹵
+  - 䝔
+  - 貛
+  - 鼴
+  - 麐
+  - 塡
+  - あ
+  - い
+  - う
+  - え
+  - お
+  - か
+  - き
+  - く
+  - け
+  - こ
+  - さ
+  - し
+  - す
+  - せ
+  - そ
+  - た
+  - ち
+  - つ
+  - て
+  - と
+  - な
+  - に
+  - ぬ
+  - ね
+  - の
+  - は
+  - ひ
+  - ふ
+  - へ
+  - ほ
+  - ま
+  - み
+  - む
+  - め
+  - も
+  - や
+  - ゆ
+  - よ
+  - ら
+  - り
+  - る
+  - れ
+  - ろ
+  - わ
+  - を
+  - ん
+  - が
+  - ぎ
+  - ぐ
+  - げ
+  - ご
+  - ざ
+  - じ
+  - ず
+  - ぜ
+  - ぞ
+  - だ
+  - ぢ
+  - づ
+  - で
+  - ど
+  - ば
+  - び
+  - ぶ
+  - べ
+  - ぼ
+  - ぱ
+  - ぴ
+  - ぷ
+  - ぺ
+  - ぽ
+  - ぁ
+  - ぃ
+  - ぅ
+  - ぇ
+  - ぉ
+  - っ
+  - ゃ
+  - ゅ
+  - ょ
+  - ゎ
+  - ゕ
+  - ゖ
+  - ア
+  - イ
+  - ウ
+  - エ
+  - オ
+  - カ
+  - キ
+  - ク
+  - ケ
+  - コ
+  - サ
+  - シ
+  - ス
+  - セ
+  - ソ
+  - タ
+  - チ
+  - ツ
+  - テ
+  - ト
+  - ナ
+  - ニ
+  - ヌ
+  - ネ
+  - ノ
+  - ハ
+  - ヒ
+  - フ
+  - ヘ
+  - ホ
+  - マ
+  - ミ
+  - ム
+  - メ
+  - モ
+  - ヤ
+  - ユ
+  - ヨ
+  - ラ
+  - リ
+  - ル
+  - レ
+  - ロ
+  - ワ
+  - ヲ
+  - ン
+  - ガ
+  - ギ
+  - グ
+  - ゲ
+  - ゴ
+  - ザ
+  - ジ
+  - ズ
+  - ゼ
+  - ゾ
+  - ダ
+  - ヂ
+  - ヅ
+  - デ
+  - ド
+  - バ
+  - ビ
+  - ブ
+  - ベ
+  - ボ
+  - パ
+  - ピ
+  - プ
+  - ペ
+  - ポ
+  - ァ
+  - ィ
+  - ゥ
+  - ェ
+  - ォ
+  - ッ
+  - ャ
+  - ュ
+  - ョ
+  - ヮ
+  - ヵ
+  - ヶ
+  - ヷ
+  - ヸ
+  - ヹ
+  - ヺ
+  - ・
+  - ー
+  - ヽ
+  - ヾ
+  - ヿ
+  - ｱ
+  - ｲ
+  - ｳ
+  - ｴ
+  - ｵ
+  - ｶ
+  - ｷ
+  - ｸ
+  - ｹ
+  - ｺ
+  - ｻ
+  - ｼ
+  - ｽ
+  - ｾ
+  - ｿ
+  - ﾀ
+  - ﾁ
+  - ﾂ
+  - ﾃ
+  - ﾄ
+  - ﾅ
+  - ﾆ
+  - ﾇ
+  - ﾈ
+  - ﾉ
+  - ﾊ
+  - ﾋ
+  - ﾌ
+  - ﾍ
+  - ﾎ
+  - ﾏ
+  - ﾐ
+  - ﾑ
+  - ﾒ
+  - ﾓ
+  - ﾔ
+  - ﾕ
+  - ﾖ
+  - ﾗ
+  - ﾘ
+  - ﾙ
+  - ﾚ
+  - ﾛ
+  - ﾜ
+  - ｦ
+  - ﾝ
+  - ﾞ
+  - ﾟ
+  - ｧ
+  - ｨ
+  - ｩ
+  - ｪ
+  - ｫ
+  - ｯ
+  - ｬ
+  - ｭ
+  - ｮ
+  - 円
+  - 気
+  - 糸
+  - 絵
+  - 楽
+  - 帰
+  - 戸
+  - 広
+  - 黒
+  - 図
+  - 線
+  - 読
+  - 売
+  - 歩
+  - 毎
+  - 亜
+  - 悪
+  - 圧
+  - 扱
+  - 囲
+  - 為
+  - 壱
+  - 隠
+  - 栄
+  - 営
+  - 駅
+  - 塩
+  - 縁
+  - 艶
+  - 応
+  - 桜
+  - 穏
+  - 仮
+  - 価
+  - 箇
+  - ゑ
+  - ゝ
+  - ゞ
+  - ヰ
+  - ヴ
+  - ㈱
+  - 両
+  - 丼
+  - 丿
+  - 亀
+  - 仏
+  - 伝
+  - 侶
+  - 俤
+  - 値
+  - 倶
+  - 倹
+  - 偐
+  - 偽
+  - 働
+  - 儛
+  - 兌
+  - 児
+  - 冑
+  - 冨
+  - 凞
+  - 処
+  - 凪
+  - 別
+  - 剣
+  - 剤
+  - 剰
+  - 劔
+  - 労
+  - 勧
+  - 勲
+  - 匁
+  - 匂
+  - 匲
+  - 卍
+  - 単
+  - 厳
+  - 収
+  - 呂
+  - 呉
+  - 呑
+  - 呰
+  - 唖
+  - 喚
+  - 喩
+  - 喰
+  - 噛
+  - 噺
+  - 嚢
+  - 囃
+  - 団
+  - 圀
+  - 圏
+  - 堀
+  - 堺
+  - 塀
+  - 塁
+  - 塙
+  - 増
+  - 墺
+  - 壊
+  - 壌
+  - 壷
+  - 変
+  - 奨
+  - 姫
+  - 娯
+  - 嫐
+  - 嬢
+  - 嬾
+  - 孁
+  - 宍
+  - 実
+  - 宮
+  - 寔
+  - 寛
+  - 対
+  - 専
+  - 尭
+  - 峠
+  - 崋
+  - 嶋
+  - 巀
+  - 巌
+  - 巣
+  - 巻
+  - 帯
+  - 幇
+  - 庁
+  - 廃
+  - 廻
+  - 弉
+  - 弌
+  - 弐
+  - 弖
+  - 弾
+  - 従
+  - 徳
+  - 徴
+  - 忯
+  - 恵
+  - 悩
+  - 惣
+  - 懐
+  - 懽
+  - 戦
+  - 戯
+  - 戻
+  - 払
+  - 抜
+  - 択
+  - 拝
+  - 拠
+  - 拡
+  - 拵
+  - 挙
+  - 挿
+  - 捗
+  - 捜
+  - 掟
+  - 掲
+  - 掻
+  - 揃
+  - 換
+  - 揺
+  - 摂
+  - 撃
+  - 撹
+  - 斉
+  - 斎
+  - 旛
+  - 旡
+  - 晧
+  - 晩
+  - 暁
+  - 暦
+  - 曽
+  - 杁
+  - 杢
+  - 杣
+  - 杮
+  - 枓
+  - 枠
+  - 枡
+  - 柾
+  - 栂
+  - 栃
+  - 桝
+  - 桟
+  - 桾
+  - 梛
+  - 梱
+  - 梲
+  - 梶
+  - 椙
+  - 検
+  - 椥
+  - 楕
+  - 楡
+  - 楢
+  - 榊
+  - 榎
+  - 槇
+  - 様
+  - 槙
+  - 槻
+  - 樋
+  - 権
+  - 樫
+  - 橿
+  - 檥
+  - 欅
+  - 歎
+  - 歓
+  - 歯
+  - 歳
+  - 歴
+  - 毀
+  - 沖
+  - 沢
+  - 浄
+  - 涙
+  - 済
+  - 渉
+  - 渋
+  - 渓
+  - 渕
+  - 満
+  - 滝
+  - 漑
+  - 潅
+  - 澁
+  - 瀞
+  - 瀬
+  - 焔
+  - 焼
+  - 煇
+  - 煕
+  - 煥
+  - 燗
+  - 爼
+  - 犠
+  - 狛
+  - 猟
+  - 獏
+  - 獣
+  - 珊
+  - 瑤
+  - 甞
+  - 畑
+  - 畠
+  - 畳
+  - 畷
+  - 畺
+  - 痩
+  - 癪
+  - 発
+  - 県
+  - 眞
+  - 砕
+  - 碕
+  - 礒
+  - 禖
+  - 禿
+  - 稲
+  - 穂
+  - 穣
+  - 竃
+  - 竜
+  - 竴
+  - 笹
+  - 筈
+  - 筬
+  - 筰
+  - 箆
+  - 箏
+  - 箙
+  - 篠
+  - 篭
+  - 簺
+  - 籾
+  - 粂
+  - 粋
+  - 粛
+  - 粧
+  - 糺
+  - 紬
+  - 絁
+  - 経
+  - 絖
+  - 絣
+  - 絽
+  - 継
+  - 続
+  - 綟
+  - 総
+  - 縄
+  - 縅
+  - 縒
+  - 縦
+  - 繊
+  - 繋
+  - 繍
+  - 繝
+  - 繧
+  - 纐
+  - 纒
+  - 罠
+  - 罧
+  - 罵
+  - 羂
+  - 羇
+  - 羨
+  - 聟
+  - 聡
+  - 聨
+  - 聴
+  - 脇
+  - 脳
+  - 膣
+  - 膵
+  - 臈
+  - 臓
+  - 臥
+  - 舎
+  - 舖
+  - 舗
+  - 舘
+  - 芿
+  - 苅
+  - 茲
+  - 荊
+  - 荘
+  - 莬
+  - 莵
+  - 菫
+  - 萠
+  - 蔵
+  - 薗
+  - 薫
+  - 薬
+  - 薭
+  - 蘊
+  - 蛍
+  - 蝋
+  - 蝿
+  - 蟷
+  - 衞
+  - 衵
+  - 袙
+  - 袞
+  - 袰
+  - 袴
+  - 袿
+  - 裃
+  - 裡
+  - 裲
+  - 褄
+  - 褌
+  - 襴
+  - 襷
+  - 覗
+  - 覚
+  - 覧
+  - 観
+  - 訳
+  - 証
+  - 諌
+  - 諚
+  - 諟
+  - 諡
+  - 諮
+  - 譛
+  - 譲
+  - 讃
+  - 豅
+  - 豊
+  - 豎
+  - 賎
+  - 賛
+  - 贔
+  - 躙
+  - 躰
+  - 転
+  - 軽
+  - 輌
+  - 辥
+  - 辺
+  - 辻
+  - 込
+  - 逓
+  - 遅
+  - 遙
+  - 邉
+  - 郷
+  - 酔
+  - 醗
+  - 醤
+  - 醸
+  - 釈
+  - 鉄
+  - 鉇
+  - 鉤
+  - 鉱
+  - 鉾
+  - 銈
+  - 銕
+  - 銭
+  - 鋲
+  - 鋳
+  - 鋺
+  - 錆
+  - 錍
+  - 錣
+  - 錬
+  - 錵
+  - 鍑
+  - 鍮
+  - 鍼
+  - 鎌
+  - 鎗
+  - 鎚
+  - 鎹
+  - 鐇
+  - 鐚
+  - 鐡
+  - 鑁
+  - 鑑
+  - 鑚
+  - 鑢
+  - 閇
+  - 関
+  - 閦
+  - 闘
+  - 陥
+  - 険
+  - 隣
+  - 隷
+  - 雑
+  - 雫
+  - 霊
+  - 靜
+  - 靫
+  - 靭
+  - 靱
+  - 鞄
+  - 鞆
+  - 頚
+  - 頬
+  - 頴
+  - 頼
+  - 顕
+  - 顗
+  - 餝
+  - 饂
+  - 駄
+  - 駆
+  - 駈
+  - 騒
+  - 験
+  - 騨
+  - 髄
+  - 髙
+  - 髪
+  - 髷
+  - 鯖
+  - 鯰
+  - 鯱
+  - 鰒
+  - 鰯
+  - 鰰
+  - 鳰
+  - 鴎
+  - 鴫
+  - 鵄
+  - 鵞
+  - 鵺
+  - 鶏
+  - 鹸
+  - 麁
+  - 麺
+  - 麿
+  - 黌
+  - 黙
+  - 鼈
+  - 齢
+  - 龗
+  - 縯
+  - 蟅
+  - 坖
+  - 祂
+  - 鼂
+  - 鱚
+  - 蛻
+  - 屌
+  - 呾
+  - 煔
+  - 吶
+  - 扥
+  - 蚖
+  - 銂
+  - 尃
+  - 夋
+  - 鵼
+  - 徬
+  - 寳
+  - 彡
+  - 舨
+  - 湳
+  - 麼
+  - 鍈
+  - 崈
+  - 鱣
+  - 盺
+  - 拺
+  - 瑥
+  - 茷
+  - 焻
+  - 奀
+  - 驎
+  - 鱰
+  - 砢
+  - 痟
+  - 廱
+  - 僜
+  - 瘺
+  - 鱊
+  - 擥
+  - 嶰
+  - 淓
+  - 跅
+  - 浵
+  - 媗
+  - 璦
+  - 煠
+  - 檊
+  - 媃
+  - 峅
+  - 躄
+  - 鉟
+  - 塽
+  - 蟴
+  - 鯮
+  - 弍
+  - 烒
+  - 鵵
+  - 妑
+  - 孋
+  - 蚡
+  - 恊
+  - 輭
+  - 廞
+  - 產
+  - 曅
+  - 盜
+  - 騤
+  - 囪
+  - 鱀
+  - 茇
+  - 葊
+  - 逹
+  - 狓
+  - 崢
+  - 趖
+  - 凃
+  - 羙
+  - 鮸
+  - 昞
+  - 楿
+  - 渽
+  - 圗
+  - 麪
+  - 屇
+  - 鍉
+  - 葝
+  - 沯
+  - 爭
+  - 幵
+  - 筭
+  - 寊
+  - 銋
+  - 貮
+  - 鎭
+  - 熺
+  - 昜
+  - 鍱
+  - 墬
+  - 愒
+  - 磺
+  - 嚈
+  - 稘
+  - 珮
+  - 釆
+  - 殑
+  - 鍩
+  - 䲁
+  - 蕷
+  - 鐿
+  - 僡
+  - 佹
+  - 輶
+  - 冴
+  - 襶
+  - 賔
+  - 猙
+  - 辧
+  - 絛
+  - 磾
+  - 韁
+  - 螔
+  - 譳
+  - 礑
+  - 鋱
+  - 魩
+  - 嚗
+  - 棆
+  - 牆
+  - 敟
+  - 柶
+  - 瓛
+  - 魣
+  - 巎
+  - 轘
+  - 襌
+  - 枼
+  - 鸌
+  - 逺
+  - 錏
+  - 縡
+  - 帢
+  - 騄
+  - 媼
+  - 埅
+  - 鄤
+  - 萐
+  - 祙
+  - 旼
+  - 詥
+  - 鶲
+  - 燉
+  - 卲
+  - 銱
+  - 庲
+  - 伱
+  - 氽
+  - 嵿
+  - 挻
+  - 煵
+  - 窋
+  - 鐤
+  - 鮊
+  - 鱬
+  - 鰧
+  - 嬤
+  - 譞
+  - 諲
+  - 脭
+  - 悳
+  - 崘
+  - 阭
+  - 內
+  - 袾
+  - 冚
+  - 壐
+  - 咗
+  - 礠
+  - 孮
+  - 痲
+  - 埈
+  - 肹
+  - 鰮
+  - 鮓
+  - 濊
+  - 塜
+  - 凜
+  - 蒢
+  - 噰
+  - 桼
+  - 峍
+  - 焴
+  - 鶒
+  - 鋮
+  - 綠
+  - 鶹
+  - 熿
+  - 毴
+  - 咟
+  - 嘥
+  - 睺
+  - 繡
+  - 郎
+  - 瘞
+  - 鉶
+  - 蔎
+  - 秠
+  - 緤
+  - 蝀
+  - 躝
+  - 蟜
+  - 繃
+  - 囮
+  - 墫
+  - 乭
+  - 胊
+  - 濙
+  - 瘓
+  - 榣
+  - 鑛
+  - 鐫
+  - 嶴
+  - 甹
+  - 坮
+  - 銾
+  - 蒭
+  - 睜
+  - 俋
+  - 餠
+  - 榢
+  - 蓳
+  - 盋
+  - 堷
+  - 鍏
+  - 苝
+  - 巛
+  - 蚵
+  - 暏
+  - 熤
+  - 嬨
+  - 墎
+  - 鏽
+  - 戶
+  - 菺
+  - 膮
+  - 熖
+  - 睪
+  - 栜
+  - 捱
+  - 榗
+  - 鍷
+  - 曧
+  - 犽
+  - 韑
+  - 袓
+  - 䖝
+  - 焄
+  - 喦
+  - 髲
+  - 疌
+  - 㴪
+  - 侊
+  - 貐
+  - 蕅
+  - 禠
+  - 蕑
+  - 囯
+  - 暊
+  - 儞
+  - 佋
+  - 柎
+  - 㐱
+  - 鰤
+  - 苳
+  - 鱥
+  - 謤
+  - 遶
+  - 眀
+  - 鑀
+  - 羋
+  - 顏
+  - 陜
+  - 銩
+  - 黶
+  - 苼
+  - 蒤
+  - 棛
+  - 儫
+  - 咁
+  - 抦
+  - 衚
+  - 棩
+  - 焿
+  - 脫
+  - 麅
+  - 玏
+  - 埧
+  - 淸
+  - 黁
+  - 淽
+  - 彠
+  - 鮨
+  - 沜
+  - 糀
+  - 厓
+  - 楧
+  - 嶌
+  - 簹
+  - 檵
+  - 鱇
+  - 嶬
+  - 廸
+  - 卽
+  - 樀
+  - 贌
+  - 酼
+  - 籛
+  - 沒
+  - 晸
+  - 諪
+  - 蕡
+  - 妏
+  - 鄋
+  - 蒍
+  - 奧
+  - 抇
+  - 蓨
+  - 薆
+  - 鱷
+  - 巘
+  - 䝉
+  - 亰
+  - 寈
+  - 槩
+  - 誒
+  - 麴
+  - 蕟
+  - 溎
+  - 蘗
+  - 榦
+  - 斿
+  - 暟
+  - 炲
+  - 拚
+  - 娖
+  - 繖
+  - 橚
+  - 寜
+  - 爀
+  - 饟
+  - 悅
+  - 鯏
+  - 彜
+  - 眾
+  - 葯
+  - 嬝
+  - 埮
+  - 獇
+  - 馛
+  - 溙
+  - 瀦
+  - 熼
+  - 硓
+  - 鈢
+  - 樆
+  - 輬
+  - 鰜
+  - 蔘
+  - 渙
+  - 澔
+  - 嗮
+  - 旉
+  - 籜
+  - 媊
+  - 燘
+  - 儚
+  - 頹
+  - 缽
+  - 俽
+  - 逨
+  - 鱓
+  - 郞
+  - 歊
+  - 杴
+  - 珡
+  - 杋
+  - 醁
+  - 鰏
+  - 鵾
+  - 鐽
+  - 鮋
+  - 巶
+  - 荅
+  - 薾
+  - 囓
+  - 蹻
+  - 獎
+  - 禑
+  - 鎓
+  - 榲
+  - 僴
+  - 綞
+  - 尓
+  - 敭
+  - 曔
+  - 褔
+  - 鬅
+  - 亊
+  - 鏦
+  - 蓘
+  - 裬
+  - 鱲
+  - 薡
+  - 鰗
+  - 箑
+  - 鬪
+  - 縂
+  - 璸
+  - 甙
+  - 茮
+  - 辵
+  - 岻
+  - 覿
+  - 滈
+  - 鯶
+  - 鑂
+  - 囶
+  - 舺
+  - 溋
+  - 拋
+  - 菾
+  - 敾
+  - 虨
+  - 綝
+  - 蝍
+  - 醂
+  - 禨
+  - 賹
+  - 廧
+  - 絕
+  - 槗
+  - 徫
+  - 鎔
+  - 曮
+  - 蠂
+  - 捒
+  - 堈
+  - 莕
+  - 蓪
+  - 敎
+  - 禃
+  - 櫱
+  - 綧
+  - 瀶
+  - 逌
+  - 浤
+  - 碻
+  - 刄
+  - 逤
+  - 剏
+  - 氹
+  - 菈
+  - 娫
+  - 蜛
+  - 嵗
+  - 糎
+  - 螶
+  - 譓
+  - 鏳
+  - 嵙
+  - 瑊
+  - 隲
+  - 檨
+  - 緈
+  - 畵
+  - 砯
+  - 簗
+  - 彅
+  - 鰺
+  - 騋
+  - 窶
+  - 嚒
+  - 嵻
+  - 尙
+  - 頵
+  - 槰
+  - 虉
+  - 醞
+  - 巂
+  - 彔
+  - 偊
+  - 畇
+  - 鱨
+  - 妸
+  - 塲
+  - 畐
+  - 鈫
+  - 錟
+  - 磪
+  - 摠
+  - 彥
+  - 璙
+  - 囝
+  - 寗
+  - 耎
+  - 鮡
+  - 蘓
+  - 弅
+  - 焃
+  - 飥
+  - 戙
+  - 塰
+  - 儱
+  - 槺
+  - 噏
+  - 魟
+  - 禵
+  - 佧
+  - 咘
+  - 盪
+  - 瑈
+  - 鉲
+  - 睭
+  - 鏌
+  - 鼇
+  - 郋
+  - 魮
+  - 朖
+  - 滽
+  - 渃
+  - 滙
+  - 熯
+  - 醿
+  - 鎅
+  - 褀
+  - 鬬
+  - 巄
+  - 螥
+  - 眜
+  - 釚
+  - 柉
+  - 壎
+  - 峇
+  - 姸
+  - 唭
+  - 鮜
+  - 鈖
+  - 嫈
+  - 壄
+  - 洤
+  - 黃
+  - 伕
+  - 堦
+  - 嶔
+  - 鮰
+  - 鞞
+  - 漎
+  - 鉓
+  - 鮗
+  - 壴
+  - 阝
+  - 妀
+  - 矽
+  - 獢
+  - 倗
+  - 銪
+  - 鴓
+  - 橒
+  - 凈
+  - 哖
+  - 屚
+  - 偍
+  - 瑺
+  - 媯
+  - 淍
+  - 驌
+  - 椇
+  - 赬
+  - 薐
+  - 糹
+  - 碽
+  - 濲
+  - 釭
+  - 晭
+  - 纕
+  - 寖
+  - 閞
+  - 歿
+  - 呎
+  - 鶆
+  - 屄
+  - 櫿
+  - 犎
+  - 旲
+  - 㙟
+  - 龎
+  - 翜
+  - 螾
+  - 說
+  - 衜
+  - 泆
+  - 軎
+  - 鵂
+  - 荎
+  - 嚧
+  - 硂
+  - 桖
+  - 褭
+  - 筊
+  - 鰷
+  - 秳
+  - 戩
+  - 轀
+  - 鬹
+  - 飬
+  - 卋
+  - 暸
+  - 狦
+  - 搢
+  - 娋
+  - 鏴
+  - 溫
+  - 毉
+  - 淰
+  - 謩
+  - 餺
+  - 鵙
+  - 鳽
+  - 鮀
+  - 狶
+  - 氻
+  - 轝
+  - 妺
+  - 袛
+  - 蓭
+  - 梂
+  - 娛
+  - 牼
+  - 稅
+  - 兿
+  - 玾
+  - 煚
+  - 僩
+  - 鶿
+  - 鬄
+  - 崠
+  - 鉆
+  - 鯓
+  - 蚢
+  - 庀
+  - 鵟
+  - 坣
+  - 殼
+  - 悞
+  - 熅
+  - 敻
+  - 鍠
+  - 曶
+  - 愼
+  - 搳
+  - 姃
+  - 砳
+  - 槼
+  - 臞
+  - 韾
+  - 靑
+  - 鸊
+  - 薲
+  - 虛
+  - 蠄
+  - 啟
+  - 鶺
+  - 苺
+  - 滾
+  - 褞
+  - 仺
+  - 胇
+  - 憻
+  - 郳
+  - 烉
+  - 驩
+  - 冇
+  - 枖
+  - 夌
+  - 搵
+  - 匸
+  - 盨
+  - 櫾
+  - 霤
+  - 麊
+  - 貒
+  - 噓
+  - 嗢
+  - 笩
+  - 晈
+  - 冂
+  - 銳
+  - 毿
+  - 慜
+  - 囧
+  - 閜
+  - 娸
+  - 庢
+  - 壆
+  - 馯
+  - 桱
+  - 兗
+  - 葃
+  - 侅
+  - 煐
+  - 鐦
+  - 藸
+  - 鷎
+  - 嵰
+  - 逎
+  - 弒
+  - 匋
+  - 鐭
+  - 廔
+  - 砩
+  - 孆
+  - 灴
+  - 伷
+  - 兪
+  - 鴗
+  - 澯
+  - 幚
+  - 旙
+  - 勻
+  - 礽
+  - 婑
+  - 鱮
+  - 娍
+  - 銶
+  - 吳
+  - 鍟
+  - 仼
+  - 鳧
+  - 彞
+  - 娽
+  - 昛
+  - 鰼
+  - 剎
+  - 佉
+  - 鉏
+  - 偸
+  - 鰆
+  - 讙
+  - 橪
+  - 啱
+  - 岀
+  - 孻
+  - 釪
+  - 乹
+  - 鈳
+  - 漇
+  - 檦
+  - 埻
+  - 祿
+  - 爌
+  - 禇
+  - 鱵
+  - 㸃
+  - 梉
+  - 燝
+  - 霙
+  - 炁
+  - 飮
+  - 蠙
+  - 勷
+  - 鵎
+  - 儥
+  - 鐠
+  - 唻
+  - 廰
+  - 嚿
+  - 嵕
+  - 墱
+  - 紑
+  - 搖
+  - 瘜
+  - 皝
+  - 鸑
+  - 瀁
+  - 粵
+  - 撚
+  - 巑
+  - 梀
+  - 啯
+  - 眛
+  - 諴
+  - 夊
+  - 僙
+  - 鍝
+  - 裖
+  - 鮣
+  - 凬
+  - 飡
+  - 灊
+  - 橓
+  - 嫳
+  - 筳
+  - 咑
+  - 粍
+  - 瓑
+  - 璌
+  - 伃
+  - 閰
+  - 傜
+  - 黐
+  - 謢
+  - 驒
+  - 橫
+  - 蛯
+  - 寕
+  - 蠵
+  - 瞓
+  - 旳
+  - 翏
+  - 硏
+  - 寯
+  - 韡
+  - 楤
+  - 鰃
+  - 朿
+  - 侞
+  - 鵯
+  - 愨
+  - 祹
+  - 厔
+  - 丌
+  - 盩
+  - 謏
+  - 魕
+  - 啣
+  - 閱
+  - 曺
+  - 枛
+  - 罉
+  - 卐
+  - 樻
+  - 鷉
+  - 鯒
+  - 鋡
+  - 磱
+  - 枱
+  - 攴
+  - 蠷
+  - 穈
+  - 嚟
+  - 檽
+  - 趐
+  - 奐
+  - 鋐
+  - 檇
+  - 薀
+  - 峼
+  - 咭
+  - 訔
+  - 韠
+  - 鑴
+  - 鸐
+  - 唃
+  - 捦
+  - 鸜
+  - 誴
+  - 罳
+  - 璄
+  - 暃
+  - 夀
+  - 賨
+  - 鞥
+  - 鈊
+  - 灡
+  - 鮍
+  - 懮
+  - 籣
+  - 昐
+  - 陁
+  - 襾
+  - 鮠
+  - 鈏
+  - 囍
+  - 婯
+  - 艔
+  - 貭
+  - 䰾
+  - 姁
+  - 禼
+  - 堖
+  - 鋶
+  - 仛
+  - 鏷
+  - 謜
+  - 鑅
+  - 忬
+  - 蘶
+  - 謠
+  - 觙
+  - 奫
+  - 狟
+  - 泩
+  - 桙
+  - 飈
+  - 垰
+  - 啍
+  - 嚞
+  - 鯕
+  - 蒧
+  - 榞
+  - 徸
+  - 璹
+  - 揔
+  - 欉
+  - 魞
+  - 菶
+  - 玧
+  - 鳯
+  - 廍
+  - 侚
+  - 岰
+  - 岧
+  - 鋕
+  - 凵
+  - 彣
+  - 崱
+  - 媜
+  - 倢
+  - 鵐
+  - 砋
+  - 鷚
+  - 鱠
+  - 鮻
+  - 繻
+  - 摵
+  - 贓
+  - 磵
+  - 錻
+  - 痠
+  - 粩
+  - 胅
+  - 奣
+  - 塨
+  - 瀠
+  - 鸘
+  - 啚
+  - 娳
+  - 霶
+  - 壔
+  - 峚
+  - 甂
+  - 廁
+  - 覌
+  - 鰂
+  - 猳
+  - 鱻
+  - 盫
+  - 裿
+  - 杬
+  - 歛
+  - 澋
+  - 蘞
+  - 嵜
+  - 尐
+  - 旽
+  - 鉌
+  - 鎛
+  - 豿
+  - 凖
+  - 榤
+  - 禓
+  - 龝
+  - 悧
+  - 鷟
+  - 鮟
+  - 吋
+  - 喢
+  - 岪
+  - 吥
+  - 漵
+  - 頠
+  - 豔
+  - 巿
+  - 鑨
+  - 醣
+  - 熳
+  - 懍
+  - 湥
+  - 檡
+  - 韺
+  - 戱
+  - 緖
+  - 鐈
+  - 凉
+  - 緃
+  - 鮹
+  - 媐
+  - 爯
+  - 巆
+  - 褍
+  - 鐬
+  - 昍
+  - 扙
+  - 鍳
+  - 芛
+  - 蟳
+  - 嬅
+  - 糬
+  - 吔
+  - 塭
+  - 譿
+  - 冧
+  - 鏓
+  - 嶪
+  - 嗹
+  - 椵
+  - 姀
+  - 閿
+  - 褧
+  - 錞
+  - 玆
+  - 笘
+  - 篔
+  - 萡
+  - 鶡
+  - 螐
+  - 鮄
+  - 鰟
+  - 脷
+  - 啲
+  - 杤
+  - 蓚
+  - 尗
+  - 娎
+  - 殟
+  - 淥
+  - 蝚
+  - 蓧
+  - 彐
+  - 嚤
+  - 銍
+  - 囒
+  - 坶
+  - 淩
+  - 鶼
+  - 鱂
+  - 喼
+  - 燫
+  - 肏
+  - 姵
+  - 廌
+  - 禟
+  - 籝
+  - 迵
+  - 嵨
+  - 堮
+  - 蟌
+  - 憍
+  - 廕
+  - 蜑
+  - 緁
+  - 唘
+  - 竩
+  - 崙
+  - 璚
+  - 粄
+  - 栨
+  - 罈
+  - 梫
+  - 貤
+  - 藔
+  - 蜯
+  - 訁
+  - 斖
+  - 煶
+  - 馦
+  - 妠
+  - 閟
+  - 疕
+  - 夆
+  - 鎪
+  - 膥
+  - 澻
+  - 嘢
+  - 嚐
+  - 靁
+  - 鎻
+  - 鰛
+  - 穵
+  - 烋
+  - 縕
+  - 褎
+  - 疒
+  - 壠
+  - 溼
+  - 圂
+  - 咅
+  - 鯭
+  - 鯙
+  - 磘
+  - 玨
+  - 珤
+  - 朊
+  - 蚼
+  - 濶
+  - 薞
+  - 嚩
+  - 丟
+  - 嫺
+  - 鯻
+  - 椲
+  - 鰕
+  - 刂
+  - 蠘
+  - 踎
+  - 瀴
+  - 琁
+  - 鰶
+  - 瑴
+  - 肜
+  - 㐂
+  - 欥
+  - 媺
+  - 竻
+  - 讚
+  - 𣇉
+  - 裵
+  - 緜
+  - 廩
+  - 齧
+  - 叄
+  - 俌
+  - 厰
+  - 滀
+  - 錄
+  - 鷫
+  - 鯗
+  - 攞
+  - 姌
+  - 蔝
+  - 幷
+  - 縤
+  - 屻
+  - 鯃
+  - 雞
+  - 纁
+  - 嫲
+  - 嵮
+  - 屭
+  - 嶃
+  - 跩
+  - 鋗
+  - 蕢
+  - 篊
+  - 俬
+  - 淎
+  - 暻
+  - 鏻
+  - 憓
+  - 玗
+  - 溈
+  - 笭
+  - 糢
+  - 勳
+  - 閒
+  - 沍
+  - 咾
+  - 鉷
+  - 蘵
+  - 俁
+  - 崵
+  - 毸
+  - 苪
+  - 掙
+  - 鴡
+  - 萭
+  - 俴
+  - 屜
+  - 蒾
+  - 艹
+  - 剷
+  - 慍
+  - 朮
+  - 枴
+  - 氳
+  - 猓
+  - 甽
+  - 箝
+  - 譁
+  - 贗
+  - 迆
+  - 鈽
+  - 鍊
+  - 鍰
+  - 鏍
+  - 靦
+  - 餽
+  - 丮
+  - 丱
+  - 仜
+  - 仩
+  - 伬
+  - 伔
+  - 仱
+  - 伀
+  - 伻
+  - 佢
+  - 佒
+  - 侀
+  - 侇
+  - 佷
+  - 佌
+  - 佪
+  - 侐
+  - 侜
+  - 俓
+  - 侲
+  - 俉
+  - 侻
+  - 侳
+  - 俇
+  - 倅
+  - 倇
+  - 倰
+  - 倛
+  - 倳
+  - 倷
+  - 俷
+  - 倠
+  - 偯
+  - 偞
+  - 偠
+  - 偋
+  - 偝
+  - 偛
+  - 偢
+  - 偅
+  - 偟
+  - 偩
+  - 偫
+  - 傛
+  - 傔
+  - 傞
+  - 傋
+  - 傌
+  - 傎
+  - 傝
+  - 偨
+  - 傂
+  - 傽
+  - 傿
+  - 僆
+  - 傮
+  - 僄
+  - 僈
+  - 傰
+  - 僁
+  - 傱
+  - 僋
+  - 僗
+  - 僛
+  - 僪
+  - 僝
+  - 僓
+  - 僿
+  - 儃
+  - 儰
+  - 僸
+  - 僶
+  - 僾
+  - 儌
+  - 僽
+  - 儜
+  - 儓
+  - 儗
+  - 儑
+  - 儢
+  - 儤
+  - 儠
+  - 儸
+  - 儹
+  - 儽
+  - 冓
+  - 冘
+  - 冞
+  - 凊
+  - 凅
+  - 凔
+  - 刌
+  - 刉
+  - 刓
+  - 刜
+  - 刞
+  - 刵
+  - 刲
+  - 剆
+  - 刱
+  - 剉
+  - 剚
+  - 剒
+  - 剫
+  - 剭
+  - 剬
+  - 剺
+  - 剸
+  - 剻
+  - 剼
+  - 劀
+  - 劋
+  - 劖
+  - 劘
+  - 劗
+  - 劙
+  - 劦
+  - 勴
+  - 匊
+  - 匢
+  - 匰
+  - 匴
+  - 匷
+  - 匽
+  - 卌
+  - 卼
+  - 厎
+  - 厒
+  - 厗
+  - 厞
+  - 厜
+  - 厤
+  - 厬
+  - 厹
+  - 吰
+  - 吷
+  - 吪
+  - 呿
+  - 咈
+  - 呫
+  - 呺
+  - 呥
+  - 呬
+  - 呴
+  - 茍
+  - 咷
+  - 咮
+  - 咶
+  - 哅
+  - 咠
+  - 咢
+  - 唦
+  - 唗
+  - 唒
+  - 哤
+  - 唚
+  - 唈
+  - 哫
+  - 唅
+  - 唴
+  - 啢
+  - 唶
+  - 啒
+  - 啅
+  - 唌
+  - 唲
+  - 喨
+  - 喥
+  - 喭
+  - 噅
+  - 喓
+  - 喣
+  - 啽
+  - 喌
+  - 嗃
+  - 嗛
+  - 嗋
+  - 嗀
+  - 喿
+  - 喍
+  - 嗏
+  - 嗕
+  - 嗈
+  - 嘕
+  - 嘒
+  - 嗼
+  - 嘐
+  - 嘓
+  - 嘂
+  - 嗺
+  - 嘝
+  - 嘄
+  - 嗿
+  - 噈
+  - 噊
+  - 噆
+  - 噚
+  - 嘳
+  - 嘽
+  - 嘾
+  - 噮
+  - 噳
+  - 噣
+  - 噭
+  - 噞
+  - 嚌
+  - 嚍
+  - 嚃
+  - 嚘
+  - 嚜
+  - 嚫
+  - 嚪
+  - 嚬
+  - 嚲
+  - 嚵
+  - 嚽
+  - 嚾
+  - 囆
+  - 囅
+  - 囋
+  - 囗
+  - 圁
+  - 圞
+  - 圠
+  - 坁
+  - 坅
+  - 坲
+  - 坱
+  - 垀
+  - 坴
+  - 垗
+  - 垝
+  - 垔
+  - 垘
+  - 垽
+  - 垼
+  - 埢
+  - 埶
+  - 堩
+  - 堣
+  - 塈
+  - 堥
+  - 塓
+  - 塉
+  - 塯
+  - 塕
+  - 塼
+  - 墆
+  - 塿
+  - 塴
+  - 墋
+  - 塺
+  - 墝
+  - 墯
+  - 壈
+  - 墽
+  - 壖
+  - 壝
+  - 壛
+  - 壾
+  - 壿
+  - 夃
+  - 夎
+  - 夒
+  - 夗
+  - 奅
+  - 奊
+  - 奰
+  - 奲
+  - 奼
+  - 妦
+  - 妎
+  - 妢
+  - 妐
+  - 妵
+  - 姏
+  - 姎
+  - 㚷
+  - 姡
+  - 姺
+  - 姼
+  - 娭
+  - 婐
+  - 婟
+  - 婥
+  - 婓
+  - 婗
+  - 媔
+  - 媟
+  - 媢
+  - 婸
+  - 媦
+  - 媥
+  - 媬
+  - 媕
+  - 娷
+  - 嫇
+  - 嫋
+  - 媰
+  - 媻
+  - 嫮
+  - 嫥
+  - 嫢
+  - 嫛
+  - 嫿
+  - 嫴
+  - 嫷
+  - 嫶
+  - 嬎
+  - 嬓
+  - 嬐
+  - 嬲
+  - 嬽
+  - 孈
+  - 屘
+  - 孲
+  - 孷
+  - 宎
+  - 宨
+  - 寪
+  - 寍
+  - 寋
+  - 寑
+  - 寙
+  - 寠
+  - 寱
+  - 尌
+  - 尒
+  - 尟
+  - 尰
+  - 尳
+  - 屖
+  - 屔
+  - 屝
+  - 屧
+  - 屩
+  - 屮
+  - 屴
+  - 岏
+  - 岋
+  - 岉
+  - 岒
+  - 岮
+  - 岤
+  - 岯
+  - 岟
+  - 岝
+  - 峐
+  - 峌
+  - 峞
+  - 峉
+  - 峊
+  - 峬
+  - 峮
+  - 峷
+  - 崝
+  - 崨
+  - 崥
+  - 崏
+  - 崰
+  - 崣
+  - 崷
+  - 嵃
+  - 嵑
+  - 崳
+  - 崺
+  - 嵂
+  - 嵱
+  - 嵣
+  - 嵥
+  - 嵞
+  - 嶀
+  - 嵽
+  - 嶆
+  - 嵺
+  - 嵷
+  - 嶊
+  - 嶉
+  - 嶈
+  - 嵾
+  - 嶕
+  - 嶜
+  - 嶡
+  - 嶚
+  - 嶞
+  - 嶱
+  - 嶩
+  - 嶵
+  - 嶭
+  - 巃
+  - 巏
+  - 巕
+  - 巟
+  - 巹
+  - 帊
+  - 帗
+  - 帟
+  - 帣
+  - 帠
+  - 帤
+  - 帩
+  - 帾
+  - 帴
+  - 幏
+  - 幎
+  - 幓
+  - 幩
+  - 幝
+  - 幠
+  - 幧
+  - 幨
+  - 幦
+  - 幭
+  - 幰
+  - 庂
+  - 庉
+  - 庌
+  - 庈
+  - 庰
+  - 庛
+  - 庣
+  - 庨
+  - 庮
+  - 庪
+  - 庬
+  - 庴
+  - 廅
+  - 廇
+  - 廘
+  - 廗
+  - 廎
+  - 廜
+  - 緳
+  - 廦
+  - 廥
+  - 廮
+  - 廯
+  - 蠯
+  - 廾
+  - 弚
+  - 弝
+  - 弣
+  - 弤
+  - 弮
+  - 弳
+  - 彃
+  - 彉
+  - 彋
+  - 彏
+  - 彯
+  - 彴
+  - 彸
+  - 彾
+  - 徦
+  - 徥
+  - 徯
+  - 徲
+  - 徾
+  - 徿
+  - 忀
+  - 忁
+  - 忔
+  - 忕
+  - 忨
+  - 忣
+  - 忷
+  - 忥
+  - 怭
+  - 怲
+  - 怋
+  - 怴
+  - 怗
+  - 怚
+  - 怞
+  - 怬
+  - 怢
+  - 怐
+  - 怮
+  - 怓
+  - 怷
+  - 怹
+  - 恲
+  - 恞
+  - 恅
+  - 恇
+  - 恉
+  - 恛
+  - 恌
+  - 恀
+  - 恟
+  - 悀
+  - 悁
+  - 悕
+  - 悗
+  - 悇
+  - 悊
+  - 悐
+  - 悾
+  - 悺
+  - 惓
+  - 惤
+  - 惈
+  - 悷
+  - 惉
+  - 悹
+  - 惌
+  - 惢
+  - 惄
+  - 愊
+  - 愖
+  - 愅
+  - 惵
+  - 愓
+  - 惸
+  - 惼
+  - 惾
+  - 慉
+  - 慅
+  - 愶
+  - 愲
+  - 愮
+  - 愯
+  - 愬
+  - 慁
+  - 慞
+  - 慱
+  - 慒
+  - 慓
+  - 慲
+  - 憀
+  - 慴
+  - 慔
+  - 慺
+  - 慛
+  - 憃
+  - 慹
+  - 憱
+  - 憰
+  - 憢
+  - 憉
+  - 憛
+  - 憯
+  - 憟
+  - 憪
+  - 憡
+  - 憝
+  - 憖
+  - 懅
+  - 憴
+  - 懆
+  - 懁
+  - 憿
+  - 憸
+  - 憵
+  - 憼
+  - 懧
+  - 懠
+  - 懥
+  - 懤
+  - 懘
+  - 懭
+  - 懱
+  - 懪
+  - 懰
+  - 懫
+  - 懻
+  - 戁
+  - 戃
+  - 戄
+  - 戉
+  - 戠
+  - 酨
+  - 戺
+  - 扐
+  - 扜
+  - 扤
+  - 扡
+  - 扢
+  - 抆
+  - 抌
+  - 抎
+  - 抏
+  - 扻
+  - 抭
+  - 抴
+  - 拑
+  - 抾
+  - 抪
+  - 抶
+  - 抮
+  - 挍
+  - 挋
+  - 挃
+  - 拫
+  - 拹
+  - 挏
+  - 挌
+  - 拸
+  - 挀
+  - 拲
+  - 捖
+  - 挬
+  - 挶
+  - 揤
+  - 捊
+  - 挼
+  - 挩
+  - 捁
+  - 挴
+  - 捘
+  - 捔
+  - 捥
+  - 掝
+  - 掗
+  - 掫
+  - 掯
+  - 捵
+  - 掜
+  - 捼
+  - 掤
+  - 掔
+  - 掱
+  - 揎
+  - 揥
+  - 揨
+  - 揯
+  - 揊
+  - 揲
+  - 揵
+  - 摡
+  - 揟
+  - 揝
+  - 揜
+  - 揘
+  - 揅
+  - 揱
+  - 搆
+  - 搟
+  - 搕
+  - 搘
+  - 搹
+  - 搷
+  - 搣
+  - 搰
+  - 搊
+  - 搚
+  - 摀
+  - 搧
+  - 搫
+  - 摍
+  - 摝
+  - 摲
+  - 摦
+  - 摎
+  - 摋
+  - 摓
+  - 摐
+  - 摿
+  - 摮
+  - 摰
+  - 撢
+  - 撠
+  - 撗
+  - 撜
+  - 撋
+  - 撊
+  - 撌
+  - 撟
+  - 擗
+  - 擖
+  - 擏
+  - 擉
+  - 撽
+  - 擩
+  - 擣
+  - 擫
+  - 擭
+  - 擨
+  - 擽
+  - 擸
+  - 攇
+  - 攐
+  - 攍
+  - 攌
+  - 攗
+  - 攕
+  - 攓
+  - 攡
+  - 攠
+  - 攦
+  - 攩
+  - 攭
+  - 攲
+  - 攳
+  - 敁
+  - 敊
+  - 敆
+  - 敓
+  - 敧
+  - 敪
+  - 敤
+  - 敜
+  - 敯
+  - 敳
+  - 敶
+  - 敺
+  - 敹
+  - 敿
+  - 斁
+  - 斀
+  - 斄
+  - 斒
+  - 斔
+  - 斞
+  - 斨
+  - 斪
+  - 斻
+  - 旍
+  - 旓
+  - 旚
+  - 旝
+  - 旟
+  - 昲
+  - 昦
+  - 昢
+  - 晇
+  - 晥
+  - 晜
+  - 晼
+  - 晬
+  - 暀
+  - 暆
+  - 暍
+  - 暋
+  - 暡
+  - 暰
+  - 暩
+  - 曀
+  - 曊
+  - 曋
+  - 曏
+  - 曒
+  - 曚
+  - 曣
+  - 曭
+  - 朁
+  - 朅
+  - 朄
+  - 朒
+  - 朘
+  - 朣
+  - 朾
+  - 朹
+  - 朻
+  - 朼
+  - 杅
+  - 杇
+  - 杝
+  - 杗
+  - 枎
+  - 杶
+  - 枆
+  - 枌
+  - 柲
+  - 枺
+  - 枻
+  - 柸
+  - 柀
+  - 柅
+  - 柫
+  - 柤
+  - 柍
+  - 柮
+  - 柣
+  - 柂
+  - 柧
+  - 栚
+  - 桋
+  - 桏
+  - 栱
+  - 栵
+  - 栫
+  - 栭
+  - 栯
+  - 栘
+  - 栔
+  - 梡
+  - 梇
+  - 梐
+  - 桭
+  - 梮
+  - 楖
+  - 梬
+  - 梩
+  - 桵
+  - 梒
+  - 椌
+  - 椄
+  - 棜
+  - 棷
+  - 棳
+  - 棌
+  - 椈
+  - 楰
+  - 棯
+  - 椔
+  - 棸
+  - 楟
+  - 楎
+  - 楱
+  - 楅
+  - 楺
+  - 楈
+  - 楛
+  - 楉
+  - 楬
+  - 椳
+  - 楀
+  - 楄
+  - 楶
+  - 楘
+  - 榶
+  - 槉
+  - 榠
+  - 榬
+  - 榼
+  - 榙
+  - 榩
+  - 榾
+  - 榯
+  - 槄
+  - 榽
+  - 榹
+  - 槥
+  - 槸
+  - 樕
+  - 樠
+  - 槬
+  - 槢
+  - 樛
+  - 樝
+  - 槾
+  - 樧
+  - 槮
+  - 樔
+  - 槷
+  - 橀
+  - 樴
+  - 橉
+  - 橧
+  - 樲
+  - 橨
+  - 橝
+  - 橭
+  - 橶
+  - 樿
+  - 橁
+  - 檍
+  - 檖
+  - 檁
+  - 檟
+  - 橾
+  - 檛
+  - 檓
+  - 檕
+  - 檃
+  - 櫅
+  - 檹
+  - 櫡
+  - 櫠
+  - 櫌
+  - 櫑
+  - 櫙
+  - 櫋
+  - 櫜
+  - 櫐
+  - 櫫
+  - 櫬
+  - 櫰
+  - 櫹
+  - 櫺
+  - 櫼
+  - 欃
+  - 欋
+  - 欈
+  - 欐
+  - 欑
+  - 欘
+  - 欨
+  - 欴
+  - 欯
+  - 欭
+  - 欱
+  - 欶
+  - 欳
+  - 欷
+  - 欿
+  - 歂
+  - 歈
+  - 歍
+  - 歋
+  - 歕
+  - 歔
+  - 歜
+  - 歠
+  - 歭
+  - 歾
+  - 肂
+  - 殈
+  - 殏
+  - 殔
+  - 殗
+  - 殙
+  - 殠
+  - 殥
+  - 殢
+  - 殦
+  - 殧
+  - 殰
+  - 殶
+  - 毃
+  - 毄
+  - 毈
+  - 毇
+  - 毊
+  - 毚
+  - 毞
+  - 毦
+  - 毤
+  - 毨
+  - 毣
+  - 毰
+  - 毲
+  - 毻
+  - 毼
+  - 毾
+  - 氁
+  - 氀
+  - 氄
+  - 氠
+  - 氶
+  - 汃
+  - 汒
+  - 汏
+  - 汍
+  - 汸
+  - 沋
+  - 汱
+  - 汯
+  - 沕
+  - 汦
+  - 汳
+  - 泬
+  - 沶
+  - 沬
+  - 泧
+  - 沷
+  - 泭
+  - 泲
+  - 泒
+  - 沴
+  - 洟
+  - 洊
+  - 洀
+  - 浺
+  - 浶
+  - 洍
+  - 涒
+  - 浘
+  - 浢
+  - 涊
+  - 涆
+  - 浧
+  - 涗
+  - 涳
+  - 涬
+  - 淢
+  - 涷
+  - 淔
+  - 渀
+  - 淈
+  - 涾
+  - 淊
+  - 涽
+  - 淭
+  - 湆
+  - 湇
+  - 湅
+  - 湢
+  - 渿
+  - 湁
+  - 渜
+  - 渳
+  - 湀
+  - 渻
+  - 渮
+  - 湨
+  - 湡
+  - 渱
+  - 渨
+  - 湠
+  - 湱
+  - 湩
+  - 渹
+  - 溛
+  - 滖
+  - 溓
+  - 溔
+  - 滒
+  - 溰
+  - 溾
+  - 滜
+  - 滵
+  - 滱
+  - 漃
+  - 漥
+  - 漮
+  - 潎
+  - 漙
+  - 漧
+  - 漘
+  - 漒
+  - 滭
+  - 漊
+  - 潳
+  - 滮
+  - 潀
+  - 漰
+  - 潃
+  - 漅
+  - 濆
+  - 澒
+  - 澅
+  - 潚
+  - 潠
+  - 澖
+  - 潶
+  - 潬
+  - 潒
+  - 潐
+  - 潗
+  - 澓
+  - 潝
+  - 濇
+  - 濎
+  - 濈
+  - 濄
+  - 澞
+  - 澨
+  - 瀄
+  - 濌
+  - 澩
+  - 濴
+  - 濔
+  - 濣
+  - 濭
+  - 濧
+  - 濦
+  - 瀇
+  - 瀎
+  - 濿
+  - 瀀
+  - 濻
+  - 瀙
+  - 瀖
+  - 瀫
+  - 瀡
+  - 瀢
+  - 瀩
+  - 瀯
+  - 瀷
+  - 灂
+  - 瀸
+  - 瀿
+  - 瀺
+  - 灄
+  - 灉
+  - 灖
+  - 灗
+  - 灛
+  - 灟
+  - 灨
+  - 灩
+  - 灪
+  - 炾
+  - 炰
+  - 烓
+  - 烑
+  - 缹
+  - 焍
+  - 烰
+  - 焠
+  - 焮
+  - 焣
+  - 煆
+  - 煣
+  - 煝
+  - 熐
+  - 熉
+  - 熀
+  - 熂
+  - 熚
+  - 燅
+  - 燂
+  - 熸
+  - 燀
+  - 燡
+  - 爁
+  - 爊
+  - 爂
+  - 爓
+  - 爞
+  - 爢
+  - 爣
+  - 牄
+  - 牉
+  - 牋
+  - 牏
+  - 牣
+  - 牬
+  - 牰
+  - 牸
+  - 牷
+  - 犈
+  - 犉
+  - 犆
+  - 犅
+  - 犌
+  - 犑
+  - 犐
+  - 犗
+  - 犕
+  - 犓
+  - 犘
+  - 犚
+  - 犝
+  - 犞
+  - 犥
+  - 犦
+  - 犤
+  - 犣
+  - 犩
+  - 犪
+  - 犮
+  - 犵
+  - 犿
+  - 狆
+  - 狖
+  - 狋
+  - 狘
+  - 狜
+  - 狔
+  - 狚
+  - 狌
+  - 狑
+  - 狊
+  - 狤
+  - 狫
+  - 狪
+  - 狣
+  - 猀
+  - 狾
+  - 猑
+  - 猘
+  - 猈
+  - 狿
+  - 猏
+  - 猋
+  - 猒
+  - 猧
+  - 猲
+  - 猭
+  - 猦
+  - 猣
+  - 猵
+  - 猼
+  - 獂
+  - 獀
+  - 獊
+  - 獑
+  - 獌
+  - 獘
+  - 獞
+  - 獟
+  - 獝
+  - 獛
+  - 獡
+  - 獩
+  - 獦
+  - 獥
+  - 獳
+  - 獶
+  - 獽
+  - 獿
+  - 玂
+  - 玁
+  - 玈
+  - 玊
+  - 玔
+  - 珓
+  - 珶
+  - 琖
+  - 瑵
+  - 璊
+  - 瑽
+  - 璅
+  - 瑿
+  - 璗
+  - 瓁
+  - 瓋
+  - 瓝
+  - 瓟
+  - 瓡
+  - 瓥
+  - 瓨
+  - 瓬
+  - 瓵
+  - 瓾
+  - 瓽
+  - 甀
+  - 甃
+  - 甈
+  - 甋
+  - 甐
+  - 甒
+  - 甔
+  - 甖
+  - 甝
+  - 甮
+  - 甿
+  - 畟
+  - 畣
+  - 畽
+  - 疀
+  - 疧
+  - 痁
+  - 疻
+  - 痀
+  - 痎
+  - 痏
+  - 痋
+  - 痌
+  - 痑
+  - 痚
+  - 痡
+  - 痝
+  - 痗
+  - 痯
+  - 瘏
+  - 痷
+  - 痸
+  - 痻
+  - 瘈
+  - 瘑
+  - 瘝
+  - 瘣
+  - 瘯
+  - 瘱
+  - 瘽
+  - 癈
+  - 癉
+  - 癙
+  - 癐
+  - 癓
+  - 癠
+  - 癵
+  - 癹
+  - 皊
+  - 皏
+  - 皫
+  - 皯
+  - 皵
+  - 皻
+  - 皽
+  - 皾
+  - 盄
+  - 盓
+  - 盝
+  - 盬
+  - 盭
+  - 盳
+  - 眃
+  - 眅
+  - 盻
+  - 眝
+  - 眐
+  - 眓
+  - 眒
+  - 眣
+  - 眑
+  - 眕
+  - 眹
+  - 眱
+  - 眲
+  - 眴
+  - 眳
+  - 眽
+  - 睆
+  - 睅
+  - 睊
+  - 睋
+  - 睌
+  - 睕
+  - 睟
+  - 睒
+  - 睖
+  - 睩
+  - 睧
+  - 睔
+  - 瞁
+  - 睼
+  - 瞂
+  - 睮
+  - 睯
+  - 瞏
+  - 瞉
+  - 瞚
+  - 瞝
+  - 瞡
+  - 瞛
+  - 瞲
+  - 瞷
+  - 瞶
+  - 瞴
+  - 矂
+  - 矉
+  - 矊
+  - 矌
+  - 矎
+  - 矏
+  - 矐
+  - 矔
+  - 矕
+  - 矘
+  - 矠
+  - 矱
+  - 矲
+  - 矹
+  - 矺
+  - 砅
+  - 砐
+  - 砏
+  - 砎
+  - 砨
+  - 硈
+  - 硉
+  - 硠
+  - 硥
+  - 硱
+  - 硰
+  - 硩
+  - 碔
+  - 碄
+  - 碅
+  - 碆
+  - 硾
+  - 碫
+  - 碞
+  - 磍
+  - 磌
+  - 磎
+  - 磈
+  - 磃
+  - 磝
+  - 磩
+  - 磥
+  - 磞
+  - 磛
+  - 磳
+  - 磼
+  - 磿
+  - 礔
+  - 礉
+  - 礝
+  - 礛
+  - 礜
+  - 礥
+  - 礣
+  - 礧
+  - 礨
+  - 礭
+  - 礿
+  - 祌
+  - 祅
+  - 祔
+  - 祒
+  - 祑
+  - 祤
+  - 祩
+  - 祪
+  - 祣
+  - 祫
+  - 祡
+  - 祴
+  - 祳
+  - 禂
+  - 禗
+  - 禜
+  - 禫
+  - 禭
+  - 禬
+  - 禴
+  - 禷
+  - 禸
+  - 歶
+  - 秅
+  - 秏
+  - 秖
+  - 秎
+  - 秮
+  - 秪
+  - 秺
+  - 秶
+  - 稊
+  - 稒
+  - 稫
+  - 穊
+  - 稰
+  - 稯
+  - 穋
+  - 穛
+  - 穖
+  - 穧
+  - 穨
+  - 穮
+  - 穬
+  - 穭
+  - 穱
+  - 穾
+  - 窆
+  - 窉
+  - 窌
+  - 窏
+  - 窔
+  - 窐
+  - 窙
+  - 窢
+  - 窞
+  - 窫
+  - 窲
+  - 窴
+  - 窱
+  - 窾
+  - 竀
+  - 竁
+  - 竷
+  - 笐
+  - 笓
+  - 笅
+  - 笵
+  - 笻
+  - 笴
+  - 笰
+  - 笢
+  - 笝
+  - 笲
+  - 筄
+  - 筡
+  - 箈
+  - 箊
+  - 箌
+  - 箛
+  - 箎
+  - 箘
+  - 箄
+  - 箷
+  - 箾
+  - 篎
+  - 箯
+  - 箹
+  - 篞
+  - 篣
+  - 篧
+  - 篕
+  - 篨
+  - 篹
+  - 簅
+  - 篲
+  - 篿
+  - 篻
+  - 簎
+  - 篴
+  - 簂
+  - 簁
+  - 篸
+  - 篽
+  - 簜
+  - 簩
+  - 簙
+  - 簭
+  - 簦
+  - 簨
+  - 簢
+  - 簥
+  - 簳
+  - 簼
+  - 簬
+  - 簻
+  - 籉
+  - 籈
+  - 籊
+  - 籔
+  - 籗
+  - 籧
+  - 籦
+  - 籯
+  - 籺
+  - 籸
+  - 籹
+  - 粊
+  - 粔
+  - 粻
+  - 糔
+  - 糪
+  - 糱
+  - 糷
+  - 紎
+  - 紟
+  - 紒
+  - 紽
+  - 紸
+  - 紶
+  - 紩
+  - 絇
+  - 紾
+  - 絘
+  - 絯
+  - 絓
+  - 絧
+  - 絏
+  - 絭
+  - 絫
+  - 綀
+  - 綍
+  - 絿
+  - 綅
+  - 絻
+  - 絼
+  - 綔
+  - 綷
+  - 緂
+  - 綪
+  - 緀
+  - 緅
+  - 緎
+  - 緆
+  - 緌
+  - 綯
+  - 綼
+  - 緷
+  - 緛
+  - 緪
+  - 緧
+  - 縃
+  - 緺
+  - 緶
+  - 緰
+  - 縗
+  - 縌
+  - 縓
+  - 縎
+  - 縜
+  - 縚
+  - 縏
+  - 縼
+  - 繂
+  - 縳
+  - 顈
+  - 繈
+  - 縸
+  - 縪
+  - 繉
+  - 繀
+  - 縩
+  - 緵
+  - 縰
+  - 縿
+  - 縶
+  - 繜
+  - 繐
+  - 繣
+  - 繘
+  - 繢
+  - 繟
+  - 繑
+  - 繠
+  - 繶
+  - 繵
+  - 繸
+  - 繷
+  - 繺
+  - 繲
+  - 繴
+  - 纀
+  - 纇
+  - 纋
+  - 纆
+  - 纑
+  - 纗
+  - 纚
+  - 缿
+  - 罊
+  - 罏
+  - 罜
+  - 罞
+  - 罝
+  - 罛
+  - 罣
+  - 罥
+  - 罦
+  - 罭
+  - 罫
+  - 罬
+  - 罻
+  - 罼
+  - 罺
+  - 罿
+  - 羃
+  - 羉
+  - 羍
+  - 羒
+  - 羜
+  - 羛
+  - 羢
+  - 羠
+  - 羦
+  - 羬
+  - 羭
+  - 羵
+  - 羳
+  - 羷
+  - 羺
+  - 羾
+  - 翋
+  - 翍
+  - 翐
+  - 翑
+  - 翇
+  - 翢
+  - 翣
+  - 翭
+  - 翪
+  - 翨
+  - 翴
+  - 翲
+  - 翽
+  - 翿
+  - 耟
+  - 耞
+  - 耡
+  - 耴
+  - 耾
+  - 耹
+  - 聇
+  - 聈
+  - 聑
+  - 聏
+  - 聝
+  - 肕
+  - 肙
+  - 肒
+  - 肣
+  - 肵
+  - 胘
+  - 胑
+  - 胐
+  - 胕
+  - 胉
+  - 胏
+  - 胹
+  - 胵
+  - 脁
+  - 胻
+  - 脀
+  - 胾
+  - 胔
+  - 脰
+  - 脥
+  - 脤
+  - 脙
+  - 脡
+  - 脕
+  - 脧
+  - 腃
+  - 腏
+  - 腄
+  - 腇
+  - 脽
+  - 腍
+  - 腤
+  - 腷
+  - 腜
+  - 腛
+  - 腢
+  - 腲
+  - 朡
+  - 腞
+  - 腶
+  - 膉
+  - 膆
+  - 膃
+  - 膇
+  - 膍
+  - 膌
+  - 膋
+  - 膟
+  - 膕
+  - 膢
+  - 膱
+  - 膹
+  - 膫
+  - 膰
+  - 膬
+  - 膴
+  - 膲
+  - 臇
+  - 膷
+  - 臄
+  - 臅
+  - 臒
+  - 臐
+  - 臗
+  - 臛
+  - 臡
+  - 臦
+  - 臩
+  - 臮
+  - 臲
+  - 臷
+  - 臸
+  - 臿
+  - 舋
+  - 舑
+  - 舕
+  - 舝
+  - 舡
+  - 舼
+  - 舽
+  - 艀
+  - 艂
+  - 艓
+  - 艒
+  - 艐
+  - 艑
+  - 艕
+  - 艛
+  - 艵
+  - 艼
+  - 芀
+  - 芐
+  - 芅
+  - 芓
+  - 芔
+  - 苀
+  - 芚
+  - 芵
+  - 芧
+  - 芞
+  - 芺
+  - 苙
+  - 苨
+  - 苖
+  - 苬
+  - 苲
+  - 苵
+  - 苶
+  - 茙
+  - 茥
+  - 茿
+  - 茦
+  - 茢
+  - 荂
+  - 茪
+  - 荍
+  - 茖
+  - 茤
+  - 茠
+  - 茩
+  - 茻
+  - 莐
+  - 莣
+  - 莍
+  - 荺
+  - 莤
+  - 荴
+  - 莏
+  - 莁
+  - 荵
+  - 莔
+  - 莃
+  - 莌
+  - 莋
+  - 荾
+  - 莥
+  - 菨
+  - 萒
+  - 菧
+  - 菤
+  - 菆
+  - 菣
+  - 菿
+  - 菋
+  - 菎
+  - 菵
+  - 萉
+  - 菞
+  - 菳
+  - 菕
+  - 蓱
+  - 萿
+  - 葹
+  - 葥
+  - 葀
+  - 葧
+  - 萰
+  - 葍
+  - 葽
+  - 蔇
+  - 葞
+  - 萷
+  - 萺
+  - 萴
+  - 葅
+  - 菙
+  - 葋
+  - 萯
+  - 葂
+  - 葟
+  - 葌
+  - 蓎
+  - 蒬
+  - 蒮
+  - 蒫
+  - 蒪
+  - 蒚
+  - 蒝
+  - 蓌
+  - 蒛
+  - 蒩
+  - 蒘
+  - 蒶
+  - 蒠
+  - 蔤
+  - 蔏
+  - 蔩
+  - 蔉
+  - 蔍
+  - 蔧
+  - 蔜
+  - 蓻
+  - 蓺
+  - 蓴
+  - 蔪
+  - 蓲
+  - 蓷
+  - 蓫
+  - 蔒
+  - 蓩
+  - 蔖
+  - 蓾
+  - 蔨
+  - 蔮
+  - 蔂
+  - 蓶
+  - 蔱
+  - 蓹
+  - 蔠
+  - 蔰
+  - 蕫
+  - 蕍
+  - 蕀
+  - 蕆
+  - 蕄
+  - 蕇
+  - 蕣
+  - 蕛
+  - 蕱
+  - 蕵
+  - 蕮
+  - 蕧
+  - 蕠
+  - 蕦
+  - 蕝
+  - 薃
+  - 薧
+  - 薕
+  - 薠
+  - 薋
+  - 薣
+  - 薚
+  - 蕼
+  - 薉
+  - 蕸
+  - 薎
+  - 薖
+  - 薍
+  - 薝
+  - 薂
+  - 藆
+  - 藀
+  - 藃
+  - 藂
+  - 薵
+  - 薽
+  - 藇
+  - 藄
+  - 藋
+  - 藈
+  - 藅
+  - 薱
+  - 薶
+  - 藒
+  - 藫
+  - 藱
+  - 藙
+  - 藡
+  - 藚
+  - 藗
+  - 藲
+  - 藬
+  - 藘
+  - 藣
+  - 藑
+  - 藰
+  - 蘁
+  - 藾
+  - 蘛
+  - 蘉
+  - 蘌
+  - 蘪
+  - 蘦
+  - 蘟
+  - 蘣
+  - 蘜
+  - 蘙
+  - 蘮
+  - 蘡
+  - 蘠
+  - 蘥
+  - 蘴
+  - 蘳
+  - 蘬
+  - 虀
+  - 蘹
+  - 蘱
+  - 蘻
+  - 蘾
+  - 虃
+  - 虆
+  - 虇
+  - 虈
+  - 虌
+  - 虋
+  - 虙
+  - 虡
+  - 虣
+  - 虩
+  - 虪
+  - 虰
+  - 虭
+  - 虴
+  - 蚑
+  - 蚞
+  - 蚇
+  - 蚗
+  - 蚚
+  - 蚅
+  - 蚥
+  - 蚙
+  - 蚿
+  - 蚷
+  - 蛂
+  - 蛁
+  - 蛅
+  - 蛈
+  - 蚹
+  - 蚳
+  - 蚸
+  - 蛌
+  - 蚻
+  - 蛢
+  - 蛦
+  - 蛓
+  - 蛣
+  - 蛚
+  - 蛪
+  - 蛝
+  - 蛫
+  - 蛜
+  - 蛬
+  - 蛗
+  - 蜄
+  - 蛷
+  - 蜌
+  - 蛖
+  - 蛵
+  - 蜁
+  - 蛶
+  - 蜳
+  - 蝫
+  - 蜙
+  - 蝃
+  - 蜬
+  - 蝁
+  - 蝆
+  - 蜠
+  - 蜲
+  - 蜪
+  - 蜭
+  - 蜼
+  - 蜵
+  - 蝂
+  - 蜦
+  - 蜧
+  - 蜸
+  - 蜤
+  - 蜰
+  - 蝖
+  - 蝷
+  - 蟡
+  - 蝳
+  - 蝔
+  - 蝛
+  - 蝒
+  - 蝑
+  - 蝞
+  - 蝭
+  - 蝪
+  - 蝐
+  - 蝝
+  - 蝬
+  - 蝺
+  - 蝜
+  - 螛
+  - 螏
+  - 螓
+  - 螒
+  - 螁
+  - 螖
+  - 螘
+  - 蝹
+  - 螇
+  - 螑
+  - 螝
+  - 螜
+  - 螚
+  - 螪
+  - 螰
+  - 螹
+  - 螼
+  - 螮
+  - 蟉
+  - 蟃
+  - 蟂
+  - 螷
+  - 螴
+  - 螿
+  - 螸
+  - 蟞
+  - 蟧
+  - 蟦
+  - 蟢
+  - 蟟
+  - 蟤
+  - 蟔
+  - 蟓
+  - 蟭
+  - 蟘
+  - 螤
+  - 蟗
+  - 蟙
+  - 蠁
+  - 蟨
+  - 蠀
+  - 蟺
+  - 蠉
+  - 蠌
+  - 蟼
+  - 蠈
+  - 蟿
+  - 蠗
+  - 蠩
+  - 蠝
+  - 蠛
+  - 蠠
+  - 蠤
+  - 蠜
+  - 蠫
+  - 蠬
+  - 蠨
+  - 蠦
+  - 蠪
+  - 蠥
+  - 蠰
+  - 蠮
+  - 蠳
+  - 蠸
+  - 蠾
+  - 蠽
+  - 蠿
+  - 衁
+  - 衈
+  - 衋
+  - 衧
+  - 衪
+  - 衭
+  - 衶
+  - 袀
+  - 衱
+  - 衯
+  - 袃
+  - 袉
+  - 袕
+  - 袨
+  - 袚
+  - 袑
+  - 袡
+  - 袘
+  - 袧
+  - 袬
+  - 袌
+  - 袺
+  - 裗
+  - 袹
+  - 袸
+  - 裀
+  - 袶
+  - 袽
+  - 袲
+  - 裋
+  - 裍
+  - 裞
+  - 裚
+  - 裷
+  - 裧
+  - 裺
+  - 裮
+  - 裶
+  - 裯
+  - 裻
+  - 褁
+  - 褅
+  - 褋
+  - 褗
+  - 褆
+  - 褖
+  - 褑
+  - 褦
+  - 褮
+  - 褱
+  - 褢
+  - 褩
+  - 褵
+  - 褼
+  - 褾
+  - 襒
+  - 褷
+  - 襂
+  - 褽
+  - 襓
+  - 襋
+  - 襆
+  - 襐
+  - 襛
+  - 襗
+  - 襡
+  - 襘
+  - 襝
+  - 襣
+  - 襭
+  - 襩
+  - 襮
+  - 襳
+  - 襹
+  - 襺
+  - 覂
+  - 覅
+  - 覕
+  - 覛
+  - 覝
+  - 覢
+  - 覤
+  - 覣
+  - 覭
+  - 覮
+  - 覶
+  - 觓
+  - 觤
+  - 觡
+  - 觠
+  - 觢
+  - 觩
+  - 觰
+  - 觬
+  - 觲
+  - 觷
+  - 觺
+  - 觻
+  - 觼
+  - 觾
+  - 訑
+  - 訰
+  - 訧
+  - 訬
+  - 訞
+  - 詍
+  - 訹
+  - 詙
+  - 詀
+  - 詄
+  - 詅
+  - 訿
+  - 誂
+  - 詻
+  - 誃
+  - 誫
+  - 誙
+  - 誋
+  - 諆
+  - 誸
+  - 諔
+  - 諕
+  - 誻
+  - 諀
+  - 諅
+  - 諵
+  - 諝
+  - 諰
+  - 諈
+  - 謞
+  - 謘
+  - 謑
+  - 謋
+  - 謒
+  - 謕
+  - 謍
+  - 謈
+  - 謪
+  - 謧
+  - 謣
+  - 謰
+  - 謵
+  - 譇
+  - 謯
+  - 謱
+  - 謥
+  - 謷
+  - 謦
+  - 譐
+  - 譈
+  - 譊
+  - 譀
+  - 譋
+  - 譕
+  - 譑
+  - 譠
+  - 譪
+  - 譝
+  - 譨
+  - 譣
+  - 譥
+  - 譹
+  - 譸
+  - 譅
+  - 譺
+  - 譻
+  - 譾
+  - 讄
+  - 讂
+  - 讆
+  - 讋
+  - 讔
+  - 讘
+  - 讟
+  - 谹
+  - 谻
+  - 谽
+  - 谾
+  - 豃
+  - 豋
+  - 豍
+  - 豏
+  - 豗
+  - 豜
+  - 豝
+  - 豟
+  - 豥
+  - 豤
+  - 豦
+  - 豭
+  - 豰
+  - 豲
+  - 豱
+  - 豯
+  - 豵
+  - 豷
+  - 豶
+  - 豻
+  - 豽
+  - 貁
+  - 貀
+  - 貄
+  - 貏
+  - 貑
+  - 貕
+  - 貙
+  - 貗
+  - 貜
+  - 貣
+  - 貾
+  - 賌
+  - 賥
+  - 賟
+  - 賙
+  - 賵
+  - 賮
+  - 贆
+  - 贕
+  - 贙
+  - 赨
+  - 赩
+  - 赮
+  - 赸
+  - 趀
+  - 趌
+  - 趎
+  - 趏
+  - 趍
+  - 趓
+  - 趠
+  - 趜
+  - 趡
+  - 趥
+  - 趧
+  - 趬
+  - 趪
+  - 趭
+  - 趫
+  - 趮
+  - 趷
+  - 趹
+  - 跘
+  - 跓
+  - 跍
+  - 跇
+  - 跜
+  - 跕
+  - 跙
+  - 跈
+  - 跰
+  - 跠
+  - 跮
+  - 跦
+  - 跢
+  - 跧
+  - 跲
+  - 跫
+  - 踂
+  - 跿
+  - 踍
+  - 踃
+  - 踇
+  - 踆
+  - 跾
+  - 踠
+  - 踥
+  - 踤
+  - 踡
+  - 踕
+  - 踛
+  - 踖
+  - 踑
+  - 踙
+  - 踧
+  - 踘
+  - 踓
+  - 踳
+  - 踾
+  - 踸
+  - 踼
+  - 蹎
+  - 蹍
+  - 蹓
+  - 蹗
+  - 蹖
+  - 蹞
+  - 蹥
+  - 蹛
+  - 蹡
+  - 蹝
+  - 蹔
+  - 蹸
+  - 蹳
+  - 蹪
+  - 躆
+  - 躈
+  - 躖
+  - 躗
+  - 躟
+  - 躠
+  - 躤
+  - 躣
+  - 躩
+  - 躨
+  - 躽
+  - 軓
+  - 軘
+  - 軞
+  - 軯
+  - 軷
+  - 軦
+  - 軮
+  - 軥
+  - 軵
+  - 軧
+  - 軨
+  - 軶
+  - 軱
+  - 軬
+  - 輆
+  - 軿
+  - 輁
+  - 輀
+  - 輂
+  - 輐
+  - 輑
+  - 輤
+  - 輘
+  - 輚
+  - 輠
+  - 輣
+  - 輖
+  - 輗
+  - 輮
+  - 輵
+  - 輲
+  - 輹
+  - 輷
+  - 輴
+  - 轃
+  - 轇
+  - 轈
+  - 轒
+  - 轑
+  - 轏
+  - 轐
+  - 轓
+  - 轙
+  - 轖
+  - 轗
+  - 轕
+  - 轚
+  - 轞
+  - 轛
+  - 轠
+  - 辴
+  - 迉
+  - 迒
+  - 迋
+  - 迍
+  - 迖
+  - 迣
+  - 迡
+  - 迾
+  - 迿
+  - 逜
+  - 逿
+  - 遝
+  - 遳
+  - 遰
+  - 遻
+  - 邆
+  - 邅
+  - 遾
+  - 邍
+  - 邔
+  - 邟
+  - 邥
+  - 邞
+  - 邧
+  - 郱
+  - 郕
+  - 郖
+  - 郠
+  - 郙
+  - 郣
+  - 郥
+  - 郘
+  - 郰
+  - 郲
+  - 郔
+  - 鄬
+  - 郼
+  - 鄈
+  - 郹
+  - 郻
+  - 鄁
+  - 鄇
+  - 郺
+  - 鄐
+  - 鄍
+  - 鄏
+  - 鄎
+  - 鄟
+  - 鄝
+  - 鄡
+  - 鄛
+  - 鄨
+  - 鄪
+  - 鄦
+  - 鄮
+  - 鄵
+  - 鄸
+  - 鄻
+  - 鄾
+  - 酀
+  - 酁
+  - 酄
+  - 酇
+  - 酖
+  - 酘
+  - 酓
+  - 酟
+  - 酳
+  - 醆
+  - 醊
+  - 醓
+  - 醙
+  - 醟
+  - 醥
+  - 醧
+  - 醰
+  - 醱
+  - 醷
+  - 醲
+  - 醳
+  - 醹
+  - 醽
+  - 釂
+  - 釃
+  - 釢
+  - 釱
+  - 釳
+  - 釸
+  - 鈚
+  - 鈌
+  - 鈒
+  - 釽
+  - 鈆
+  - 鉒
+  - 鉠
+  - 鉯
+  - 鈶
+  - 鉼
+  - 銤
+  - 銛
+  - 銔
+  - 鉹
+  - 銗
+  - 鋄
+  - 鋀
+  - 鋟
+  - 鋘
+  - 鋩
+  - 鋝
+  - 鋂
+  - 鋊
+  - 錧
+  - 錼
+  - 錭
+  - 錎
+  - 鋋
+  - 鎡
+  - 鎃
+  - 鎯
+  - 鍖
+  - 鍜
+  - 鍐
+  - 鍭
+  - 鍌
+  - 鎒
+  - 鎷
+  - 鎝
+  - 鎉
+  - 鎎
+  - 鎞
+  - 鏏
+  - 鏂
+  - 鏚
+  - 鏬
+  - 鏙
+  - 鐋
+  - 鐏
+  - 鏾
+  - 鐕
+  - 鐨
+  - 鐍
+  - 鐀
+  - 鐎
+  - 鐖
+  - 鐻
+  - 鐶
+  - 鑐
+  - 鑋
+  - 鑕
+  - 鑮
+  - 鑯
+  - 钂
+  - 钀
+  - 钁
+  - 钃
+  - 镺
+  - 镻
+  - 镼
+  - 镽
+  - 閈
+  - 閍
+  - 閺
+  - 閵
+  - 闀
+  - 闉
+  - 闅
+  - 閷
+  - 闒
+  - 闑
+  - 闚
+  - 闛
+  - 闠
+  - 闟
+  - 闤
+  - 阞
+  - 阢
+  - 阤
+  - 阠
+  - 阰
+  - 阹
+  - 阸
+  - 阺
+  - 陏
+  - 陓
+  - 陊
+  - 陼
+  - 陭
+  - 陫
+  - 隇
+  - 陾
+  - 隉
+  - 隒
+  - 隓
+  - 隞
+  - 隤
+  - 隿
+  - 雂
+  - 雈
+  - 雓
+  - 雔
+  - 雗
+  - 雚
+  - 雟
+  - 雘
+  - 雺
+  - 雽
+  - 雿
+  - 霂
+  - 霋
+  - 霒
+  - 霐
+  - 霠
+  - 霣
+  - 霢
+  - 霩
+  - 霫
+  - 霬
+  - 霮
+  - 霵
+  - 霿
+  - 靆
+  - 靃
+  - 靪
+  - 靮
+  - 靷
+  - 靲
+  - 靾
+  - 鞃
+  - 鞀
+  - 鞂
+  - 靻
+  - 鞊
+  - 鞎
+  - 鞈
+  - 鞙
+  - 鞗
+  - 鞚
+  - 鞜
+  - 鞤
+  - 鞪
+  - 鞷
+  - 鞶
+  - 鞹
+  - 鞻
+  - 鞿
+  - 韄
+  - 韅
+  - 韇
+  - 韎
+  - 韐
+  - 韏
+  - 韕
+  - 韔
+  - 韗
+  - 韝
+  - 韟
+  - 韣
+  - 韥
+  - 韰
+  - 韱
+  - 韹
+  - 韽
+  - 頄
+  - 頖
+  - 頞
+  - 頝
+  - 頩
+  - 頨
+  - 頯
+  - 頲
+  - 顁
+  - 顄
+  - 顊
+  - 顉
+  - 顅
+  - 顐
+  - 顑
+  - 顜
+  - 顝
+  - 顠
+  - 顣
+  - 顟
+  - 顤
+  - 顪
+  - 顩
+  - 顲
+  - 颬
+  - 颲
+  - 颸
+  - 颽
+  - 颻
+  - 颾
+  - 飁
+  - 飂
+  - 飉
+  - 飋
+  - 飌
+  - 飣
+  - 飶
+  - 餂
+  - 餀
+  - 飺
+  - 餔
+  - 餖
+  - 餕
+  - 餤
+  - 餟
+  - 餥
+  - 餫
+  - 餪
+  - 餲
+  - 餯
+  - 餭
+  - 餱
+  - 餰
+  - 饁
+  - 饇
+  - 饐
+  - 饎
+  - 饙
+  - 饘
+  - 饛
+  - 饡
+  - 馣
+  - 馲
+  - 馰
+  - 馵
+  - 馻
+  - 馺
+  - 駂
+  - 馽
+  - 駜
+  - 駍
+  - 駏
+  - 駎
+  - 駖
+  - 駮
+  - 駬
+  - 駥
+  - 駤
+  - 駣
+  - 駩
+  - 駺
+  - 駴
+  - 駷
+  - 駹
+  - 駶
+  - 駻
+  - 駽
+  - 駾
+  - 騃
+  - 騉
+  - 騑
+  - 騊
+  - 騇
+  - 騚
+  - 騕
+  - 騥
+  - 騝
+  - 騛
+  - 騢
+  - 騠
+  - 騧
+  - 騞
+  - 騜
+  - 騵
+  - 騲
+  - 騴
+  - 騱
+  - 騬
+  - 騪
+  - 騩
+  - 騹
+  - 騽
+  - 驆
+  - 騺
+  - 驓
+  - 驔
+  - 驈
+  - 驉
+  - 驖
+  - 驞
+  - 驠
+  - 驦
+  - 驨
+  - 骭
+  - 骫
+  - 骹
+  - 骿
+  - 骴
+  - 骾
+  - 髇
+  - 髊
+  - 髆
+  - 髍
+  - 髐
+  - 髟
+  - 髧
+  - 髬
+  - 髳
+  - 髶
+  - 髺
+  - 髾
+  - 鬁
+  - 髼
+  - 鬋
+  - 鬊
+  - 鬎
+  - 鬌
+  - 鬐
+  - 鬕
+  - 鬗
+  - 鬖
+  - 鬙
+  - 鬞
+  - 鬠
+  - 鬤
+  - 鬫
+  - 鬳
+  - 鬵
+  - 鬺
+  - 鬾
+  - 鬿
+  - 魊
+  - 魌
+  - 魖
+  - 魠
+  - 魡
+  - 魧
+  - 魱
+  - 魦
+  - 魶
+  - 魵
+  - 鮅
+  - 鮇
+  - 魼
+  - 魾
+  - 魻
+  - 鮂
+  - 鮚
+  - 鮞
+  - 鮛
+  - 鮦
+  - 鮥
+  - 鮤
+  - 鮆
+  - 鯆
+  - 鮿
+  - 鮵
+  - 鯈
+  - 鯫
+  - 鯠
+  - 鯞
+  - 鯦
+  - 鯬
+  - 鰌
+  - 鰋
+  - 鰅
+  - 鯸
+  - 鰫
+  - 鰝
+  - 鰬
+  - 鱆
+  - 鰿
+  - 鱄
+  - 鱁
+  - 鰴
+  - 鱐
+  - 鱍
+  - 鱋
+  - 鱕
+  - 鱦
+  - 鱢
+  - 鱞
+  - 鱴
+  - 鱳
+  - 鱹
+  - 鳦
+  - 鳪
+  - 鳭
+  - 鳱
+  - 鳵
+  - 鳼
+  - 鳺
+  - 鳿
+  - 鳷
+  - 鴀
+  - 鳹
+  - 鳻
+  - 鴅
+  - 鴃
+  - 鴥
+  - 鴠
+  - 鴔
+  - 鴩
+  - 鴘
+  - 鴢
+  - 鴐
+  - 鴳
+  - 鵁
+  - 鵧
+  - 鴶
+  - 鴮
+  - 鴱
+  - 鴸
+  - 鵅
+  - 鵃
+  - 鴾
+  - 鵀
+  - 鴽
+  - 鵏
+  - 鵊
+  - 鵛
+  - 鵋
+  - 鵖
+  - 鵌
+  - 鵗
+  - 鵔
+  - 鵷
+  - 鶁
+  - 鶊
+  - 鶄
+  - 鶈
+  - 鵱
+  - 鶀
+  - 鵸
+  - 鶋
+  - 鶌
+  - 鵽
+  - 鵫
+  - 鵴
+  - 鵩
+  - 鶅
+  - 鵳
+  - 鵻
+  - 鶂
+  - 鵹
+  - 鶟
+  - 鶙
+  - 鶤
+  - 鶝
+  - 鶐
+  - 鶛
+  - 鶠
+  - 鶔
+  - 鶜
+  - 鶪
+  - 鶗
+  - 鶢
+  - 鶨
+  - 鶞
+  - 鶣
+  - 鶖
+  - 鶷
+  - 鶶
+  - 鷁
+  - 鷇
+  - 鷊
+  - 鷏
+  - 鶾
+  - 鷅
+  - 鷃
+  - 鶵
+  - 鷈
+  - 鶱
+  - 鶭
+  - 鷛
+  - 鷒
+  - 鷞
+  - 鷋
+  - 鷐
+  - 鷜
+  - 鷑
+  - 鷩
+  - 鷘
+  - 鷖
+  - 鷵
+  - 鷕
+  - 鷻
+  - 鷷
+  - 鷣
+  - 鷤
+  - 鷶
+  - 鷡
+  - 鷮
+  - 鷢
+  - 鸂
+  - 鷾
+  - 鸇
+  - 鸃
+  - 鸆
+  - 鸅
+  - 鸀
+  - 鸁
+  - 鸉
+  - 鷿
+  - 鷽
+  - 鸄
+  - 鸋
+  - 鸍
+  - 鸏
+  - 鸒
+  - 鸔
+  - 鸓
+  - 鸗
+  - 鸙
+  - 鹺
+  - 麃
+  - 麆
+  - 麉
+  - 麎
+  - 麌
+  - 麔
+  - 麙
+  - 麛
+  - 麚
+  - 麜
+  - 麠
+  - 麡
+  - 麧
+  - 麮
+  - 麰
+  - 麶
+  - 麷
+  - 黀
+  - 黂
+  - 黈
+  - 黓
+  - 黕
+  - 黖
+  - 黚
+  - 黤
+  - 黫
+  - 黮
+  - 黭
+  - 黰
+  - 黳
+  - 黵
+  - 黺
+  - 鼁
+  - 鼀
+  - 鼆
+  - 鼊
+  - 鼏
+  - 鼖
+  - 鼛
+  - 鼘
+  - 鼜
+  - 鼤
+  - 鼣
+  - 鼥
+  - 鼪
+  - 鼨
+  - 鼭
+  - 鼰
+  - 鼮
+  - 鼵
+  - 鼳
+  - 鼲
+  - 鼸
+  - 鼶
+  - 齀
+  - 齂
+  - 齃
+  - 齌
+  - 齍
+  - 齎
+  - 齖
+  - 齗
+  - 齘
+  - 齛
+  - 齠
+  - 齞
+  - 齝
+  - 齥
+  - 齤
+  - 齫
+  - 齱
+  - 齰
+  - 齮
+  - 齯
+  - 齴
+  - 齵
+  - 齸
+  - 齻
+  - 齺
+  - 齹
+  - 齾
+  - 龒
+  - 龤
+  - 堔
+  - 礂
+  - 蒏
+  - 蒆
+  - 兙
+  - 兛
+  - 兞
+  - 兝
+  - 兡
+  - 兣
+  - 嗧
+  - 瓩
+  - 忼
+  - 擡
+  - 氊
+  - 穇
+  - 擧
+  - 譌
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - °
+  - ²
+  - ´
+  - ½
+  - Á
+  - Ä
+  - Å
+  - Ç
+  - È
+  - É
+  - Í
+  - Ó
+  - Ö
+  - ×
+  - Ü
+  - ß
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - í
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ú
+  - û
+  - ü
+  - ý
+  - ā
+  - ă
+  - ą
+  - ć
+  - Č
+  - č
+  - đ
+  - ē
+  - ė
+  - ę
+  - ğ
+  - ī
+  - ı
+  - Ł
+  - ł
+  - ń
+  - ň
+  - ō
+  - ř
+  - Ş
+  - ş
+  - Š
+  - š
+  - ţ
+  - ū
+  - ż
+  - Ž
+  - ž
+  - Ș
+  - ș
+  - ț
+  - Δ
+  - α
+  - λ
+  - μ
+  - φ
+  - Г
+  - О
+  - а
+  - в
+  - л
+  - о
+  - р
+  - с
+  - т
+  - я
+  - ồ
+  - —
+  - ―
+  - ’
+  - “
+  - ”
+  - …
+  - ℃
+  - →
+  - ∇
+  - −
+  - ■
+  - ☆
+  - 、
+  - 。
+  - 々
+  - 〆
+  - 〈
+  - 〉
+  - 「
+  - 」
+  - 『
+  - 』
+  - 〔
+  - 〕
+  - 〜
+  - ！
+  - ＃
+  - ％
+  - ＆
+  - （
+  - ）
+  - ＋
+  - ，
+  - －
+  - ．
+  - ／
+  - ０
+  - １
+  - ２
+  - ３
+  - ４
+  - ５
+  - ６
+  - ７
+  - ８
+  - ９
+  - ：
+  - ；
+  - ＝
+  - ？
+  - ＠
+  - Ａ
+  - Ｂ
+  - Ｃ
+  - Ｄ
+  - Ｅ
+  - Ｆ
+  - Ｇ
+  - Ｈ
+  - Ｉ
+  - Ｊ
+  - Ｋ
+  - Ｌ
+  - Ｍ
+  - Ｎ
+  - Ｏ
+  - Ｐ
+  - Ｒ
+  - Ｓ
+  - Ｔ
+  - Ｕ
+  - Ｖ
+  - Ｗ
+  - Ｘ
+  - Ｚ
+  - ａ
+  - ｂ
+  - ｃ
+  - ｄ
+  - ｅ
+  - ｆ
+  - ｇ
+  - ｈ
+  - ｉ
+  - ｊ
+  - ｋ
+  - ｌ
+  - ｍ
+  - ｎ
+  - ｏ
+  - ｐ
+  - ｑ
+  - ｒ
+  - ｓ
+  - ｔ
+  - ｕ
+  - ｖ
+  - ｗ
+  - ｘ
+  - ｙ
+  - ｚ
+  - ～
+  - ･
+  - ǎ
+  - ǒ
+  - ě
+  - ǐ
+  - ì
+  - ǔ
+  - ù
+  - ǖ
+  - ǘ
+  - ǚ
+  - ǜ
+  - 【
+  - 】
+  - 《
+  - 》
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ⊕
+  - ⊖
+  - ⊗
+  - ⊘
+  - ⊙
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ⊎
+  - ⊓
+  - ⊔
+  - ≠
+  - ≈
+  - ≡
+  - ≤
+  - ≥
+  - ≪
+  - ≫
+  - ≲
+  - ≳
+  - ≶
+  - ≷
+  - ≺
+  - ≻
+  - ≼
+  - ≽
+  - ∈
+  - ∉
+  - ⊂
+  - ⊃
+  - ⊆
+  - ⊇
+  - ⊄
+  - ⊅
+  - ∅
+  - ∖
+  - ∁
+  - ∆
+  - ∧
+  - ∨
+  - ¬
+  - ⊻
+  - ⊼
+  - ⊽
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ≄
+  - ≅
+  - ≃
+  - ≦
+  - ≧
+  - ⊈
+  - ⊉
+  - ⊢
+  - ⊤
+  - ⊨
+  - ⊧
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ￥
+  - ₿
+  - ↑
+  - ↓
+  - ↕
+  - ↖
+  - ↗
+  - ↘
+  - ↙
+  - ↺
+  - ↻
+  - ↼
+  - ↽
+  - ↾
+  - ↿
+  - ⇀
+  - ⇁
+  - ⇂
+  - ⇃
+  - ⇋
+  - ⇌
+  - ª
+  - º
+  - ⁰
+  - ¹
+  - ³
+  - ⁴
+  - ⁵
+  - ⁶
+  - ⁷
+  - ⁸
+  - ⁹
+  - ⁺
+  - ⁻
+  - ⁼
+  - ⁽
+  - ⁾
+  - ⁿ
+  - ₀
+  - ₁
+  - ₂
+  - ₃
+  - ₄
+  - ₅
+  - ₆
+  - ₇
+  - ₈
+  - ₉
+  - ₊
+  - ₋
+  - ₌
+  - ₍
+  - ₎
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ☰
+  - ☱
+  - ☲
+  - ☳
+  - ☴
+  - ☵
+  - ☶
+  - ☷
+  - ♀
+  - ♂
+  - ♳
+  - ♴
+  - ♵
+  - ♶
+  - ♷
+  - ♸
+  - ♹
+  - ♺
+  - ♩
+  - ♪
+  - ♫
+  - ♬
+  - ⚪
+  - ⚫
+  - ⚬
+  - ✶
+  - ✷
+  - ✸
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ⏀
+  - ⏁
+  - ⏂
+  - ⏃
+  - ⏄
+  - ⏅
+  - ⏆
+  - ⏇
+  - ⏈
+  - ⏉
+  - ⏊
+  - ⏋
+  - ⏌
+  - ⏚
+  - ⏴
+  - ⏵
+  - ⏶
+  - ⏷
+  - ⏸
+  - ⏹
+  - ⏺
+  - ⏻
+  - ⏼
+  - Α
+  - Β
+  - Γ
+  - Ε
+  - Ζ
+  - Η
+  - Θ
+  - Ι
+  - Κ
+  - Λ
+  - Μ
+  - Ν
+  - Ξ
+  - Ο
+  - Π
+  - Ρ
+  - Σ
+  - Τ
+  - Υ
+  - Φ
+  - Χ
+  - Ψ
+  - β
+  - γ
+  - δ
+  - ε
+  - ζ
+  - η
+  - θ
+  - ι
+  - κ
+  - ν
+  - ξ
+  - ο
+  - π
+  - ρ
+  - σ
+  - τ
+  - υ
+  - χ
+  - ψ
+  - ω
+  - ϐ
+  - ϑ
+  - ϒ
+  - ϕ
+  - █
+  - ϖ
+  - ϰ
+  - ϱ
+  - ϴ
+  - ϵ
+  - ϝ
+  - Ϟ
+  - ϟ
+  - Ϡ
+  - ϡ
+  - Ϣ
+  - ϣ
+  - Ϥ
+  - ϥ
+  - Ϧ
+  - ϧ
+  - Ϩ
+  - ϩ
+  - Ϫ
+  - ϫ
+  - Ϭ
+  - ϭ
+  - Ϯ
+  - ϯ
+  - ∸
+  - ∹
+  - ∺
+  - ∻
+  - ∽
+  - ∾
+  - ∿
+  - ≀
+  - ≁
+  - ≂
+  - ≆
+  - ≇
+  - ≉
+  - ≊
+  - ≋
+  - ≌
+  - ≍
+  - ≎
+  - ≏
+  - ≐
+  - ≑
+  - ≒
+  - ≓
+  - ≔
+  - ≕
+  - ≖
+  - ≗
+  - ≘
+  - ≙
+  - ≚
+  - ≛
+  - ≜
+  - ≝
+  - ≞
+  - ≟
+  - ≢
+  - ≣
+  - ≨
+  - ≩
+  - ≬
+  - ≭
+  - ≮
+  - ≯
+  - ≰
+  - ≱
+  - ≴
+  - ≵
+  - ≸
+  - ≹
+  - ≾
+  - ≿
+  - ⊀
+  - ⊁
+  - ⊊
+  - ⊋
+  - ⊌
+  - ⊍
+  - ⊏
+  - ⊐
+  - ⊑
+  - ⊒
+  - ⊚
+  - ⊛
+  - ⊜
+  - ⊝
+  - ⊞
+  - ⊟
+  - ⊠
+  - ⊡
+  - ⊣
+  - ⊦
+  - ⊩
+  - ⊪
+  - ⊫
+  - ⊬
+  - ⊭
+  - ⊮
+  - ⊯
+  - ⊰
+  - ⊱
+  - ⊲
+  - ⊳
+  - ⊴
+  - ⊵
+  - ⊶
+  - ⊷
+  - ⊸
+  - ⊹
+  - ⊺
+  - ℎ
+  - ℘
+  - ℜ
+  - ℑ
+  - ℵ
+  - ℶ
+  - ℷ
+  - ℸ
+  - ⌬
+  - ⌭
+  - ⌮
+  - ⌯
+  - ⎔
+  - ¤
+  - ₠
+  - ₡
+  - ₢
+  - ₣
+  - ₤
+  - ₥
+  - ₦
+  - ₧
+  - ₨
+  - ₩
+  - ₪
+  - ₫
+  - ₭
+  - ₮
+  - ₯
+  - ₰
+  - ₱
+  - ₲
+  - ₳
+  - ₴
+  - ₵
+  - ₶
+  - ₷
+  - ₸
+  - ₹
+  - ₺
+  - ₻
+  - ₼
+  - ₽
+  - ₾
+  - ↚
+  - ↛
+  - ↜
+  - ↝
+  - ↞
+  - ↟
+  - ↠
+  - ↡
+  - ↢
+  - ↣
+  - ↤
+  - ↥
+  - ↦
+  - ↧
+  - ↨
+  - ↩
+  - ↪
+  - ↫
+  - ↬
+  - ↭
+  - ↮
+  - ↯
+  - ↰
+  - ↱
+  - ↲
+  - ↳
+  - ↴
+  - ↵
+  - ↶
+  - ↷
+  - ↸
+  - ↹
+  - ⇄
+  - ⇅
+  - ⇆
+  - ⇇
+  - ⇈
+  - ⇉
+  - ⇊
+  - ⇍
+  - ⇎
+  - ⇏
+  - ⇑
+  - ⇓
+  - ⇕
+  - ⇖
+  - ⇗
+  - ⇘
+  - ⇙
+  - ⇚
+  - ⇛
+  - ⇜
+  - ⇝
+  - ⇞
+  - ⇟
+  - ⇠
+  - ⇡
+  - ⇢
+  - ⇣
+  - ⇤
+  - ⇥
+  - ⇦
+  - ⇧
+  - ⇨
+  - ⇩
+  - ⇪
+  - ⇫
+  - ⇬
+  - ⇭
+  - ⇮
+  - ⇯
+  - ⇰
+  - ⇱
+  - ⇲
+  - ⇳
+  - ⇴
+  - ⇵
+  - ⇶
+  - ⇷
+  - ⇸
+  - ⇹
+  - ⇺
+  - ⇻
+  - ⇼
+  - ⇽
+  - ⇾
+  - ⇿
+  - ↀ
+  - ↁ
+  - ↂ
+  - ☀
+  - ☁
+  - ☂
+  - ☃
+  - ☄
+  - ★
+  - ☇
+  - ☈
+  - ☉
+  - ☊
+  - ☋
+  - ☌
+  - ☍
+  - ☎
+  - ☏
+  - ☐
+  - ☑
+  - ☒
+  - ☓
+  - ☔
+  - ☕
+  - ☖
+  - ☗
+  - ☘
+  - ☙
+  - ☚
+  - ☛
+  - ☜
+  - ☝
+  - ☞
+  - ☟
+  - ☠
+  - ☡
+  - ☢
+  - ☣
+  - ☤
+  - ☥
+  - ☦
+  - ☧
+  - ☨
+  - ☩
+  - ☪
+  - ☫
+  - ☬
+  - ☭
+  - ☮
+  - ☯
+  - ☸
+  - ☹
+  - ☺
+  - ☻
+  - ☼
+  - ☽
+  - ☾
+  - ☿
+  - ♁
+  - ♃
+  - ♄
+  - ♅
+  - ♆
+  - ♇
+  - ♔
+  - ♕
+  - ♖
+  - ♗
+  - ♘
+  - ♙
+  - ♚
+  - ♛
+  - ♜
+  - ♝
+  - ♞
+  - ♟
+  - ♠
+  - ♡
+  - ♢
+  - ♣
+  - ♤
+  - ♥
+  - ♦
+  - ♧
+  - ♨
+  - ♭
+  - ♮
+  - ♯
+  - ♰
+  - ♱
+  - ♲
+  - ♻
+  - ♼
+  - ♽
+  - ♾
+  - ⚀
+  - ⚁
+  - ⚂
+  - ⚃
+  - ⚄
+  - ⚅
+  - ⚆
+  - ⚇
+  - ⚈
+  - ⚉
+  - ⚊
+  - ⚋
+  - ⚌
+  - ⚍
+  - ⚎
+  - ⚏
+  - ⚐
+  - ⚑
+  - ⚒
+  - ⚓
+  - ⚔
+  - ⚕
+  - ⚖
+  - ⚗
+  - ⚘
+  - ⚙
+  - ⚚
+  - ⚛
+  - ⚜
+  - ⚝
+  - ⚞
+  - ⚟
+  - ⚠
+  - ⚡
+  - ⚢
+  - ⚣
+  - ⚤
+  - ⚥
+  - ⚦
+  - ⚧
+  - ⚨
+  - ⚩
+  - ⚭
+  - ⚮
+  - ⚯
+  - ⚰
+  - ⚱
+  - ⚲
+  - ⚳
+  - ⚴
+  - ⚵
+  - ⚶
+  - ⚷
+  - ⚸
+  - ⚹
+  - ⚺
+  - ⚻
+  - ⚼
+  - ⚿
+  - ⛀
+  - ⛁
+  - ⛂
+  - ⛃
+  - ⛆
+  - ⛇
+  - ⛈
+  - ⛉
+  - ⛊
+  - ⛋
+  - ⛌
+  - ⛍
+  - ⛏
+  - ⛐
+  - ⛑
+  - ⛒
+  - ⛓
+  - ⛕
+  - ⛖
+  - ⛗
+  - ⛘
+  - ⛙
+  - ⛚
+  - ⛛
+  - ⛜
+  - ⛝
+  - ⛞
+  - ⛠
+  - ⛡
+  - ⛢
+  - ⛣
+  - ⛤
+  - ⛥
+  - ⛦
+  - ⛧
+  - ⛨
+  - ⛩
+  - ⛪
+  - ⛫
+  - ⛬
+  - ⛭
+  - ⛮
+  - ⛯
+  - ⛶
+  - ⛾
+  - ⛿
+  - ✆
+  - ✇
+  - ✈
+  - ✉
+  - ✌
+  - ✍
+  - ✎
+  - ✏
+  - ✐
+  - ✑
+  - ✒
+  - ✓
+  - ✔
+  - ✕
+  - ✙
+  - ✚
+  - ✛
+  - ✜
+  - ✝
+  - ✞
+  - ✟
+  - ✠
+  - ✡
+  - ✢
+  - ✣
+  - ✤
+  - ✥
+  - ✦
+  - ✧
+  - ✩
+  - ✪
+  - ✫
+  - ✬
+  - ✭
+  - ✮
+  - ✯
+  - ✰
+  - ✱
+  - ✲
+  - ✳
+  - ✴
+  - ✵
+  - ✹
+  - ✺
+  - ✻
+  - ✼
+  - ✽
+  - ✾
+  - ✿
+  - ❀
+  - ❁
+  - ❂
+  - ❃
+  - ❄
+  - ❅
+  - ❆
+  - ❇
+  - ❈
+  - ❉
+  - ❊
+  - ❋
+  - ❍
+  - ❏
+  - ❐
+  - ❑
+  - ❒
+  - ❖
+  - ❘
+  - ❙
+  - ❚
+  - ❛
+  - ❜
+  - ❝
+  - ❞
+  - ❡
+  - ❢
+  - ❣
+  - ❤
+  - ❥
+  - ❦
+  - ❧
+  - ❨
+  - ❩
+  - ❪
+  - ❫
+  - ❬
+  - ❭
+  - ❮
+  - ❯
+  - ❰
+  - ❱
+  - ❲
+  - ❳
+  - ❴
+  - ❵
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ➔
+  - ➕
+  - ➖
+  - ➗
+  - ➘
+  - ➙
+  - ➚
+  - ➛
+  - ➜
+  - ➝
+  - ➞
+  - ➟
+  - ➠
+  - ➡
+  - ➢
+  - ➣
+  - ➤
+  - ➥
+  - ➦
+  - ➧
+  - ➨
+  - ➩
+  - ➪
+  - ➫
+  - ➬
+  - ➭
+  - ➮
+  - ➯
+  - ➰
+  - ➱
+  - ➲
+  - ➳
+  - ➴
+  - ➵
+  - ➶
+  - ➷
+  - ➸
+  - ➹
+  - ➺
+  - ➻
+  - ➼
+  - ➽
+  - ➾
+  - ➿
+  - ⌘
+  - ⌥
+  - ⌃
+  - ⎋
+  - ⌫
+  - ⌦
+  - ⏏
+  - ⌤
+  - ⌧
+  - ⌨
+  - ⎆
+  - ⎇
+  - ⎈
+  - ⎉
+  - ⎊
+  - ⎌
+  - ⎍
+  - ⎎
+  - ⎏
+  - ⎐
+  - ⎑
+  - ⎒
+  - ⎓
+  - ⎕
+  - ⎖
+  - ⎗
+  - ⎘
+  - ⎙
+  - ⎚
+  - ⎛
+  - ⎜
+  - ⎝
+  - ⎞
+  - ⎟
+  - ⎠
+  - ⎡
+  - ⎢
+  - ⎣
+  - ⎤
+  - ⎥
+  - ⎦
+  - ⎧
+  - ⎨
+  - ⎩
+  - ⎪
+  - ⎫
+  - ⎬
+  - ⎭
+  - ⎮
+  - ⎯
+  - ⎰
+  - ⎱
+  - ⎲
+  - ⎳
+  - ⎴
+  - ⎵
+  - ⎶
+  - ⎷
+  - ⎸
+  - ⎹
+  - ⎺
+  - ⎻
+  - ⎼
+  - ⎽
+  - ⎾
+  - ⎿
+  - ⏍
+  - ⏎
+  - ⏐
+  - ⏑
+  - ⏒
+  - ⏓
+  - ⏔
+  - ⏕
+  - ⏖
+  - ⏗
+  - ⏘
+  - ⏙
+  - ⏛
+  - ⏜
+  - ⏝
+  - ⏞
+  - ⏟
+  - ⏠
+  - ⏡
+  - ⏢
+  - ⏣
+  - ⏤
+  - ⏥
+  - ⏦
+  - ⏧
+  - ⏨
+  - ⏭
+  - ⏮
+  - ⏯
+  - ⏱
+  - ⏲
+  - ▲
+  - ▽
+  - ◐
+  - ⏽
+  - ⏾
+  - ⏿
+  - ɐ
+  - ɑ
+  - ɒ
+  - ɓ
+  - ɔ
+  - ɕ
+  - ɖ
+  - ɗ
+  - ɘ
+  - ə
+  - ɚ
+  - ɛ
+  - ɜ
+  - ɝ
+  - ɞ
+  - ɟ
+  - ɠ
+  - ɡ
+  - ɢ
+  - ɣ
+  - ɤ
+  - ɥ
+  - ɦ
+  - ɧ
+  - ɨ
+  - ɩ
+  - ɪ
+  - ɫ
+  - ɬ
+  - ɭ
+  - ɮ
+  - ɯ
+  - ɰ
+  - ɱ
+  - ɲ
+  - ɳ
+  - ɴ
+  - ɵ
+  - ɶ
+  - ɷ
+  - ɸ
+  - ɹ
+  - ɺ
+  - ɻ
+  - ɼ
+  - ɽ
+  - ɾ
+  - ɿ
+  - ʀ
+  - ʁ
+  - ʂ
+  - ʃ
+  - ʄ
+  - ʅ
+  - ʆ
+  - ʇ
+  - ʈ
+  - ʉ
+  - ʊ
+  - ʋ
+  - ʌ
+  - ʍ
+  - ʎ
+  - ʏ
+  - ʐ
+  - ʑ
+  - ʒ
+  - ʓ
+  - ʔ
+  - ʕ
+  - ʖ
+  - ʗ
+  - ʘ
+  - ʙ
+  - ʚ
+  - ʛ
+  - ʜ
+  - ʝ
+  - ʞ
+  - ʟ
+  - ʠ
+  - ʡ
+  - ʢ
+  - ʣ
+  - ʤ
+  - ʥ
+  - ʦ
+  - ʧ
+  - ʨ
+  - ʩ
+  - ʪ
+  - ʫ
+  - ʬ
+  - ʭ
+  - ʮ
+  - ʯ
+  - ━
+  - Ǝ
+  - Ã
+  - ●
+  - ▶
+  - ｜
+  - 𝑢
+  - 〖
+  - 〗
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ✘
+  - Е
+  - ◉
+  - 〒
+  - 𝒱
+  - 𝜆
+  - ⟹
+  - ﹪
+  - ◊
+  - ╆
+  - 오
+  - ˂
+  - 〉
+  - 𝝎
+  - ▪
+  - △
+  - ▁
+  - ◼
+  - 〇
+  - ▷
+  - ▬
+  - 𝒮
+  - †
+  - ₒ
+  - ⼁
+  - 〵
+  - ⭐
+  - ╳
+  - ⟶
+  - 으
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - 丄
+  - ︾
+  - ◥
+  - ‖
+  - 𝜌
+  - ⅼ
+  - ▼
+  - ⁎
+  - ﹏
+  - 😁
+  - 😂
+  - 😃
+  - 😄
+  - 😅
+  - 😆
+  - 😉
+  - 😊
+  - 😋
+  - 😌
+  - 😍
+  - 😏
+  - 😒
+  - 😓
+  - 😔
+  - 😖
+  - 😘
+  - 😚
+  - 😜
+  - 😝
+  - 😞
+  - 😠
+  - 😡
+  - 😢
+  - 😣
+  - 😤
+  - 😥
+  - 😨
+  - 😩
+  - 😪
+  - 😫
+  - 😭
+  - 😰
+  - 😱
+  - 😲
+  - 😳
+  - 😵
+  - 😷
+  - 😸
+  - 😹
+  - 😺
+  - 😻
+  - 😼
+  - 😽
+  - 😾
+  - 😿
+  - 🙀
+  - 🙅
+  - 🙆
+  - 🙇
+  - 🙈
+  - 🙉
+  - 🙊
+  - 🙋
+  - 🙌
+  - 🙍
+  - 🙎
+  - 🙏
+  - ✂
+  - ✅
+  - ✊
+  - ✋
+  - ✖
+  - ✨
+  - ❌
+  - ❎
+  - ❓
+  - ❔
+  - ❕
+  - ❗
+  - 🚀
+  - 🚃
+  - 🚄
+  - 🚅
+  - 🚇
+  - 🚉
+  - 🚌
+  - 🚏
+  - 🚑
+  - 🚒
+  - 🚓
+  - 🚕
+  - 🚗
+  - 🚙
+  - 🚚
+  - 🚢
+  - 🚤
+  - 🚥
+  - 🚧
+  - 🚨
+  - 🚩
+  - 🚪
+  - 🚫
+  - 🚬
+  - 🚭
+  - 🚲
+  - 🚶
+  - 🚹
+  - 🚺
+  - 🚻
+  - 🚼
+  - 🚽
+  - 🚾
+  - 🛀
+  - Ⓜ
+  - 🅰
+  - 🅱
+  - 🅾
+  - 🅿
+  - 🆎
+  - 🆑
+  - 🆒
+  - 🆓
+  - 🆔
+  - 🆕
+  - 🆖
+  - 🆗
+  - 🆘
+  - 🆙
+  - 🆚
+  - 🇩🇪
+  - 🇬🇧
+  - 🇨🇳
+  - 🇯🇵
+  - 🇫🇷
+  - 🇰🇷
+  - 🇪🇸
+  - 🇮🇹
+  - 🇷🇺
+  - 🇺🇸
+  - 🈁
+  - ℹ
+  - ⌚
+  - ⌛
+  - ⏩
+  - ⏪
+  - ⏫
+  - ⏬
+  - ⏰
+  - ⏳
+  - ◻
+  - ◽
+  - ◾
+  - ♈
+  - ♉
+  - ♊
+  - ♋
+  - ♌
+  - ♍
+  - ♎
+  - ♏
+  - ♐
+  - ♑
+  - ♒
+  - ♓
+  - ♿
+  - ⚽
+  - ⚾
+  - ⛄
+  - ⛅
+  - ⛎
+  - ⛔
+  - ⛲
+  - ⛳
+  - ⛵
+  - ⛺
+  - ⛽
+  - ⤴
+  - ⤵
+  - ⬅
+  - ⬇
+  - ⬛
+  - ⬜
+  - ⭕
+  - 〰
+  - 〽
+  - ㊗
+  - ㊙
+  - 🀄
+  - 🃏
+  - 🌀
+  - 🌁
+  - 🌂
+  - 🌃
+  - 🌄
+  - 🌅
+  - 🌆
+  - 🌇
+  - 🌈
+  - 🌉
+  - 🌊
+  - 🌋
+  - 🌌
+  - 🌏
+  - 🌑
+  - 🌓
+  - 🌔
+  - 🌕
+  - 🌙
+  - 🌛
+  - 🌟
+  - 🌠
+  - 🌰
+  - 🌱
+  - 🌴
+  - 🌵
+  - 🌷
+  - 🌸
+  - 🌹
+  - 🌺
+  - 🌻
+  - 🌼
+  - 🌽
+  - 🌾
+  - 🌿
+  - 🍀
+  - 🍁
+  - 🍂
+  - 🍃
+  - 🍄
+  - 🍅
+  - 🍆
+  - 🍇
+  - 🍈
+  - 🍉
+  - 🍊
+  - 🍌
+  - 🍍
+  - 🍎
+  - 🍏
+  - 🍑
+  - 🍒
+  - 🍓
+  - 🍔
+  - 🍕
+  - 🍖
+  - 🍗
+  - 🍘
+  - 🍙
+  - 🍚
+  - 🍛
+  - 🍜
+  - 🍝
+  - 🍞
+  - 🍟
+  - 🍠
+  - 🍡
+  - 🍢
+  - 🍣
+  - 🍤
+  - 🍥
+  - 🍦
+  - 🍧
+  - 🍨
+  - 🍩
+  - 🍪
+  - 🍫
+  - 🍬
+  - 🍭
+  - 🍮
+  - 🍯
+  - 🍰
+  - 🍱
+  - 🍲
+  - 🍳
+  - 🍴
+  - 🍵
+  - 🍶
+  - 🍷
+  - 🍸
+  - 🍹
+  - 🍺
+  - 🍻
+  - 🎀
+  - 🎁
+  - 🎂
+  - 🎃
+  - 🎄
+  - 🎅
+  - 🎆
+  - 🎇
+  - 🎈
+  - 🎉
+  - 🎊
+  - 🎋
+  - 🎌
+  - 🎍
+  - 🎎
+  - 🎏
+  - 🎐
+  - 🎑
+  - 🎒
+  - 🎓
+  - 🎠
+  - 🎡
+  - 🎢
+  - 🎣
+  - 🎤
+  - 🎥
+  - 🎦
+  - 🎧
+  - 🎨
+  - 🎩
+  - 🎪
+  - 🎫
+  - 🎬
+  - 🎭
+  - 🎮
+  - 🎯
+  - 🎰
+  - 🎱
+  - 🎲
+  - 🎳
+  - 🎴
+  - 🎵
+  - 🎶
+  - 🎷
+  - 🎸
+  - 🎹
+  - 🎺
+  - 🎻
+  - 🎼
+  - 🎽
+  - 🎾
+  - 🎿
+  - 🏀
+  - 🏁
+  - 🏂
+  - 🏃
+  - 🏄
+  - 🏆
+  - 🏈
+  - 🏊
+  - 🏠
+  - 🏡
+  - 🏢
+  - 🏣
+  - 🏥
+  - 🏦
+  - 🏧
+  - 🏨
+  - 🏩
+  - 🏪
+  - 🏫
+  - 🏬
+  - 🏭
+  - 🏮
+  - 🏯
+  - 🏰
+  - 🐌
+  - 🐍
+  - 🐎
+  - 🐑
+  - 🐒
+  - 🐔
+  - 🐗
+  - 🐘
+  - 🐙
+  - 🐚
+  - 🐛
+  - 🐜
+  - 🐝
+  - 🐞
+  - 🐟
+  - 🐠
+  - 🐡
+  - 🐢
+  - 🐣
+  - 🐤
+  - 🐥
+  - 🐦
+  - 🐧
+  - 🐨
+  - 🐩
+  - 🐫
+  - 🐬
+  - 🐭
+  - 🐮
+  - 🐯
+  - 🐰
+  - 🐱
+  - 🐲
+  - 🐳
+  - 🐴
+  - 🐵
+  - 🐶
+  - 🐷
+  - 🐸
+  - 🐹
+  - 🐺
+  - 🐻
+  - 🐼
+  - 🐽
+  - 🐾
+  - 👀
+  - 👂
+  - 👃
+  - 👄
+  - 👅
+  - 👆
+  - 👇
+  - 👈
+  - 👉
+  - 👊
+  - 👋
+  - 👌
+  - 👍
+  - 👎
+  - 👏
+  - 👐
+  - 👑
+  - 👒
+  - 👓
+  - 👔
+  - 👕
+  - 👖
+  - 👗
+  - 👘
+  - 👙
+  - 👚
+  - 👛
+  - 👜
+  - 👝
+  - 👞
+  - 👟
+  - 👠
+  - 👡
+  - 👢
+  - 👣
+  - 👤
+  - 👦
+  - 👧
+  - 👨
+  - 👩
+  - 👪
+  - 👫
+  - 👮
+  - 👯
+  - 👰
+  - 👱
+  - 👲
+  - 👳
+  - 👴
+  - 👵
+  - 👶
+  - 👷
+  - 👸
+  - 👹
+  - 👺
+  - 👻
+  - 👼
+  - 👽
+  - 👾
+  - 👿
+  - 💀
+  - 💁
+  - 💂
+  - 💃
+  - 💄
+  - 💅
+  - 💆
+  - 💇
+  - 💈
+  - 💉
+  - 💊
+  - 💋
+  - 💌
+  - 💍
+  - 💎
+  - 💏
+  - 💐
+  - 💑
+  - 💒
+  - 💓
+  - 💔
+  - 💕
+  - 💖
+  - 💗
+  - 💘
+  - 💙
+  - 💚
+  - 💛
+  - 💜
+  - 💝
+  - 💞
+  - 💟
+  - 💠
+  - 💡
+  - 💢
+  - 💣
+  - 💤
+  - 💥
+  - 💦
+  - 💧
+  - 💨
+  - 💩
+  - 💪
+  - 💫
+  - 💬
+  - 💮
+  - 💯
+  - 💰
+  - 💲
+  - 💳
+  - 💴
+  - 💵
+  - 💸
+  - 💹
+  - 💺
+  - 💻
+  - 💼
+  - 💽
+  - 💾
+  - 💿
+  - 📀
+  - 📁
+  - 📂
+  - 📃
+  - 📄
+  - 📅
+  - 📆
+  - 📇
+  - 📈
+  - 📉
+  - 📊
+  - 📋
+  - 📌
+  - 📍
+  - 📎
+  - 📏
+  - 📐
+  - 📑
+  - 📒
+  - 📓
+  - 📔
+  - 📕
+  - 📖
+  - 📗
+  - 📘
+  - 📙
+  - 📚
+  - 📛
+  - 📜
+  - 📝
+  - 📞
+  - 📟
+  - 📠
+  - 📡
+  - 📢
+  - 📣
+  - 📤
+  - 📥
+  - 📦
+  - 📧
+  - 📨
+  - 📩
+  - 📪
+  - 📫
+  - 📮
+  - 📰
+  - 📱
+  - 📲
+  - 📳
+  - 📴
+  - 📶
+  - 📷
+  - 📹
+  - 📺
+  - 📻
+  - 📼
+  - 🔃
+  - 🔊
+  - 🔋
+  - 🔌
+  - 🔍
+  - 🔎
+  - 🔏
+  - 🔐
+  - 🔑
+  - 🔒
+  - 🔓
+  - 🔔
+  - 🔖
+  - 🔗
+  - 🔘
+  - 🔙
+  - 🔚
+  - 🔛
+  - 🔜
+  - 🔝
+  - 🔞
+  - 🔟
+  - 🔠
+  - 🔡
+  - 🔢
+  - 🔣
+  - 🔤
+  - 🔥
+  - 🔦
+  - 🔧
+  - 🔨
+  - 🔩
+  - 🔪
+  - 🔫
+  - 🔮
+  - 🔯
+  - 🔰
+  - 🔱
+  - 🔲
+  - 🔳
+  - 🔴
+  - 🔵
+  - 🔶
+  - 🔷
+  - 🔸
+  - 🔹
+  - 🔺
+  - 🔻
+  - 🔼
+  - 🔽
+  - 🕐
+  - 🕑
+  - 🕒
+  - 🕓
+  - 🕔
+  - 🕕
+  - 🕖
+  - 🕗
+  - 🕘
+  - 🕙
+  - 🕚
+  - 🕛
+  - 🗻
+  - 🗼
+  - 🗽
+  - 🗾
+  - 🗿
+  - 😀
+  - 😇
+  - 😈
+  - 😎
+  - 😐
+  - 😑
+  - 😕
+  - 😗
+  - 😙
+  - 😛
+  - 😟
+  - 😦
+  - 😧
+  - 😬
+  - 😮
+  - 😯
+  - 😴
+  - 😶
+  - 🚁
+  - 🚂
+  - 🚆
+  - 🚈
+  - 🚊
+  - 🚍
+  - 🚎
+  - 🚐
+  - 🚔
+  - 🚖
+  - 🚘
+  - 🚛
+  - 🚜
+  - 🚝
+  - 🚞
+  - 🚟
+  - 🚠
+  - 🚡
+  - 🚣
+  - 🚦
+  - 🚮
+  - 🚯
+  - 🚰
+  - 🚱
+  - 🚳
+  - 🚴
+  - 🚵
+  - 🚷
+  - 🚸
+  - 🚿
+  - 🛁
+  - 🛂
+  - 🛃
+  - 🛄
+  - 🛅
+  - 🌍
+  - 🌎
+  - 🌐
+  - 🌒
+  - 🌖
+  - 🌗
+  - 🌘
+  - 🌚
+  - 🌜
+  - 🌝
+  - 🌞
+  - 🌲
+  - 🌳
+  - 🍋
+  - 🍐
+  - 🍼
+  - 🏇
+  - 🏉
+  - 🏤
+  - 🐀
+  - 🐁
+  - 🐂
+  - 🐃
+  - 🐄
+  - 🐅
+  - 🐆
+  - 🐇
+  - 🐈
+  - 🐉
+  - 🐊
+  - 🐋
+  - 🐏
+  - 🐐
+  - 🐓
+  - 🐕
+  - 🐖
+  - 🐪
+  - 👥
+  - 👬
+  - 👭
+  - 💭
+  - 💶
+  - 💷
+  - 📬
+  - 📭
+  - 📯
+  - 📵
+  - 🔀
+  - 🔁
+  - 🔂
+  - 🔄
+  - 🔅
+  - 🔆
+  - 🔇
+  - 🔉
+  - 🔕
+  - 🔬
+  - 🔭
+  - 🕜
+  - 🕝
+  - 🕞
+  - 🕟
+  - 🕠
+  - 🕡
+  - 🕢
+  - 🕣
+  - 🕤
+  - 🕥
+  - 🕦
+  - 🕧
diff --git a/backend/models/V5/PP-OCRv5_server_det_infer/inference.json b/backend/models/V5/PP-OCRv5_server_det_infer/inference.json
new file mode 100644
index 0000000..7b582d6
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_server_det_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_4.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_4.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_4.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_4.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,65,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_1.b_0"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_1.w_0"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.w_2"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.w_1"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.b_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_1.w_0"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_0.b_0"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_transpose_0.w_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.w_2"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.w_1"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm_0.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,256,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.w_2"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.w_1"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.b_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.w_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.b_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.b_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.b_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.b_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.b_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_130.b_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_130.w_0"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_129.b_0"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_129.w_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.w_2"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.w_1"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.b_0"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.w_0"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_128.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_128.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_127.b_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_127.w_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_126.b_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_126.w_0"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_125.b_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_125.w_0"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_124.b_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_124.w_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_123.b_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_123.w_0"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_122.b_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_122.w_0"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_121.b_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_121.w_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_120.b_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_120.w_0"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_119.b_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_119.w_0"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_118.b_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_118.w_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.w_2"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.b_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.w_0"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_117.b_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_117.w_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_116.b_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_116.w_0"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_115.b_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_115.w_0"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_114.b_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_114.w_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_113.b_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_113.w_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_112.b_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_112.w_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_111.b_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_111.w_0"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_110.b_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_110.w_0"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_109.b_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_109.w_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.w_2"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.w_1"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.b_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.w_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_106.b_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_106.w_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_105.b_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_105.w_0"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_104.b_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_104.w_0"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_103.b_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_103.w_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_102.b_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_102.w_0"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_101.b_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_101.w_0"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,1,7],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_100.b_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_100.w_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,3,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_99.b_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_99.w_0"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,5,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_98.b_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_98.w_0"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,32,7,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_95.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_91.w_0"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_87.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_83.w_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_94.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_90.w_0"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_86.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_93.w_0"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,256,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_89.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,256,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_85.w_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,256,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_82.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,256,9,9],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_92.w_0"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,2048,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_88.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_84.w_0"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_81.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.w_2"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.w_1"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.b_0"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_79.w_0"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.w_2"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.w_1"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.b_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.w_0"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_78.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,3328,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.w_2"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.w_1"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_77.w_0"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.w_2"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.b_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.w_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_76.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.w_2"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.w_1"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.b_0"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_75.w_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.w_2"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.b_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.w_0"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_74.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.w_2"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.w_1"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.b_0"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_73.w_0"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.w_2"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.w_1"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.b_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.w_0"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_72.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.w_2"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.w_1"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_71.w_0"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.w_2"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.b_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.w_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_70.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.w_2"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.w_1"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.b_0"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_69.w_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.w_2"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.b_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.w_0"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_68.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.w_2"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.w_1"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.b_0"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_67.w_0"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.w_2"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.w_1"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.b_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.w_0"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_66.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.w_2"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.w_1"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_65.w_0"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.w_2"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.b_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.w_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_64.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.w_2"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.w_1"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.b_0"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_63.w_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,2176,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.w_2"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.b_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.w_0"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_62.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_61.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.w_2"],"DA":[],"O":{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.w_1"],"DA":[],"O":{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.b_0"],"DA":[],"O":{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.w_0"],"DA":[],"O":{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_60.w_0"],"DA":[],"O":{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.w_2"],"DA":[],"O":{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.w_1"],"DA":[],"O":{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.b_0"],"DA":[],"O":{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.w_0"],"DA":[],"O":{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_59.w_0"],"DA":[],"O":{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.w_2"],"DA":[],"O":{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.w_1"],"DA":[],"O":{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.b_0"],"DA":[],"O":{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.w_0"],"DA":[],"O":{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_58.w_0"],"DA":[],"O":{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.w_2"],"DA":[],"O":{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.w_1"],"DA":[],"O":{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.b_0"],"DA":[],"O":{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.w_0"],"DA":[],"O":{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_57.w_0"],"DA":[],"O":{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.w_2"],"DA":[],"O":{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.w_1"],"DA":[],"O":{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.b_0"],"DA":[],"O":{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.w_0"],"DA":[],"O":{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_56.w_0"],"DA":[],"O":{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.w_2"],"DA":[],"O":{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.w_1"],"DA":[],"O":{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.b_0"],"DA":[],"O":{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.w_0"],"DA":[],"O":{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_55.w_0"],"DA":[],"O":{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.w_2"],"DA":[],"O":{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.w_1"],"DA":[],"O":{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.b_0"],"DA":[],"O":{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.w_0"],"DA":[],"O":{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_54.w_0"],"DA":[],"O":{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.w_2"],"DA":[],"O":{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.w_1"],"DA":[],"O":{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.b_0"],"DA":[],"O":{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.w_0"],"DA":[],"O":{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_53.w_0"],"DA":[],"O":{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.w_2"],"DA":[],"O":{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.w_1"],"DA":[],"O":{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.b_0"],"DA":[],"O":{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.w_0"],"DA":[],"O":{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_52.w_0"],"DA":[],"O":{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.w_2"],"DA":[],"O":{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.w_1"],"DA":[],"O":{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.b_0"],"DA":[],"O":{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.w_0"],"DA":[],"O":{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_51.w_0"],"DA":[],"O":{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.w_2"],"DA":[],"O":{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.w_1"],"DA":[],"O":{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.b_0"],"DA":[],"O":{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.w_0"],"DA":[],"O":{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_50.w_0"],"DA":[],"O":{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.w_2"],"DA":[],"O":{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.w_1"],"DA":[],"O":{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.b_0"],"DA":[],"O":{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.w_0"],"DA":[],"O":{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_49.w_0"],"DA":[],"O":{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,2176,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.w_2"],"DA":[],"O":{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.w_1"],"DA":[],"O":{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.b_0"],"DA":[],"O":{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.w_0"],"DA":[],"O":{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_48.w_0"],"DA":[],"O":{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.w_2"],"DA":[],"O":{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.w_1"],"DA":[],"O":{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.b_0"],"DA":[],"O":{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.w_0"],"DA":[],"O":{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_47.w_0"],"DA":[],"O":{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.w_2"],"DA":[],"O":{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.w_1"],"DA":[],"O":{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.b_0"],"DA":[],"O":{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.w_0"],"DA":[],"O":{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_46.w_0"],"DA":[],"O":{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.w_2"],"DA":[],"O":{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.w_1"],"DA":[],"O":{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.b_0"],"DA":[],"O":{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.w_0"],"DA":[],"O":{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_45.w_0"],"DA":[],"O":{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.w_2"],"DA":[],"O":{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.w_1"],"DA":[],"O":{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.b_0"],"DA":[],"O":{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.w_0"],"DA":[],"O":{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_44.w_0"],"DA":[],"O":{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.w_2"],"DA":[],"O":{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.w_1"],"DA":[],"O":{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.b_0"],"DA":[],"O":{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.w_0"],"DA":[],"O":{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_43.w_0"],"DA":[],"O":{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.w_2"],"DA":[],"O":{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.w_1"],"DA":[],"O":{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.b_0"],"DA":[],"O":{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.w_0"],"DA":[],"O":{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_42.w_0"],"DA":[],"O":{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.w_2"],"DA":[],"O":{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.w_1"],"DA":[],"O":{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.b_0"],"DA":[],"O":{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.w_0"],"DA":[],"O":{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_41.w_0"],"DA":[],"O":{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.w_2"],"DA":[],"O":{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.w_1"],"DA":[],"O":{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.b_0"],"DA":[],"O":{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.w_0"],"DA":[],"O":{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_40.w_0"],"DA":[],"O":{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.w_2"],"DA":[],"O":{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.w_1"],"DA":[],"O":{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.b_0"],"DA":[],"O":{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.w_0"],"DA":[],"O":{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_39.w_0"],"DA":[],"O":{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.w_2"],"DA":[],"O":{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.w_1"],"DA":[],"O":{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.b_0"],"DA":[],"O":{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.w_0"],"DA":[],"O":{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_38.w_0"],"DA":[],"O":{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.w_2"],"DA":[],"O":{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.w_1"],"DA":[],"O":{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.b_0"],"DA":[],"O":{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.w_0"],"DA":[],"O":{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_37.w_0"],"DA":[],"O":{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.w_2"],"DA":[],"O":{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.w_1"],"DA":[],"O":{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.b_0"],"DA":[],"O":{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.w_0"],"DA":[],"O":{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_36.w_0"],"DA":[],"O":{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.w_2"],"DA":[],"O":{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.w_1"],"DA":[],"O":{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.b_0"],"DA":[],"O":{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.w_0"],"DA":[],"O":{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_35.w_0"],"DA":[],"O":{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,1664,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.w_2"],"DA":[],"O":{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.w_1"],"DA":[],"O":{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.b_0"],"DA":[],"O":{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.w_0"],"DA":[],"O":{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_34.w_0"],"DA":[],"O":{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.w_2"],"DA":[],"O":{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.w_1"],"DA":[],"O":{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.b_0"],"DA":[],"O":{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.w_0"],"DA":[],"O":{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_33.w_0"],"DA":[],"O":{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.w_2"],"DA":[],"O":{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.w_1"],"DA":[],"O":{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.b_0"],"DA":[],"O":{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.w_0"],"DA":[],"O":{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_32.w_0"],"DA":[],"O":{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.w_2"],"DA":[],"O":{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.w_1"],"DA":[],"O":{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.b_0"],"DA":[],"O":{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.w_0"],"DA":[],"O":{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_31.w_0"],"DA":[],"O":{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.w_2"],"DA":[],"O":{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.w_1"],"DA":[],"O":{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.b_0"],"DA":[],"O":{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.w_0"],"DA":[],"O":{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_30.w_0"],"DA":[],"O":{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.w_2"],"DA":[],"O":{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.w_1"],"DA":[],"O":{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.b_0"],"DA":[],"O":{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.w_0"],"DA":[],"O":{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_29.w_0"],"DA":[],"O":{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.w_2"],"DA":[],"O":{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.w_1"],"DA":[],"O":{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.b_0"],"DA":[],"O":{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.w_0"],"DA":[],"O":{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_28.w_0"],"DA":[],"O":{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.w_2"],"DA":[],"O":{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.w_1"],"DA":[],"O":{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.b_0"],"DA":[],"O":{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.w_0"],"DA":[],"O":{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_27.w_0"],"DA":[],"O":{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.w_2"],"DA":[],"O":{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.w_1"],"DA":[],"O":{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.b_0"],"DA":[],"O":{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.w_0"],"DA":[],"O":{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_26.w_0"],"DA":[],"O":{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.w_2"],"DA":[],"O":{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.w_1"],"DA":[],"O":{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.b_0"],"DA":[],"O":{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.w_0"],"DA":[],"O":{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_25.w_0"],"DA":[],"O":{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.w_2"],"DA":[],"O":{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.w_1"],"DA":[],"O":{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.b_0"],"DA":[],"O":{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.w_0"],"DA":[],"O":{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_24.w_0"],"DA":[],"O":{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.w_2"],"DA":[],"O":{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.w_1"],"DA":[],"O":{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.b_0"],"DA":[],"O":{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.w_0"],"DA":[],"O":{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_23.w_0"],"DA":[],"O":{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.w_2"],"DA":[],"O":{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.w_1"],"DA":[],"O":{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.b_0"],"DA":[],"O":{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.w_0"],"DA":[],"O":{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_22.w_0"],"DA":[],"O":{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.w_2"],"DA":[],"O":{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.w_1"],"DA":[],"O":{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.b_0"],"DA":[],"O":{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.w_0"],"DA":[],"O":{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_21.w_0"],"DA":[],"O":{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,256,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.w_2"],"DA":[],"O":{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.w_1"],"DA":[],"O":{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.b_0"],"DA":[],"O":{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.w_0"],"DA":[],"O":{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_20.w_0"],"DA":[],"O":{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,704,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.w_2"],"DA":[],"O":{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.w_1"],"DA":[],"O":{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.b_0"],"DA":[],"O":{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.w_0"],"DA":[],"O":{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_19.w_0"],"DA":[],"O":{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.w_2"],"DA":[],"O":{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.w_1"],"DA":[],"O":{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.b_0"],"DA":[],"O":{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.w_0"],"DA":[],"O":{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_18.w_0"],"DA":[],"O":{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.w_2"],"DA":[],"O":{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.w_1"],"DA":[],"O":{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.b_0"],"DA":[],"O":{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.w_0"],"DA":[],"O":{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_17.w_0"],"DA":[],"O":{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.w_2"],"DA":[],"O":{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.w_1"],"DA":[],"O":{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.b_0"],"DA":[],"O":{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.w_0"],"DA":[],"O":{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_16.w_0"],"DA":[],"O":{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.w_2"],"DA":[],"O":{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.w_1"],"DA":[],"O":{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.b_0"],"DA":[],"O":{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.w_0"],"DA":[],"O":{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_15.w_0"],"DA":[],"O":{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.w_2"],"DA":[],"O":{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.w_1"],"DA":[],"O":{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.b_0"],"DA":[],"O":{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.w_0"],"DA":[],"O":{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_14.w_0"],"DA":[],"O":{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,128,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.w_2"],"DA":[],"O":{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.w_1"],"DA":[],"O":{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.b_0"],"DA":[],"O":{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.w_0"],"DA":[],"O":{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_13.w_0"],"DA":[],"O":{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.w_2"],"DA":[],"O":{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.w_1"],"DA":[],"O":{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.b_0"],"DA":[],"O":{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.w_0"],"DA":[],"O":{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_12.w_0"],"DA":[],"O":{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.w_2"],"DA":[],"O":{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.w_1"],"DA":[],"O":{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.b_0"],"DA":[],"O":{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.w_0"],"DA":[],"O":{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_11.w_0"],"DA":[],"O":{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,336,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.w_2"],"DA":[],"O":{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.w_1"],"DA":[],"O":{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.b_0"],"DA":[],"O":{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.w_0"],"DA":[],"O":{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_10.w_0"],"DA":[],"O":{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.w_2"],"DA":[],"O":{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.w_1"],"DA":[],"O":{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.b_0"],"DA":[],"O":{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.w_0"],"DA":[],"O":{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_9.w_0"],"DA":[],"O":{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.w_2"],"DA":[],"O":{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.w_1"],"DA":[],"O":{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.b_0"],"DA":[],"O":{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.w_0"],"DA":[],"O":{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_8.w_0"],"DA":[],"O":{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.w_2"],"DA":[],"O":{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.w_1"],"DA":[],"O":{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.b_0"],"DA":[],"O":{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.w_0"],"DA":[],"O":{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_7.w_0"],"DA":[],"O":{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.w_2"],"DA":[],"O":{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.w_1"],"DA":[],"O":{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.b_0"],"DA":[],"O":{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.w_0"],"DA":[],"O":{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_6.w_0"],"DA":[],"O":{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.w_2"],"DA":[],"O":{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.w_1"],"DA":[],"O":{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.b_0"],"DA":[],"O":{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.w_0"],"DA":[],"O":{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_5.w_0"],"DA":[],"O":{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.w_2"],"DA":[],"O":{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.w_1"],"DA":[],"O":{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.b_0"],"DA":[],"O":{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.w_0"],"DA":[],"O":{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_4.w_0"],"DA":[],"O":{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.w_2"],"DA":[],"O":{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.w_1"],"DA":[],"O":{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.b_0"],"DA":[],"O":{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.w_0"],"DA":[],"O":{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_3.w_0"],"DA":[],"O":{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,64,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.w_2"],"DA":[],"O":{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.w_1"],"DA":[],"O":{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.b_0"],"DA":[],"O":{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.w_0"],"DA":[],"O":{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_2.w_0"],"DA":[],"O":{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.w_2"],"DA":[],"O":{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.w_1"],"DA":[],"O":{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.b_0"],"DA":[],"O":{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.w_0"],"DA":[],"O":{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_1.w_0"],"DA":[],"O":{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,32,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,-1,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":540},{"%":539}],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":541},{"%":536},{"%":535},{"%":538},{"%":537}],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}},{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":542}],"O":[{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"SAME"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":548},{"%":534}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":549},{"%":531},{"%":530},{"%":533},{"%":532}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}},{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":550}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"SAME"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":556},{"%":529}],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":557},{"%":526},{"%":525},{"%":528},{"%":527}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}},{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_2/ReLU/"},"N":"struct_name"}],"I":[{"%":558}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/MaxPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":true},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"max"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"SAME"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/MaxPool2D/"},"N":"struct_name"}],"I":[{"%":548},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/"},"N":"struct_name"}],"I":[],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/"},"N":"struct_name"}],"I":[{"%":566},{"%":564}],"O":[{"%":568,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/"},"N":"struct_name"}],"I":[{"%":568},{"%":567}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":569},{"%":524}],"O":[{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":570},{"%":521},{"%":520},{"%":523},{"%":522}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}},{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_3/ReLU/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":577},{"%":519}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":578},{"%":516},{"%":515},{"%":518},{"%":517}],"O":[{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_4/ReLU/"},"N":"struct_name"}],"I":[{"%":579}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":585},{"%":514}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":586},{"%":511},{"%":510},{"%":513},{"%":512}],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":587}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":593},{"%":509}],"O":[{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":594},{"%":506},{"%":505},{"%":508},{"%":507}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":595}],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":601},{"%":504}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":602},{"%":501},{"%":500},{"%":503},{"%":502}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_2/ReLU/"},"N":"struct_name"}],"I":[{"%":603}],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":609},{"%":499}],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":610},{"%":496},{"%":495},{"%":498},{"%":497}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_3/ReLU/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":617},{"%":494}],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":618},{"%":491},{"%":490},{"%":493},{"%":492}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_4/ReLU/"},"N":"struct_name"}],"I":[{"%":619}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_5/Conv2D/"},"N":"struct_name"}],"I":[{"%":625},{"%":489}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_5/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":626},{"%":486},{"%":485},{"%":488},{"%":487}],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}},{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_5/ReLU/"},"N":"struct_name"}],"I":[{"%":627}],"O":[{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":585},{"%":593},{"%":601},{"%":609},{"%":617},{"%":625},{"%":633}],"O":[{"%":635,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":635},{"%":634}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,336,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_6/Conv2D/"},"N":"struct_name"}],"I":[{"%":636},{"%":484}],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_6/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":637},{"%":481},{"%":480},{"%":483},{"%":482}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_6/ReLU/"},"N":"struct_name"}],"I":[{"%":638}],"O":[{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_7/Conv2D/"},"N":"struct_name"}],"I":[{"%":644},{"%":479}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_7/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":645},{"%":476},{"%":475},{"%":478},{"%":477}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,-1,-1],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_7/ReLU/"},"N":"struct_name"}],"I":[{"%":646}],"O":[{"%":652,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":652},{"%":474}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":653},{"%":471},{"%":470},{"%":473},{"%":472}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,-1,-1],"NCHW",[],0]}},{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":654},{"%":469}],"O":[{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":660},{"%":466},{"%":465},{"%":468},{"%":467}],"O":[{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":665,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":661}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":464}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":668},{"%":461},{"%":460},{"%":463},{"%":462}],"O":[{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":669}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":459}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":676},{"%":456},{"%":455},{"%":458},{"%":457}],"O":[{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_2/ReLU/"},"N":"struct_name"}],"I":[{"%":677}],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":683},{"%":454}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":684},{"%":451},{"%":450},{"%":453},{"%":452}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}},{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":690,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_3/ReLU/"},"N":"struct_name"}],"I":[{"%":685}],"O":[{"%":691,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":691},{"%":449}],"O":[{"%":692,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":692},{"%":446},{"%":445},{"%":448},{"%":447}],"O":[{"%":693,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}},{"%":694,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":695,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":696,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":697,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":698,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_4/ReLU/"},"N":"struct_name"}],"I":[{"%":693}],"O":[{"%":699,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_5/Conv2D/"},"N":"struct_name"}],"I":[{"%":699},{"%":444}],"O":[{"%":700,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_5/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":700},{"%":441},{"%":440},{"%":443},{"%":442}],"O":[{"%":701,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}},{"%":702,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":703,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":704,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":705,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":706,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_5/ReLU/"},"N":"struct_name"}],"I":[{"%":701}],"O":[{"%":707,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":708,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":654},{"%":667},{"%":675},{"%":683},{"%":691},{"%":699},{"%":707}],"O":[{"%":709,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":709},{"%":708}],"O":[{"%":710,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,704,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_6/Conv2D/"},"N":"struct_name"}],"I":[{"%":710},{"%":439}],"O":[{"%":711,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_6/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":711},{"%":436},{"%":435},{"%":438},{"%":437}],"O":[{"%":712,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}},{"%":713,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":714,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":715,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":716,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":717,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_6/ReLU/"},"N":"struct_name"}],"I":[{"%":712}],"O":[{"%":718,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_7/Conv2D/"},"N":"struct_name"}],"I":[{"%":718},{"%":434}],"O":[{"%":719,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_7/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":719},{"%":431},{"%":430},{"%":433},{"%":432}],"O":[{"%":720,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}},{"%":721,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":722,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":723,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":724,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":725,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_7/ReLU/"},"N":"struct_name"}],"I":[{"%":720}],"O":[{"%":726,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":512},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":726},{"%":429}],"O":[{"%":727,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":727},{"%":426},{"%":425},{"%":428},{"%":427}],"O":[{"%":728,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}},{"%":729,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":730,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":731,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":732,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":733,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":728},{"%":424}],"O":[{"%":734,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":734},{"%":421},{"%":420},{"%":423},{"%":422}],"O":[{"%":735,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":736,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":737,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":738,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":739,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":740,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":735},{"%":419}],"O":[{"%":741,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":741},{"%":416},{"%":415},{"%":418},{"%":417}],"O":[{"%":742,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":743,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":744,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":745,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":746,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":747,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":742}],"O":[{"%":748,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":748},{"%":414}],"O":[{"%":749,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":749},{"%":411},{"%":410},{"%":413},{"%":412}],"O":[{"%":750,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":751,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":752,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":753,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":754,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":755,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":750},{"%":409}],"O":[{"%":756,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":756},{"%":406},{"%":405},{"%":408},{"%":407}],"O":[{"%":757,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":758,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":759,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":760,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":761,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":762,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":757}],"O":[{"%":763,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":763},{"%":404}],"O":[{"%":764,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":764},{"%":401},{"%":400},{"%":403},{"%":402}],"O":[{"%":765,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":766,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":767,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":768,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":769,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":770,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":765},{"%":399}],"O":[{"%":771,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":771},{"%":396},{"%":395},{"%":398},{"%":397}],"O":[{"%":772,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":773,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":774,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":775,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":776,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":777,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":772}],"O":[{"%":778,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":778},{"%":394}],"O":[{"%":779,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":779},{"%":391},{"%":390},{"%":393},{"%":392}],"O":[{"%":780,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":781,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":782,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":783,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":784,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":785,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":780},{"%":389}],"O":[{"%":786,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":786},{"%":386},{"%":385},{"%":388},{"%":387}],"O":[{"%":787,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":788,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":789,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":790,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":791,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":792,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":787}],"O":[{"%":793,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":793},{"%":384}],"O":[{"%":794,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":794},{"%":381},{"%":380},{"%":383},{"%":382}],"O":[{"%":795,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":796,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":797,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":798,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":799,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":800,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":795},{"%":379}],"O":[{"%":801,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":801},{"%":376},{"%":375},{"%":378},{"%":377}],"O":[{"%":802,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":803,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":804,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":805,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":806,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":807,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":802}],"O":[{"%":808,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":808},{"%":374}],"O":[{"%":809,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":809},{"%":371},{"%":370},{"%":373},{"%":372}],"O":[{"%":810,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":811,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":812,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":813,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":814,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":815,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":810},{"%":369}],"O":[{"%":816,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":816},{"%":366},{"%":365},{"%":368},{"%":367}],"O":[{"%":817,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":818,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":819,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":820,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":821,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":822,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":817}],"O":[{"%":823,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":824,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":728},{"%":748},{"%":763},{"%":778},{"%":793},{"%":808},{"%":823}],"O":[{"%":825,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":825},{"%":824}],"O":[{"%":826,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1664,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":826},{"%":364}],"O":[{"%":827,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":827},{"%":361},{"%":360},{"%":363},{"%":362}],"O":[{"%":828,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}},{"%":829,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":830,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":831,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":832,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":833,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":828}],"O":[{"%":834,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":834},{"%":359}],"O":[{"%":835,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":835},{"%":356},{"%":355},{"%":358},{"%":357}],"O":[{"%":836,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}},{"%":837,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":838,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":839,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":840,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":841,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":836}],"O":[{"%":842,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":842},{"%":354}],"O":[{"%":843,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":843},{"%":351},{"%":350},{"%":353},{"%":352}],"O":[{"%":844,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":845,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":846,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":847,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":848,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":849,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":844},{"%":349}],"O":[{"%":850,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":850},{"%":346},{"%":345},{"%":348},{"%":347}],"O":[{"%":851,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":852,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":853,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":854,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":855,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":856,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":851}],"O":[{"%":857,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":857},{"%":344}],"O":[{"%":858,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":858},{"%":341},{"%":340},{"%":343},{"%":342}],"O":[{"%":859,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":860,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":861,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":862,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":863,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":864,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":859},{"%":339}],"O":[{"%":865,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":865},{"%":336},{"%":335},{"%":338},{"%":337}],"O":[{"%":866,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":867,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":868,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":869,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":870,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":871,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":866}],"O":[{"%":872,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":872},{"%":334}],"O":[{"%":873,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":873},{"%":331},{"%":330},{"%":333},{"%":332}],"O":[{"%":874,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":875,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":876,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":877,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":878,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":879,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":874},{"%":329}],"O":[{"%":880,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":880},{"%":326},{"%":325},{"%":328},{"%":327}],"O":[{"%":881,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":882,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":883,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":884,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":885,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":886,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":881}],"O":[{"%":887,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":887},{"%":324}],"O":[{"%":888,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":888},{"%":321},{"%":320},{"%":323},{"%":322}],"O":[{"%":889,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":890,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":891,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":892,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":893,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":894,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":889},{"%":319}],"O":[{"%":895,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":895},{"%":316},{"%":315},{"%":318},{"%":317}],"O":[{"%":896,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":897,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":898,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":899,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":900,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":901,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":896}],"O":[{"%":902,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":902},{"%":314}],"O":[{"%":903,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":903},{"%":311},{"%":310},{"%":313},{"%":312}],"O":[{"%":904,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":905,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":906,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":907,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":908,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":909,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":904},{"%":309}],"O":[{"%":910,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":910},{"%":306},{"%":305},{"%":308},{"%":307}],"O":[{"%":911,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":912,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":913,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":914,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":915,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":916,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":911}],"O":[{"%":917,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":917},{"%":304}],"O":[{"%":918,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":918},{"%":301},{"%":300},{"%":303},{"%":302}],"O":[{"%":919,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":920,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":921,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":922,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":923,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":924,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":919},{"%":299}],"O":[{"%":925,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":925},{"%":296},{"%":295},{"%":298},{"%":297}],"O":[{"%":926,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":927,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":928,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":929,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":930,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":931,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":926}],"O":[{"%":932,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[],"O":[{"%":933,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[{"%":842},{"%":857},{"%":872},{"%":887},{"%":902},{"%":917},{"%":932}],"O":[{"%":934,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[{"%":934},{"%":933}],"O":[{"%":935,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2176,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":935},{"%":294}],"O":[{"%":936,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":936},{"%":291},{"%":290},{"%":293},{"%":292}],"O":[{"%":937,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}},{"%":938,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":939,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":940,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":941,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":942,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":937}],"O":[{"%":943,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":943},{"%":289}],"O":[{"%":944,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":944},{"%":286},{"%":285},{"%":288},{"%":287}],"O":[{"%":945,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}},{"%":946,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":947,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":948,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":949,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":950,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":945}],"O":[{"%":951,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[{"%":951},{"%":842}],"O":[{"%":952,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":952},{"%":284}],"O":[{"%":953,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":953},{"%":281},{"%":280},{"%":283},{"%":282}],"O":[{"%":954,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":955,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":956,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":957,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":958,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":959,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":954},{"%":279}],"O":[{"%":960,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":960},{"%":276},{"%":275},{"%":278},{"%":277}],"O":[{"%":961,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":962,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":963,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":964,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":965,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":966,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":961}],"O":[{"%":967,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":967},{"%":274}],"O":[{"%":968,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":968},{"%":271},{"%":270},{"%":273},{"%":272}],"O":[{"%":969,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":970,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":971,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":972,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":973,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":974,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":969},{"%":269}],"O":[{"%":975,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":975},{"%":266},{"%":265},{"%":268},{"%":267}],"O":[{"%":976,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":977,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":978,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":979,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":980,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":981,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":976}],"O":[{"%":982,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":982},{"%":264}],"O":[{"%":983,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":983},{"%":261},{"%":260},{"%":263},{"%":262}],"O":[{"%":984,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":985,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":986,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":987,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":988,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":989,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":984},{"%":259}],"O":[{"%":990,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":990},{"%":256},{"%":255},{"%":258},{"%":257}],"O":[{"%":991,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":992,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":993,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":994,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":995,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":996,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":991}],"O":[{"%":997,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":997},{"%":254}],"O":[{"%":998,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":998},{"%":251},{"%":250},{"%":253},{"%":252}],"O":[{"%":999,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":1000,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1001,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1002,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1003,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1004,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":999},{"%":249}],"O":[{"%":1005,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1005},{"%":246},{"%":245},{"%":248},{"%":247}],"O":[{"%":1006,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":1007,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1008,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1009,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1010,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1011,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1006}],"O":[{"%":1012,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1012},{"%":244}],"O":[{"%":1013,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1013},{"%":241},{"%":240},{"%":243},{"%":242}],"O":[{"%":1014,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":1015,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1016,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1017,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1018,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1019,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1014},{"%":239}],"O":[{"%":1020,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1020},{"%":236},{"%":235},{"%":238},{"%":237}],"O":[{"%":1021,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":1022,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1023,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1024,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1025,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1026,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1021}],"O":[{"%":1027,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1027},{"%":234}],"O":[{"%":1028,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1028},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":1029,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":1030,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1031,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1032,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1033,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1034,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1029},{"%":229}],"O":[{"%":1035,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1035},{"%":226},{"%":225},{"%":228},{"%":227}],"O":[{"%":1036,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}},{"%":1037,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1038,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1039,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1040,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":1041,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1036}],"O":[{"%":1042,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[],"O":[{"%":1043,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[{"%":952},{"%":967},{"%":982},{"%":997},{"%":1012},{"%":1027},{"%":1042}],"O":[{"%":1044,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[{"%":1044},{"%":1043}],"O":[{"%":1045,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2176,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1045},{"%":224}],"O":[{"%":1046,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1046},{"%":221},{"%":220},{"%":223},{"%":222}],"O":[{"%":1047,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}},{"%":1048,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":1049,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":1050,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":1051,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":1052,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":1047}],"O":[{"%":1053,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1053},{"%":219}],"O":[{"%":1054,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1054},{"%":216},{"%":215},{"%":218},{"%":217}],"O":[{"%":1055,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}},{"%":1056,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1057,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1058,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1059,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1060,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1055}],"O":[{"%":1061,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[{"%":1061},{"%":952}],"O":[{"%":1062,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":1024},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1062},{"%":214}],"O":[{"%":1063,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1063},{"%":211},{"%":210},{"%":213},{"%":212}],"O":[{"%":1064,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}},{"%":1065,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1066,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1067,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1068,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1069,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1064},{"%":209}],"O":[{"%":1070,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1070},{"%":206},{"%":205},{"%":208},{"%":207}],"O":[{"%":1071,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1072,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1073,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1074,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1075,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1076,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1071},{"%":204}],"O":[{"%":1077,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1077},{"%":201},{"%":200},{"%":203},{"%":202}],"O":[{"%":1078,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1079,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1080,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1081,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1082,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1083,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1078}],"O":[{"%":1084,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1084},{"%":199}],"O":[{"%":1085,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1085},{"%":196},{"%":195},{"%":198},{"%":197}],"O":[{"%":1086,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1087,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1088,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1089,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1090,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1091,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1086},{"%":194}],"O":[{"%":1092,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1092},{"%":191},{"%":190},{"%":193},{"%":192}],"O":[{"%":1093,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1094,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1095,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1096,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1097,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1098,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1093}],"O":[{"%":1099,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1099},{"%":189}],"O":[{"%":1100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1100},{"%":186},{"%":185},{"%":188},{"%":187}],"O":[{"%":1101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1101},{"%":184}],"O":[{"%":1107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1107},{"%":181},{"%":180},{"%":183},{"%":182}],"O":[{"%":1108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1108}],"O":[{"%":1114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1114},{"%":179}],"O":[{"%":1115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1115},{"%":176},{"%":175},{"%":178},{"%":177}],"O":[{"%":1116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1116},{"%":174}],"O":[{"%":1122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1122},{"%":171},{"%":170},{"%":173},{"%":172}],"O":[{"%":1123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1123}],"O":[{"%":1129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1129},{"%":169}],"O":[{"%":1130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1130},{"%":166},{"%":165},{"%":168},{"%":167}],"O":[{"%":1131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1131},{"%":164}],"O":[{"%":1137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1137},{"%":161},{"%":160},{"%":163},{"%":162}],"O":[{"%":1138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1138}],"O":[{"%":1144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1144},{"%":159}],"O":[{"%":1145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1145},{"%":156},{"%":155},{"%":158},{"%":157}],"O":[{"%":1146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1146},{"%":154}],"O":[{"%":1152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1152},{"%":151},{"%":150},{"%":153},{"%":152}],"O":[{"%":1153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}},{"%":1154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1153}],"O":[{"%":1159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":1160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":1064},{"%":1084},{"%":1099},{"%":1114},{"%":1129},{"%":1144},{"%":1159}],"O":[{"%":1161,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":1161},{"%":1160}],"O":[{"%":1162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3328,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1162},{"%":149}],"O":[{"%":1163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1163},{"%":146},{"%":145},{"%":148},{"%":147}],"O":[{"%":1164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}},{"%":1165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":1164}],"O":[{"%":1170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1170},{"%":144}],"O":[{"%":1171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1171},{"%":141},{"%":140},{"%":143},{"%":142}],"O":[{"%":1172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,-1,-1],"NCHW",[],0]}},{"%":1173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1172}],"O":[{"%":1178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D/"},"N":"struct_name"}],"I":[{"%":1178},{"%":136}],"O":[{"%":1179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1062},{"%":137}],"O":[{"%":1180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":726},{"%":138}],"O":[{"%":1181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":652},{"%":139}],"O":[{"%":1182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1179},{"%":0},{"%":0},{"%":0}],"O":[{"%":1183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1180},{"%":1183}],"O":[{"%":1184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1184},{"%":0},{"%":0},{"%":0}],"O":[{"%":1185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1181},{"%":1185}],"O":[{"%":1186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1186},{"%":0},{"%":0},{"%":0}],"O":[{"%":1187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1182},{"%":1187}],"O":[{"%":1188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1179},{"%":132}],"O":[{"%":1189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1184},{"%":133}],"O":[{"%":1190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1186},{"%":134}],"O":[{"%":1191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1188},{"%":135}],"O":[{"%":1192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1192},{"%":131}],"O":[{"%":1193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1191},{"%":1193}],"O":[{"%":1194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1194},{"%":130}],"O":[{"%":1195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1190},{"%":1195}],"O":[{"%":1196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1196},{"%":129}],"O":[{"%":1197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1189},{"%":1197}],"O":[{"%":1198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_11/"},"N":"struct_name"}],"I":[{"%":1192},{"%":128}],"O":[{"%":1199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_12/"},"N":"struct_name"}],"I":[{"%":1194},{"%":127}],"O":[{"%":1200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_13/"},"N":"struct_name"}],"I":[{"%":1196},{"%":126}],"O":[{"%":1201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":4},{"#":"0.a_i32","D":4}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/Conv2D_14/"},"N":"struct_name"}],"I":[{"%":1198},{"%":125}],"O":[{"%":1202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D/"},"N":"struct_name"}],"I":[{"%":1202},{"%":46}],"O":[{"%":1203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":1204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D/"},"N":"struct_name"}],"I":[{"%":45},{"%":1204}],"O":[{"%":1205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D/"},"N":"struct_name"}],"I":[{"%":1203},{"%":1205}],"O":[{"%":1206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1206},{"%":30}],"O":[{"%":1207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":29},{"%":1208}],"O":[{"%":1209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1207},{"%":1209}],"O":[{"%":1210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1206},{"%":42}],"O":[{"%":1211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_2/"},"N":"struct_name"}],"I":[],"O":[{"%":1212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":41},{"%":1212}],"O":[{"%":1213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1211},{"%":1213}],"O":[{"%":1214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1206},{"%":36}],"O":[{"%":1215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_3/"},"N":"struct_name"}],"I":[],"O":[{"%":1216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":35},{"%":1216}],"O":[{"%":1217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1215},{"%":1217}],"O":[{"%":1218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1210},{"%":1214}],"O":[{"%":1219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1219},{"%":1218}],"O":[{"%":1220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1220},{"%":28}],"O":[{"%":1221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_4/"},"N":"struct_name"}],"I":[],"O":[{"%":1222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":27},{"%":1222}],"O":[{"%":1223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1221},{"%":1223}],"O":[{"%":1224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1220},{"%":40}],"O":[{"%":1225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_5/"},"N":"struct_name"}],"I":[],"O":[{"%":1226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":39},{"%":1226}],"O":[{"%":1227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1225},{"%":1227}],"O":[{"%":1228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1220},{"%":34}],"O":[{"%":1229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_6/"},"N":"struct_name"}],"I":[],"O":[{"%":1230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":33},{"%":1230}],"O":[{"%":1231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1229},{"%":1231}],"O":[{"%":1232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1224},{"%":1228}],"O":[{"%":1233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1233},{"%":1232}],"O":[{"%":1234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1234},{"%":26}],"O":[{"%":1235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_7/"},"N":"struct_name"}],"I":[],"O":[{"%":1236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":25},{"%":1236}],"O":[{"%":1237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1235},{"%":1237}],"O":[{"%":1238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1234},{"%":38}],"O":[{"%":1239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_8/"},"N":"struct_name"}],"I":[],"O":[{"%":1240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":37},{"%":1240}],"O":[{"%":1241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1239},{"%":1241}],"O":[{"%":1242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1234},{"%":32}],"O":[{"%":1243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_9/"},"N":"struct_name"}],"I":[],"O":[{"%":1244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":31},{"%":1244}],"O":[{"%":1245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1243},{"%":1245}],"O":[{"%":1246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1238},{"%":1242}],"O":[{"%":1247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1247},{"%":1246}],"O":[{"%":1248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1248},{"%":44}],"O":[{"%":1249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_10/"},"N":"struct_name"}],"I":[],"O":[{"%":1250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":43},{"%":1250}],"O":[{"%":1251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1249},{"%":1251}],"O":[{"%":1252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1252},{"%":22},{"%":21},{"%":24},{"%":23}],"O":[{"%":1253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/ReLU/"},"N":"struct_name"}],"I":[{"%":1253}],"O":[{"%":1259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock/"},"N":"struct_name"}],"I":[{"%":1202},{"%":1259}],"O":[{"%":1260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1201},{"%":72}],"O":[{"%":1261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":1262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":71},{"%":1262}],"O":[{"%":1263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1261},{"%":1263}],"O":[{"%":1264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1264},{"%":56}],"O":[{"%":1265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":55},{"%":1266}],"O":[{"%":1267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1265},{"%":1267}],"O":[{"%":1268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1264},{"%":68}],"O":[{"%":1269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_2/"},"N":"struct_name"}],"I":[],"O":[{"%":1270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":67},{"%":1270}],"O":[{"%":1271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1269},{"%":1271}],"O":[{"%":1272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1264},{"%":62}],"O":[{"%":1273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_3/"},"N":"struct_name"}],"I":[],"O":[{"%":1274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":61},{"%":1274}],"O":[{"%":1275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1273},{"%":1275}],"O":[{"%":1276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1268},{"%":1272}],"O":[{"%":1277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1277},{"%":1276}],"O":[{"%":1278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1278},{"%":54}],"O":[{"%":1279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_4/"},"N":"struct_name"}],"I":[],"O":[{"%":1280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":53},{"%":1280}],"O":[{"%":1281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1279},{"%":1281}],"O":[{"%":1282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1278},{"%":66}],"O":[{"%":1283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_5/"},"N":"struct_name"}],"I":[],"O":[{"%":1284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":65},{"%":1284}],"O":[{"%":1285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1283},{"%":1285}],"O":[{"%":1286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1278},{"%":60}],"O":[{"%":1287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_6/"},"N":"struct_name"}],"I":[],"O":[{"%":1288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":59},{"%":1288}],"O":[{"%":1289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1287},{"%":1289}],"O":[{"%":1290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1282},{"%":1286}],"O":[{"%":1291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1291},{"%":1290}],"O":[{"%":1292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1292},{"%":52}],"O":[{"%":1293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_7/"},"N":"struct_name"}],"I":[],"O":[{"%":1294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":51},{"%":1294}],"O":[{"%":1295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1293},{"%":1295}],"O":[{"%":1296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1292},{"%":64}],"O":[{"%":1297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_8/"},"N":"struct_name"}],"I":[],"O":[{"%":1298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":63},{"%":1298}],"O":[{"%":1299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1297},{"%":1299}],"O":[{"%":1300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1292},{"%":58}],"O":[{"%":1301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_9/"},"N":"struct_name"}],"I":[],"O":[{"%":1302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":57},{"%":1302}],"O":[{"%":1303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1301},{"%":1303}],"O":[{"%":1304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1296},{"%":1300}],"O":[{"%":1305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1305},{"%":1304}],"O":[{"%":1306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1306},{"%":70}],"O":[{"%":1307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_10/"},"N":"struct_name"}],"I":[],"O":[{"%":1308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":69},{"%":1308}],"O":[{"%":1309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1307},{"%":1309}],"O":[{"%":1310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1310},{"%":48},{"%":47},{"%":50},{"%":49}],"O":[{"%":1311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1311}],"O":[{"%":1317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_1/"},"N":"struct_name"}],"I":[{"%":1201},{"%":1317}],"O":[{"%":1318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":1200},{"%":98}],"O":[{"%":1319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":1320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":97},{"%":1320}],"O":[{"%":1321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":1319},{"%":1321}],"O":[{"%":1322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1322},{"%":82}],"O":[{"%":1323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":81},{"%":1324}],"O":[{"%":1325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1323},{"%":1325}],"O":[{"%":1326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1322},{"%":94}],"O":[{"%":1327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_2/"},"N":"struct_name"}],"I":[],"O":[{"%":1328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":93},{"%":1328}],"O":[{"%":1329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1327},{"%":1329}],"O":[{"%":1330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1322},{"%":88}],"O":[{"%":1331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_3/"},"N":"struct_name"}],"I":[],"O":[{"%":1332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":87},{"%":1332}],"O":[{"%":1333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1331},{"%":1333}],"O":[{"%":1334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1326},{"%":1330}],"O":[{"%":1335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1335},{"%":1334}],"O":[{"%":1336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1336},{"%":80}],"O":[{"%":1337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_4/"},"N":"struct_name"}],"I":[],"O":[{"%":1338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":79},{"%":1338}],"O":[{"%":1339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1337},{"%":1339}],"O":[{"%":1340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1336},{"%":92}],"O":[{"%":1341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_5/"},"N":"struct_name"}],"I":[],"O":[{"%":1342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":91},{"%":1342}],"O":[{"%":1343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1341},{"%":1343}],"O":[{"%":1344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1336},{"%":86}],"O":[{"%":1345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_6/"},"N":"struct_name"}],"I":[],"O":[{"%":1346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":85},{"%":1346}],"O":[{"%":1347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1345},{"%":1347}],"O":[{"%":1348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1340},{"%":1344}],"O":[{"%":1349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1349},{"%":1348}],"O":[{"%":1350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1350},{"%":78}],"O":[{"%":1351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_7/"},"N":"struct_name"}],"I":[],"O":[{"%":1352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":77},{"%":1352}],"O":[{"%":1353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1351},{"%":1353}],"O":[{"%":1354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1350},{"%":90}],"O":[{"%":1355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_8/"},"N":"struct_name"}],"I":[],"O":[{"%":1356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":89},{"%":1356}],"O":[{"%":1357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1355},{"%":1357}],"O":[{"%":1358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1350},{"%":84}],"O":[{"%":1359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_9/"},"N":"struct_name"}],"I":[],"O":[{"%":1360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":83},{"%":1360}],"O":[{"%":1361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1359},{"%":1361}],"O":[{"%":1362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1354},{"%":1358}],"O":[{"%":1363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1363},{"%":1362}],"O":[{"%":1364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1364},{"%":96}],"O":[{"%":1365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_10/"},"N":"struct_name"}],"I":[],"O":[{"%":1366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":95},{"%":1366}],"O":[{"%":1367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1365},{"%":1367}],"O":[{"%":1368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1368},{"%":74},{"%":73},{"%":76},{"%":75}],"O":[{"%":1369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/ReLU/"},"N":"struct_name"}],"I":[{"%":1369}],"O":[{"%":1375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_2/"},"N":"struct_name"}],"I":[{"%":1200},{"%":1375}],"O":[{"%":1376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":1199},{"%":124}],"O":[{"%":1377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":1378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":123},{"%":1378}],"O":[{"%":1379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":1377},{"%":1379}],"O":[{"%":1380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1380},{"%":108}],"O":[{"%":1381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":107},{"%":1382}],"O":[{"%":1383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":1381},{"%":1383}],"O":[{"%":1384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1380},{"%":120}],"O":[{"%":1385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_2/"},"N":"struct_name"}],"I":[],"O":[{"%":1386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":119},{"%":1386}],"O":[{"%":1387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_2/"},"N":"struct_name"}],"I":[{"%":1385},{"%":1387}],"O":[{"%":1388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1380},{"%":114}],"O":[{"%":1389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_3/"},"N":"struct_name"}],"I":[],"O":[{"%":1390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":113},{"%":1390}],"O":[{"%":1391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_3/"},"N":"struct_name"}],"I":[{"%":1389},{"%":1391}],"O":[{"%":1392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1384},{"%":1388}],"O":[{"%":1393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1393},{"%":1392}],"O":[{"%":1394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1394},{"%":106}],"O":[{"%":1395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_4/"},"N":"struct_name"}],"I":[],"O":[{"%":1396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":105},{"%":1396}],"O":[{"%":1397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_4/"},"N":"struct_name"}],"I":[{"%":1395},{"%":1397}],"O":[{"%":1398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1394},{"%":118}],"O":[{"%":1399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_5/"},"N":"struct_name"}],"I":[],"O":[{"%":1400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":117},{"%":1400}],"O":[{"%":1401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_5/"},"N":"struct_name"}],"I":[{"%":1399},{"%":1401}],"O":[{"%":1402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1394},{"%":112}],"O":[{"%":1403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_6/"},"N":"struct_name"}],"I":[],"O":[{"%":1404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":111},{"%":1404}],"O":[{"%":1405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_6/"},"N":"struct_name"}],"I":[{"%":1403},{"%":1405}],"O":[{"%":1406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1398},{"%":1402}],"O":[{"%":1407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1407},{"%":1406}],"O":[{"%":1408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1408},{"%":104}],"O":[{"%":1409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_7/"},"N":"struct_name"}],"I":[],"O":[{"%":1410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":103},{"%":1410}],"O":[{"%":1411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_7/"},"N":"struct_name"}],"I":[{"%":1409},{"%":1411}],"O":[{"%":1412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1408},{"%":116}],"O":[{"%":1413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_8/"},"N":"struct_name"}],"I":[],"O":[{"%":1414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":115},{"%":1414}],"O":[{"%":1415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_8/"},"N":"struct_name"}],"I":[{"%":1413},{"%":1415}],"O":[{"%":1416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1408},{"%":110}],"O":[{"%":1417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_9/"},"N":"struct_name"}],"I":[],"O":[{"%":1418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":109},{"%":1418}],"O":[{"%":1419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_9/"},"N":"struct_name"}],"I":[{"%":1417},{"%":1419}],"O":[{"%":1420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1412},{"%":1416}],"O":[{"%":1421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1421},{"%":1420}],"O":[{"%":1422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1422},{"%":122}],"O":[{"%":1423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_10/"},"N":"struct_name"}],"I":[],"O":[{"%":1424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":121},{"%":1424}],"O":[{"%":1425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/Conv2D_10/"},"N":"struct_name"}],"I":[{"%":1423},{"%":1425}],"O":[{"%":1426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1426},{"%":100},{"%":99},{"%":102},{"%":101}],"O":[{"%":1427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/ReLU/"},"N":"struct_name"}],"I":[{"%":1427}],"O":[{"%":1433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/IntraCLBlock_3/"},"N":"struct_name"}],"I":[{"%":1199},{"%":1433}],"O":[{"%":1434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":8.0},{"#":"0.a_f32","D":8.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1260},{"%":0},{"%":0},{"%":0}],"O":[{"%":1435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":4.0},{"#":"0.a_f32","D":4.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1318},{"%":0},{"%":0},{"%":0}],"O":[{"%":1436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1376},{"%":0},{"%":0},{"%":0}],"O":[{"%":1437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[],"O":[{"%":1438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1435},{"%":1436},{"%":1437},{"%":1434}],"O":[{"%":1439,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/LKPAN/"},"N":"struct_name"}],"I":[{"%":1439},{"%":1438}],"O":[{"%":1440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2D/"},"N":"struct_name"}],"I":[{"%":1440},{"%":20}],"O":[{"%":1441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":false},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/BatchNorm/"},"N":"struct_name"}],"I":[{"%":1441},{"%":17},{"%":16},{"%":19},{"%":18}],"O":[{"%":1442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/BatchNorm/"},"N":"struct_name"}],"I":[{"%":1442}],"O":[{"%":1448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[],"O":[{"%":1449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[0],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d_transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_array","D":[]},"N":"output_padding"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[{"%":1448},{"%":15},{"%":1449}],"O":[{"%":1450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":64},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[],"O":[{"%":1451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[{"%":14},{"%":1451}],"O":[{"%":1452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose/"},"N":"struct_name"}],"I":[{"%":1450},{"%":1452}],"O":[{"%":1453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":false},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/BatchNorm_1/"},"N":"struct_name"}],"I":[{"%":1453},{"%":11},{"%":10},{"%":13},{"%":12}],"O":[{"%":1454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/BatchNorm_1/"},"N":"struct_name"}],"I":[{"%":1454}],"O":[{"%":1460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[0],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d_transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_array","D":[]},"N":"output_padding"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[{"%":1460},{"%":9},{"%":1461}],"O":[{"%":1462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[{"%":8},{"%":1463}],"O":[{"%":1464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,1,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/Conv2DTranspose_1/"},"N":"struct_name"}],"I":[{"%":1462},{"%":1464}],"O":[{"%":1465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.sigmoid","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Head/"},"N":"struct_name"}],"I":[{"%":1465}],"O":[{"%":1466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.nearest_interp","A":[{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_d"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_h"},{"AT":{"#":"0.a_i32","D":-1},"N":"out_w"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_f32","D":2.0},{"#":"0.a_f32","D":2.0}]},"N":"scale"},{"AT":{"#":"0.a_str","D":"nearest"},"N":"interp_method"},{"AT":{"#":"0.a_bool","D":false},"N":"align_corners"},{"AT":{"#":"0.a_i32","D":1},"N":"align_mode"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/Upsample/"},"N":"struct_name"}],"I":[{"%":1460},{"%":0},{"%":0},{"%":0}],"O":[{"%":1467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/"},"N":"struct_name"}],"I":[],"O":[{"%":1468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/"},"N":"struct_name"}],"I":[{"%":1466},{"%":1467}],"O":[{"%":1469,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/"},"N":"struct_name"}],"I":[{"%":1469},{"%":1468}],"O":[{"%":1470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,65,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":1470},{"%":7}],"O":[{"%":1471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":false},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/ConvBNLayer/BatchNorm/"},"N":"struct_name"}],"I":[{"%":1471},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":1472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}},{"%":1473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":1477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/ConvBNLayer/"},"N":"struct_name"}],"I":[{"%":1472}],"O":[{"%":1478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":1478},{"%":2}],"O":[{"%":1479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":1480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":1},{"%":1480}],"O":[{"%":1481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,1,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/LocalModule/Conv2D/"},"N":"struct_name"}],"I":[{"%":1479},{"%":1481}],"O":[{"%":1482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.sigmoid","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/"},"N":"struct_name"}],"I":[{"%":1482}],"O":[{"%":1483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PFHeadLocal/"},"N":"struct_name"}],"I":[{"%":1466},{"%":1483}],"O":[{"%":1484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.5},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/"},"N":"struct_name"}],"I":[],"O":[{"%":1485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/PFHeadLocal/"},"N":"struct_name"}],"I":[{"%":1484},{"%":1485}],"O":[{"%":1486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":1486}],"O":[{"%":1487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/PP-OCRv5_server_det_infer/inference.pdiparams b/backend/models/V5/PP-OCRv5_server_det_infer/inference.pdiparams
new file mode 100644
index 0000000..51d1e18
Binary files /dev/null and b/backend/models/V5/PP-OCRv5_server_det_infer/inference.pdiparams differ
diff --git a/backend/models/V5/PP-OCRv5_server_det_infer/inference.yml b/backend/models/V5/PP-OCRv5_server_det_infer/inference.yml
new file mode 100644
index 0000000..c4f1631
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_server_det_infer/inference.yml
@@ -0,0 +1,53 @@
+Global:
+  model_name: PP-OCRv5_server_det
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 32
+          - 32
+        - - 1
+          - 3
+          - 736
+          - 736
+        - - 1
+          - 3
+          - 4000
+          - 4000
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - DetLabelEncode: null
+  - DetResizeForTest:
+      resize_long: 960
+  - NormalizeImage:
+      mean:
+      - 0.485
+      - 0.456
+      - 0.406
+      order: hwc
+      scale: 1./255.
+      std:
+      - 0.229
+      - 0.224
+      - 0.225
+  - ToCHWImage: null
+  - KeepKeys:
+      keep_keys:
+      - image
+      - shape
+      - polys
+      - ignore_tags
+PostProcess:
+  name: DBPostProcess
+  thresh: 0.3
+  box_thresh: 0.6
+  max_candidates: 1000
+  unclip_ratio: 1.5
diff --git a/backend/models/V5/PP-OCRv5_server_rec_infer/inference.json b/backend/models/V5/PP-OCRv5_server_rec_infer/inference.json
new file mode 100644
index 0000000..6701133
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_server_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_9.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[18385],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_9.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,18385],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_85.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_85.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_85.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_85.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_86.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,256,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_84.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_84.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_84.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_84.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_85.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,4096,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_83.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_84.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_82.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_83.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,256,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_81.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_82.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,2048,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.w_2"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.w_1"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.b_0"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_80.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_80.w_0"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.w_2"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.w_1"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.b_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_79.w_0"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_79.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,3328,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.w_2"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.w_1"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_78.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_78.w_0"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.w_2"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.b_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_77.w_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_77.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.w_2"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.w_1"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.b_0"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_76.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_76.w_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.w_2"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.b_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_75.w_0"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_75.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.w_2"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.w_1"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_74.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_74.w_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.w_2"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.b_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_73.w_0"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_73.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.w_2"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.w_1"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.b_0"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_72.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_72.w_0"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.w_2"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.w_1"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.b_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_71.w_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_71.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.w_2"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.w_1"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.b_0"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_70.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_70.w_0"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.w_2"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.w_1"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.b_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_69.w_0"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_69.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,384,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.w_2"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.w_1"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_68.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_68.w_0"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.w_2"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.b_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_67.w_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_67.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.w_2"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.w_1"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.b_0"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_66.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_66.w_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.w_2"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.b_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_65.w_0"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_65.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.w_2"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.w_1"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.b_0"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_64.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_64.w_0"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,2176,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.w_2"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.w_1"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.b_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_63.w_0"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_63.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.w_2"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.w_1"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_62.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_62.w_0"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.w_2"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.b_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_61.w_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_61.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.w_2"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.w_1"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.b_0"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_60.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_60.w_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.w_2"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.b_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_59.w_0"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_59.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.w_2"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.w_1"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.b_0"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_58.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_58.w_0"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.w_2"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.w_1"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.b_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_57.w_0"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_57.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.w_2"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.w_1"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_56.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_56.w_0"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.w_2"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.b_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_55.w_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_55.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.w_2"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.w_1"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.b_0"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_54.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_54.w_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.w_2"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.b_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_53.w_0"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_53.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.w_2"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.w_1"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.b_0"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_52.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_52.w_0"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.w_2"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.w_1"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.b_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_51.w_0"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_51.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.w_2"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.w_1"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_50.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_50.w_0"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,2176,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.w_2"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.b_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_49.w_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_49.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.w_2"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.w_1"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.b_0"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_48.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_48.w_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.w_2"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.b_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_47.w_0"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_47.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.w_2"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.w_1"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.b_0"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_46.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_46.w_0"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.w_2"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.w_1"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.b_0"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_45.w_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_45.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.w_2"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.w_1"],"DA":[],"O":{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.b_0"],"DA":[],"O":{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_44.w_0"],"DA":[],"O":{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_44.w_0"],"DA":[],"O":{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.w_2"],"DA":[],"O":{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.w_1"],"DA":[],"O":{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.b_0"],"DA":[],"O":{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_43.w_0"],"DA":[],"O":{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_43.w_0"],"DA":[],"O":{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.w_2"],"DA":[],"O":{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.w_1"],"DA":[],"O":{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.b_0"],"DA":[],"O":{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_42.w_0"],"DA":[],"O":{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_42.w_0"],"DA":[],"O":{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.w_2"],"DA":[],"O":{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.w_1"],"DA":[],"O":{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.b_0"],"DA":[],"O":{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_41.w_0"],"DA":[],"O":{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_41.w_0"],"DA":[],"O":{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.w_2"],"DA":[],"O":{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.w_1"],"DA":[],"O":{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.b_0"],"DA":[],"O":{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_40.w_0"],"DA":[],"O":{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_40.w_0"],"DA":[],"O":{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.w_2"],"DA":[],"O":{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.w_1"],"DA":[],"O":{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.b_0"],"DA":[],"O":{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_39.w_0"],"DA":[],"O":{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_39.w_0"],"DA":[],"O":{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.w_2"],"DA":[],"O":{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.w_1"],"DA":[],"O":{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.b_0"],"DA":[],"O":{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_38.w_0"],"DA":[],"O":{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_38.w_0"],"DA":[],"O":{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1024,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.w_2"],"DA":[],"O":{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.w_1"],"DA":[],"O":{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.b_0"],"DA":[],"O":{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_37.w_0"],"DA":[],"O":{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_37.w_0"],"DA":[],"O":{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.w_2"],"DA":[],"O":{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.w_1"],"DA":[],"O":{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.b_0"],"DA":[],"O":{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_36.w_0"],"DA":[],"O":{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_36.w_0"],"DA":[],"O":{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,1664,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.w_2"],"DA":[],"O":{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.w_1"],"DA":[],"O":{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.b_0"],"DA":[],"O":{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_35.w_0"],"DA":[],"O":{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_35.w_0"],"DA":[],"O":{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.w_2"],"DA":[],"O":{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.w_1"],"DA":[],"O":{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.b_0"],"DA":[],"O":{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_34.w_0"],"DA":[],"O":{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_34.w_0"],"DA":[],"O":{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.w_2"],"DA":[],"O":{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.w_1"],"DA":[],"O":{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.b_0"],"DA":[],"O":{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_33.w_0"],"DA":[],"O":{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_33.w_0"],"DA":[],"O":{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.w_2"],"DA":[],"O":{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.w_1"],"DA":[],"O":{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.b_0"],"DA":[],"O":{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_32.w_0"],"DA":[],"O":{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_32.w_0"],"DA":[],"O":{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.w_2"],"DA":[],"O":{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.w_1"],"DA":[],"O":{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.b_0"],"DA":[],"O":{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_31.w_0"],"DA":[],"O":{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_31.w_0"],"DA":[],"O":{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.w_2"],"DA":[],"O":{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.w_1"],"DA":[],"O":{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.b_0"],"DA":[],"O":{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_30.w_0"],"DA":[],"O":{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_30.w_0"],"DA":[],"O":{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.w_2"],"DA":[],"O":{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.w_1"],"DA":[],"O":{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.b_0"],"DA":[],"O":{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_29.w_0"],"DA":[],"O":{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_29.w_0"],"DA":[],"O":{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.w_2"],"DA":[],"O":{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.w_1"],"DA":[],"O":{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.b_0"],"DA":[],"O":{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_28.w_0"],"DA":[],"O":{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_28.w_0"],"DA":[],"O":{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.w_2"],"DA":[],"O":{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.w_1"],"DA":[],"O":{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.b_0"],"DA":[],"O":{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_27.w_0"],"DA":[],"O":{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_27.w_0"],"DA":[],"O":{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.w_2"],"DA":[],"O":{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.w_1"],"DA":[],"O":{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.b_0"],"DA":[],"O":{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_26.w_0"],"DA":[],"O":{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_26.w_0"],"DA":[],"O":{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,192,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.w_2"],"DA":[],"O":{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.w_1"],"DA":[],"O":{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.b_0"],"DA":[],"O":{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_25.w_0"],"DA":[],"O":{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_25.w_0"],"DA":[],"O":{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.w_2"],"DA":[],"O":{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.w_1"],"DA":[],"O":{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.b_0"],"DA":[],"O":{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_24.w_0"],"DA":[],"O":{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_24.w_0"],"DA":[],"O":{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192,512,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.w_2"],"DA":[],"O":{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.w_1"],"DA":[],"O":{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.b_0"],"DA":[],"O":{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_23.w_0"],"DA":[],"O":{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_23.w_0"],"DA":[],"O":{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.w_2"],"DA":[],"O":{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.w_1"],"DA":[],"O":{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.b_0"],"DA":[],"O":{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_22.w_0"],"DA":[],"O":{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_22.w_0"],"DA":[],"O":{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512,256,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.w_2"],"DA":[],"O":{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.w_1"],"DA":[],"O":{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.b_0"],"DA":[],"O":{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_21.w_0"],"DA":[],"O":{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_21.w_0"],"DA":[],"O":{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256,704,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.w_2"],"DA":[],"O":{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.w_1"],"DA":[],"O":{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.b_0"],"DA":[],"O":{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_20.w_0"],"DA":[],"O":{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_20.w_0"],"DA":[],"O":{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.w_2"],"DA":[],"O":{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.w_1"],"DA":[],"O":{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.b_0"],"DA":[],"O":{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_19.w_0"],"DA":[],"O":{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_19.w_0"],"DA":[],"O":{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.w_2"],"DA":[],"O":{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.w_1"],"DA":[],"O":{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.b_0"],"DA":[],"O":{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_18.w_0"],"DA":[],"O":{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_18.w_0"],"DA":[],"O":{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.w_2"],"DA":[],"O":{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.w_1"],"DA":[],"O":{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.b_0"],"DA":[],"O":{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_17.w_0"],"DA":[],"O":{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_17.w_0"],"DA":[],"O":{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.w_2"],"DA":[],"O":{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.w_1"],"DA":[],"O":{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.b_0"],"DA":[],"O":{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_16.w_0"],"DA":[],"O":{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_16.w_0"],"DA":[],"O":{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,96,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.w_2"],"DA":[],"O":{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.w_1"],"DA":[],"O":{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.b_0"],"DA":[],"O":{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_15.w_0"],"DA":[],"O":{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_15.w_0"],"DA":[],"O":{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96,128,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.w_2"],"DA":[],"O":{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.w_1"],"DA":[],"O":{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.b_0"],"DA":[],"O":{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_14.w_0"],"DA":[],"O":{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_14.w_0"],"DA":[],"O":{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.w_2"],"DA":[],"O":{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.w_1"],"DA":[],"O":{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.b_0"],"DA":[],"O":{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_13.w_0"],"DA":[],"O":{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_13.w_0"],"DA":[],"O":{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.w_2"],"DA":[],"O":{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.w_1"],"DA":[],"O":{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.b_0"],"DA":[],"O":{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_12.w_0"],"DA":[],"O":{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_12.w_0"],"DA":[],"O":{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,336,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.w_2"],"DA":[],"O":{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.w_1"],"DA":[],"O":{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.b_0"],"DA":[],"O":{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_11.w_0"],"DA":[],"O":{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_11.w_0"],"DA":[],"O":{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.w_2"],"DA":[],"O":{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.w_1"],"DA":[],"O":{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.b_0"],"DA":[],"O":{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_10.w_0"],"DA":[],"O":{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_10.w_0"],"DA":[],"O":{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.w_2"],"DA":[],"O":{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.w_1"],"DA":[],"O":{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.b_0"],"DA":[],"O":{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_9.w_0"],"DA":[],"O":{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_9.w_0"],"DA":[],"O":{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.w_2"],"DA":[],"O":{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.w_1"],"DA":[],"O":{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.b_0"],"DA":[],"O":{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_8.w_0"],"DA":[],"O":{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_8.w_0"],"DA":[],"O":{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.w_2"],"DA":[],"O":{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.w_1"],"DA":[],"O":{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.b_0"],"DA":[],"O":{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_7.w_0"],"DA":[],"O":{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_7.w_0"],"DA":[],"O":{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.w_2"],"DA":[],"O":{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.w_1"],"DA":[],"O":{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.b_0"],"DA":[],"O":{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_6.w_0"],"DA":[],"O":{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_6.w_0"],"DA":[],"O":{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,48,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.w_2"],"DA":[],"O":{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.w_1"],"DA":[],"O":{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.b_0"],"DA":[],"O":{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_5.w_0"],"DA":[],"O":{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_5.w_0"],"DA":[],"O":{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.w_2"],"DA":[],"O":{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.w_1"],"DA":[],"O":{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.b_0"],"DA":[],"O":{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_4.w_0"],"DA":[],"O":{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_4.w_0"],"DA":[],"O":{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.w_2"],"DA":[],"O":{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.w_1"],"DA":[],"O":{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.b_0"],"DA":[],"O":{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_3.w_0"],"DA":[],"O":{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_3.w_0"],"DA":[],"O":{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,64,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.w_2"],"DA":[],"O":{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.w_1"],"DA":[],"O":{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.b_0"],"DA":[],"O":{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_2.w_0"],"DA":[],"O":{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_2.w_0"],"DA":[],"O":{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.w_2"],"DA":[],"O":{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.w_1"],"DA":[],"O":{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.b_0"],"DA":[],"O":{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_1.w_0"],"DA":[],"O":{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_1.w_0"],"DA":[],"O":{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,32,2,2],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":459},{"%":458}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":460},{"%":455},{"%":454},{"%":457},{"%":456}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}},{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":461}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"SAME"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":467},{"%":453}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":468},{"%":450},{"%":449},{"%":452},{"%":451}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":469}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"SAME"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":448}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":445},{"%":444},{"%":447},{"%":446}],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}},{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_2/ReLU/"},"N":"struct_name"}],"I":[{"%":477}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/MaxPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":true},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"max"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"SAME"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/MaxPool2D/"},"N":"struct_name"}],"I":[{"%":467},{"%":484}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/"},"N":"struct_name"}],"I":[{"%":485},{"%":483}],"O":[{"%":487,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/"},"N":"struct_name"}],"I":[{"%":487},{"%":486}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":488},{"%":443}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":489},{"%":440},{"%":439},{"%":442},{"%":441}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}},{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_3/ReLU/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":496},{"%":438}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":497},{"%":435},{"%":434},{"%":437},{"%":436}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,24,-1],"NCHW",[],0]}},{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/StemBlock/ConvBNAct_4/ReLU/"},"N":"struct_name"}],"I":[{"%":498}],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":48},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":504},{"%":433}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":505},{"%":430},{"%":429},{"%":432},{"%":431}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":506},{"%":428}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":425},{"%":424},{"%":427},{"%":426}],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":513}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":519},{"%":423}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":520},{"%":420},{"%":419},{"%":422},{"%":421}],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":521}],"O":[{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":527},{"%":418}],"O":[{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":528},{"%":415},{"%":414},{"%":417},{"%":416}],"O":[{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_2/ReLU/"},"N":"struct_name"}],"I":[{"%":529}],"O":[{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":535},{"%":413}],"O":[{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":536},{"%":410},{"%":409},{"%":412},{"%":411}],"O":[{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_3/ReLU/"},"N":"struct_name"}],"I":[{"%":537}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":543},{"%":408}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":544},{"%":405},{"%":404},{"%":407},{"%":406}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_4/ReLU/"},"N":"struct_name"}],"I":[{"%":545}],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_5/Conv2D/"},"N":"struct_name"}],"I":[{"%":551},{"%":403}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_5/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":552},{"%":400},{"%":399},{"%":402},{"%":401}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}},{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[48],"NCHW",[],0]}},{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_5/ReLU/"},"N":"struct_name"}],"I":[{"%":553}],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":506},{"%":519},{"%":527},{"%":535},{"%":543},{"%":551},{"%":559}],"O":[{"%":561,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,48,12,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":561},{"%":560}],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,336,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_6/Conv2D/"},"N":"struct_name"}],"I":[{"%":562},{"%":398}],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_6/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":563},{"%":395},{"%":394},{"%":397},{"%":396}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}},{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_6/ReLU/"},"N":"struct_name"}],"I":[{"%":564}],"O":[{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_7/Conv2D/"},"N":"struct_name"}],"I":[{"%":570},{"%":393}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_7/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":571},{"%":390},{"%":389},{"%":392},{"%":391}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}},{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage/Sequential/HGV2_Block/ConvBNAct_7/ReLU/"},"N":"struct_name"}],"I":[{"%":572}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":578},{"%":388}],"O":[{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":579},{"%":385},{"%":384},{"%":387},{"%":386}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}},{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":580},{"%":383}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":586},{"%":380},{"%":379},{"%":382},{"%":381}],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}},{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":587}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":593},{"%":378}],"O":[{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":594},{"%":375},{"%":374},{"%":377},{"%":376}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}},{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":595}],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":601},{"%":373}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":602},{"%":370},{"%":369},{"%":372},{"%":371}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}},{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_2/ReLU/"},"N":"struct_name"}],"I":[{"%":603}],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":609},{"%":368}],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":610},{"%":365},{"%":364},{"%":367},{"%":366}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}},{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_3/ReLU/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":617},{"%":363}],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":618},{"%":360},{"%":359},{"%":362},{"%":361}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_4/ReLU/"},"N":"struct_name"}],"I":[{"%":619}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_5/Conv2D/"},"N":"struct_name"}],"I":[{"%":625},{"%":358}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_5/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":626},{"%":355},{"%":354},{"%":357},{"%":356}],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}},{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[96],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_5/ReLU/"},"N":"struct_name"}],"I":[{"%":627}],"O":[{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593},{"%":601},{"%":609},{"%":617},{"%":625},{"%":633}],"O":[{"%":635,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,96,12,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":635},{"%":634}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,704,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_6/Conv2D/"},"N":"struct_name"}],"I":[{"%":636},{"%":353}],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_6/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":637},{"%":350},{"%":349},{"%":352},{"%":351}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,12,-1],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_6/ReLU/"},"N":"struct_name"}],"I":[{"%":638}],"O":[{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_7/Conv2D/"},"N":"struct_name"}],"I":[{"%":644},{"%":348}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_7/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":645},{"%":345},{"%":344},{"%":347},{"%":346}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,12,-1],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_1/Sequential/HGV2_Block/ConvBNAct_7/ReLU/"},"N":"struct_name"}],"I":[{"%":646}],"O":[{"%":652,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":512},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":652},{"%":343}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":653},{"%":340},{"%":339},{"%":342},{"%":341}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}},{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":654},{"%":338}],"O":[{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":660},{"%":335},{"%":334},{"%":337},{"%":336}],"O":[{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":665,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":661},{"%":333}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":330},{"%":329},{"%":332},{"%":331}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":328}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":325},{"%":324},{"%":327},{"%":326}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":676},{"%":323}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":682},{"%":320},{"%":319},{"%":322},{"%":321}],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":683}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":689},{"%":318}],"O":[{"%":690,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":690},{"%":315},{"%":314},{"%":317},{"%":316}],"O":[{"%":691,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":692,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":693,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":694,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":695,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":696,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":691},{"%":313}],"O":[{"%":697,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":697},{"%":310},{"%":309},{"%":312},{"%":311}],"O":[{"%":698,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":699,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":700,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":701,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":702,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":703,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":698}],"O":[{"%":704,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":704},{"%":308}],"O":[{"%":705,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":705},{"%":305},{"%":304},{"%":307},{"%":306}],"O":[{"%":706,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":707,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":708,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":709,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":710,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":711,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":706},{"%":303}],"O":[{"%":712,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":712},{"%":300},{"%":299},{"%":302},{"%":301}],"O":[{"%":713,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":714,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":715,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":716,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":717,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":718,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":713}],"O":[{"%":719,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":719},{"%":298}],"O":[{"%":720,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":720},{"%":295},{"%":294},{"%":297},{"%":296}],"O":[{"%":721,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":722,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":723,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":724,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":725,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":726,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":721},{"%":293}],"O":[{"%":727,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":727},{"%":290},{"%":289},{"%":292},{"%":291}],"O":[{"%":728,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":729,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":730,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":731,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":732,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":733,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":728}],"O":[{"%":734,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":734},{"%":288}],"O":[{"%":735,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":735},{"%":285},{"%":284},{"%":287},{"%":286}],"O":[{"%":736,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":737,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":738,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":739,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":740,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":741,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":736},{"%":283}],"O":[{"%":742,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":742},{"%":280},{"%":279},{"%":282},{"%":281}],"O":[{"%":743,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":744,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":745,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":746,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":747,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":748,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":743}],"O":[{"%":749,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":750,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":654},{"%":674},{"%":689},{"%":704},{"%":719},{"%":734},{"%":749}],"O":[{"%":751,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":751},{"%":750}],"O":[{"%":752,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1664,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":752},{"%":278}],"O":[{"%":753,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":753},{"%":275},{"%":274},{"%":277},{"%":276}],"O":[{"%":754,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}},{"%":755,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":756,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":757,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":758,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":759,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":754}],"O":[{"%":760,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":760},{"%":273}],"O":[{"%":761,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":761},{"%":270},{"%":269},{"%":272},{"%":271}],"O":[{"%":762,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}},{"%":763,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":764,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":765,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":766,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":767,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":762}],"O":[{"%":768,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":768},{"%":268}],"O":[{"%":769,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":769},{"%":265},{"%":264},{"%":267},{"%":266}],"O":[{"%":770,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":771,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":772,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":773,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":774,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":775,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":770},{"%":263}],"O":[{"%":776,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":776},{"%":260},{"%":259},{"%":262},{"%":261}],"O":[{"%":777,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":778,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":779,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":780,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":781,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":782,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":777}],"O":[{"%":783,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":783},{"%":258}],"O":[{"%":784,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":784},{"%":255},{"%":254},{"%":257},{"%":256}],"O":[{"%":785,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":786,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":787,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":788,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":789,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":790,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":785},{"%":253}],"O":[{"%":791,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":791},{"%":250},{"%":249},{"%":252},{"%":251}],"O":[{"%":792,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":793,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":794,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":795,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":796,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":797,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":792}],"O":[{"%":798,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":798},{"%":248}],"O":[{"%":799,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":799},{"%":245},{"%":244},{"%":247},{"%":246}],"O":[{"%":800,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":801,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":802,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":803,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":804,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":805,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":800},{"%":243}],"O":[{"%":806,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":806},{"%":240},{"%":239},{"%":242},{"%":241}],"O":[{"%":807,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":808,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":809,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":810,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":811,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":812,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":807}],"O":[{"%":813,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":813},{"%":238}],"O":[{"%":814,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":814},{"%":235},{"%":234},{"%":237},{"%":236}],"O":[{"%":815,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":816,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":817,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":818,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":819,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":820,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":815},{"%":233}],"O":[{"%":821,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":821},{"%":230},{"%":229},{"%":232},{"%":231}],"O":[{"%":822,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":823,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":824,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":825,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":826,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":827,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":822}],"O":[{"%":828,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":828},{"%":228}],"O":[{"%":829,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":829},{"%":225},{"%":224},{"%":227},{"%":226}],"O":[{"%":830,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":831,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":832,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":833,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":834,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":835,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":830},{"%":223}],"O":[{"%":836,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":836},{"%":220},{"%":219},{"%":222},{"%":221}],"O":[{"%":837,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":838,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":839,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":840,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":841,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":842,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":837}],"O":[{"%":843,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":843},{"%":218}],"O":[{"%":844,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":844},{"%":215},{"%":214},{"%":217},{"%":216}],"O":[{"%":845,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":846,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":847,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":848,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":849,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":850,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":845},{"%":213}],"O":[{"%":851,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":851},{"%":210},{"%":209},{"%":212},{"%":211}],"O":[{"%":852,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":853,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":854,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":855,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":856,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":857,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":852}],"O":[{"%":858,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[],"O":[{"%":859,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[{"%":768},{"%":783},{"%":798},{"%":813},{"%":828},{"%":843},{"%":858}],"O":[{"%":860,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[{"%":860},{"%":859}],"O":[{"%":861,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2176,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":861},{"%":208}],"O":[{"%":862,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":862},{"%":205},{"%":204},{"%":207},{"%":206}],"O":[{"%":863,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}},{"%":864,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":865,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":866,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":867,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":868,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":863}],"O":[{"%":869,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":869},{"%":203}],"O":[{"%":870,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":870},{"%":200},{"%":199},{"%":202},{"%":201}],"O":[{"%":871,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}},{"%":872,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":873,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":874,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":875,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":876,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":871}],"O":[{"%":877,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_1/"},"N":"struct_name"}],"I":[{"%":877},{"%":768}],"O":[{"%":878,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":878},{"%":198}],"O":[{"%":879,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":879},{"%":195},{"%":194},{"%":197},{"%":196}],"O":[{"%":880,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":881,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":882,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":883,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":884,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":885,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":880},{"%":193}],"O":[{"%":886,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":886},{"%":190},{"%":189},{"%":192},{"%":191}],"O":[{"%":887,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":888,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":889,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":890,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":891,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":892,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":887}],"O":[{"%":893,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":893},{"%":188}],"O":[{"%":894,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":894},{"%":185},{"%":184},{"%":187},{"%":186}],"O":[{"%":895,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":896,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":897,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":898,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":899,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":900,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":895},{"%":183}],"O":[{"%":901,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":901},{"%":180},{"%":179},{"%":182},{"%":181}],"O":[{"%":902,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":903,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":904,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":905,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":906,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":907,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":902}],"O":[{"%":908,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":908},{"%":178}],"O":[{"%":909,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":909},{"%":175},{"%":174},{"%":177},{"%":176}],"O":[{"%":910,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":911,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":912,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":913,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":914,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":915,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":910},{"%":173}],"O":[{"%":916,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":916},{"%":170},{"%":169},{"%":172},{"%":171}],"O":[{"%":917,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":918,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":919,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":920,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":921,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":922,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":917}],"O":[{"%":923,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":923},{"%":168}],"O":[{"%":924,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":924},{"%":165},{"%":164},{"%":167},{"%":166}],"O":[{"%":925,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":926,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":927,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":928,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":929,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":930,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":925},{"%":163}],"O":[{"%":931,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":931},{"%":160},{"%":159},{"%":162},{"%":161}],"O":[{"%":932,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":933,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":934,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":935,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":936,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":937,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":932}],"O":[{"%":938,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":938},{"%":158}],"O":[{"%":939,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":939},{"%":155},{"%":154},{"%":157},{"%":156}],"O":[{"%":940,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":941,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":942,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":943,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":944,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":945,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":940},{"%":153}],"O":[{"%":946,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":946},{"%":150},{"%":149},{"%":152},{"%":151}],"O":[{"%":947,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":948,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":949,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":950,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":951,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":952,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":947}],"O":[{"%":953,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":953},{"%":148}],"O":[{"%":954,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":954},{"%":145},{"%":144},{"%":147},{"%":146}],"O":[{"%":955,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":956,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":957,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":958,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":959,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":960,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":192},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":955},{"%":143}],"O":[{"%":961,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":961},{"%":140},{"%":139},{"%":142},{"%":141}],"O":[{"%":962,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}},{"%":963,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":964,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":965,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":966,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[192],"NCHW",[],0]}},{"%":967,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":962}],"O":[{"%":968,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[],"O":[{"%":969,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[{"%":878},{"%":893},{"%":908},{"%":923},{"%":938},{"%":953},{"%":968}],"O":[{"%":970,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,192,6,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[{"%":970},{"%":969}],"O":[{"%":971,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2176,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":971},{"%":138}],"O":[{"%":972,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":972},{"%":135},{"%":134},{"%":137},{"%":136}],"O":[{"%":973,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}},{"%":974,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":975,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":976,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":977,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[512],"NCHW",[],0]}},{"%":978,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":973}],"O":[{"%":979,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,512,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":979},{"%":133}],"O":[{"%":980,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":980},{"%":130},{"%":129},{"%":132},{"%":131}],"O":[{"%":981,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}},{"%":982,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":983,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":984,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":985,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":986,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":981}],"O":[{"%":987,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_2/Sequential/HGV2_Block_2/"},"N":"struct_name"}],"I":[{"%":987},{"%":878}],"O":[{"%":988,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":1024},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":988},{"%":128}],"O":[{"%":989,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":989},{"%":125},{"%":124},{"%":127},{"%":126}],"O":[{"%":990,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,3,-1],"NCHW",[],0]}},{"%":991,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":992,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":993,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":994,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":995,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":990},{"%":123}],"O":[{"%":996,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":996},{"%":120},{"%":119},{"%":122},{"%":121}],"O":[{"%":997,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":998,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":999,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1000,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1001,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1002,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":997},{"%":118}],"O":[{"%":1003,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1003},{"%":115},{"%":114},{"%":117},{"%":116}],"O":[{"%":1004,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1005,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1006,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1007,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1008,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1009,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1004}],"O":[{"%":1010,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1010},{"%":113}],"O":[{"%":1011,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1011},{"%":110},{"%":109},{"%":112},{"%":111}],"O":[{"%":1012,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1013,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1014,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1015,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1016,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1017,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1012},{"%":108}],"O":[{"%":1018,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1018},{"%":105},{"%":104},{"%":107},{"%":106}],"O":[{"%":1019,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1020,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1021,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1022,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1023,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1024,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_1/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1019}],"O":[{"%":1025,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1025},{"%":103}],"O":[{"%":1026,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1026},{"%":100},{"%":99},{"%":102},{"%":101}],"O":[{"%":1027,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1028,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1029,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1030,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1031,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1032,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1027},{"%":98}],"O":[{"%":1033,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1033},{"%":95},{"%":94},{"%":97},{"%":96}],"O":[{"%":1034,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1035,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1036,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1037,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1038,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1039,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_2/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1034}],"O":[{"%":1040,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1040},{"%":93}],"O":[{"%":1041,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1041},{"%":90},{"%":89},{"%":92},{"%":91}],"O":[{"%":1042,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1043,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1044,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1045,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1046,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1047,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1042},{"%":88}],"O":[{"%":1048,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1048},{"%":85},{"%":84},{"%":87},{"%":86}],"O":[{"%":1049,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1050,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1051,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1052,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1053,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1054,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_3/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1049}],"O":[{"%":1055,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1055},{"%":83}],"O":[{"%":1056,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1056},{"%":80},{"%":79},{"%":82},{"%":81}],"O":[{"%":1057,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1058,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1059,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1060,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1061,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1062,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1057},{"%":78}],"O":[{"%":1063,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1063},{"%":75},{"%":74},{"%":77},{"%":76}],"O":[{"%":1064,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1065,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1066,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1067,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1068,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1069,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_4/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1064}],"O":[{"%":1070,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1070},{"%":73}],"O":[{"%":1071,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1071},{"%":70},{"%":69},{"%":72},{"%":71}],"O":[{"%":1072,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1073,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1074,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1075,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1076,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1077,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":384},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1072},{"%":68}],"O":[{"%":1078,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1078},{"%":65},{"%":64},{"%":67},{"%":66}],"O":[{"%":1079,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}},{"%":1080,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1081,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1082,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1083,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[384],"NCHW",[],0]}},{"%":1084,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/LightConvBNAct_5/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1079}],"O":[{"%":1085,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[],"O":[{"%":1086,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":990},{"%":1010},{"%":1025},{"%":1040},{"%":1055},{"%":1070},{"%":1085}],"O":[{"%":1087,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,3,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,384,3,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/"},"N":"struct_name"}],"I":[{"%":1087},{"%":1086}],"O":[{"%":1088,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3328,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct/Conv2D/"},"N":"struct_name"}],"I":[{"%":1088},{"%":63}],"O":[{"%":1089,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1089},{"%":60},{"%":59},{"%":62},{"%":61}],"O":[{"%":1090,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,3,-1],"NCHW",[],0]}},{"%":1091,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1092,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1093,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1094,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1024],"NCHW",[],0]}},{"%":1095,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct/ReLU/"},"N":"struct_name"}],"I":[{"%":1090}],"O":[{"%":1096,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1024,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1096},{"%":58}],"O":[{"%":1097,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1097},{"%":55},{"%":54},{"%":57},{"%":56}],"O":[{"%":1098,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,3,-1],"NCHW",[],0]}},{"%":1099,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPHGNetV2/HGV2_Stage_3/Sequential/HGV2_Block/ConvBNAct_1/ReLU/"},"N":"struct_name"}],"I":[{"%":1098}],"O":[{"%":1104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/"},"N":"struct_name"}],"I":[],"O":[{"%":1105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPHGNetV2/"},"N":"struct_name"}],"I":[{"%":1104},{"%":1105}],"O":[{"%":1106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1106}],"O":[{"%":1107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":1107},{"%":53}],"O":[{"%":1108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1108},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":1109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,1,-1],"NCHW",[],0]}},{"%":1110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":1109}],"O":[{"%":1115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":1115},{"%":48}],"O":[{"%":1116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1116},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":1117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":1118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":1117}],"O":[{"%":1123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1123}],"O":[{"%":1124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":1125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":1126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1124},{"%":1125},{"%":1126}],"O":[{"%":1127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1123}],"O":[{"%":1128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1128}],"O":[{"%":1129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":1129},{"%":43},{"%":42}],"O":[{"%":1130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":1132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":1130},{"%":41}],"O":[{"%":1133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":1133},{"%":40}],"O":[{"%":1134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1134},{"%":1135}],"O":[{"%":1136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1136}],"O":[{"%":1137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1137},{"%":1138},{"%":1139}],"O":[{"%":1140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1140},{"%":1141}],"O":[{"%":1142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1137},{"%":1143},{"%":1144}],"O":[{"%":1145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1137},{"%":1146},{"%":1147}],"O":[{"%":1148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1145}],"O":[{"%":1149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1142},{"%":1149}],"O":[{"%":1150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1150}],"O":[{"%":1151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":1152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":1151},{"%":0},{"%":1152}],"O":[{"%":1153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":1154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1153},{"%":1148}],"O":[{"%":1155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1155}],"O":[{"%":1156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":1156},{"%":1157}],"O":[{"%":1158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":1158},{"%":39}],"O":[{"%":1159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":1159},{"%":38}],"O":[{"%":1160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":1160},{"%":0},{"%":1161}],"O":[{"%":1162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":1129},{"%":1162}],"O":[{"%":1164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":1164},{"%":37},{"%":36}],"O":[{"%":1165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":1167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":1165},{"%":35}],"O":[{"%":1168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":1168},{"%":34}],"O":[{"%":1169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":1169}],"O":[{"%":1170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":1171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":1170},{"%":0},{"%":1171}],"O":[{"%":1172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":1173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":1172},{"%":33}],"O":[{"%":1174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":1174},{"%":32}],"O":[{"%":1175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":1175},{"%":0},{"%":1176}],"O":[{"%":1177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":1164},{"%":1177}],"O":[{"%":1179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":1179},{"%":31},{"%":30}],"O":[{"%":1180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":1182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":1180},{"%":29}],"O":[{"%":1183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":1183},{"%":28}],"O":[{"%":1184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1184},{"%":1185}],"O":[{"%":1186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1186}],"O":[{"%":1187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1187},{"%":1188},{"%":1189}],"O":[{"%":1190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1190},{"%":1191}],"O":[{"%":1192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1187},{"%":1193},{"%":1194}],"O":[{"%":1195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1187},{"%":1196},{"%":1197}],"O":[{"%":1198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1195}],"O":[{"%":1199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1192},{"%":1199}],"O":[{"%":1200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1200}],"O":[{"%":1201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":1202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":1201},{"%":0},{"%":1202}],"O":[{"%":1203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":1204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1203},{"%":1198}],"O":[{"%":1205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1205}],"O":[{"%":1206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":1207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":1206},{"%":1207}],"O":[{"%":1208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":1208},{"%":27}],"O":[{"%":1209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":1209},{"%":26}],"O":[{"%":1210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":1210},{"%":0},{"%":1211}],"O":[{"%":1212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":1179},{"%":1212}],"O":[{"%":1214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":1214},{"%":25},{"%":24}],"O":[{"%":1215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":1217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":1215},{"%":23}],"O":[{"%":1218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":1218},{"%":22}],"O":[{"%":1219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":1219}],"O":[{"%":1220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":1221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":1220},{"%":0},{"%":1221}],"O":[{"%":1222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":1223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":1222},{"%":21}],"O":[{"%":1224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":1224},{"%":20}],"O":[{"%":1225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":1226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":1225},{"%":0},{"%":1226}],"O":[{"%":1227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":1214},{"%":1227}],"O":[{"%":1229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":1229},{"%":19},{"%":18}],"O":[{"%":1230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":1231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":1232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":1233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":1234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":1235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1233},{"%":1234},{"%":1127},{"%":1235}],"O":[{"%":1236,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1236}],"O":[{"%":1237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1230},{"%":1237}],"O":[{"%":1238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1238}],"O":[{"%":1239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":1239},{"%":17}],"O":[{"%":1240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1240},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":1241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]}},{"%":1242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[2048],"NCHW",[],0]}},{"%":1246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":1241}],"O":[{"%":1247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":1248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1107},{"%":1247}],"O":[{"%":1249,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,2048,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":1249},{"%":1248}],"O":[{"%":1250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,4096,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":1250},{"%":12}],"O":[{"%":1251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1251},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":1252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,1,-1],"NCHW",[],0]}},{"%":1253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[256],"NCHW",[],0]}},{"%":1257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":1252}],"O":[{"%":1258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,256,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":1258},{"%":7}],"O":[{"%":1259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":1259},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":1260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":1261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":1265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":1260}],"O":[{"%":1266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":1267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":1266},{"%":1267}],"O":[{"%":1268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":1268}],"O":[{"%":1269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":1269},{"%":2}],"O":[{"%":1270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":1270},{"%":1}],"O":[{"%":1271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":1271}],"O":[{"%":1272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":1272}],"O":[{"%":1273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,18385],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/PP-OCRv5_server_rec_infer/inference.pdiparams b/backend/models/V5/PP-OCRv5_server_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..7db5aac
Binary files /dev/null and b/backend/models/V5/PP-OCRv5_server_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/PP-OCRv5_server_rec_infer/inference.yml b/backend/models/V5/PP-OCRv5_server_rec_infer/inference.yml
new file mode 100644
index 0000000..f5156e7
--- /dev/null
+++ b/backend/models/V5/PP-OCRv5_server_rec_infer/inference.yml
@@ -0,0 +1,18426 @@
+Global:
+  model_name: PP-OCRv5_server_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - 　
+  - 一
+  - 乙
+  - 二
+  - 十
+  - 丁
+  - 厂
+  - 七
+  - 卜
+  - 八
+  - 人
+  - 入
+  - 儿
+  - 匕
+  - 几
+  - 九
+  - 刁
+  - 了
+  - 刀
+  - 力
+  - 乃
+  - 又
+  - 三
+  - 干
+  - 于
+  - 亏
+  - 工
+  - 土
+  - 士
+  - 才
+  - 下
+  - 寸
+  - 大
+  - 丈
+  - 与
+  - 万
+  - 上
+  - 小
+  - 口
+  - 山
+  - 巾
+  - 千
+  - 乞
+  - 川
+  - 亿
+  - 个
+  - 夕
+  - 久
+  - 么
+  - 勺
+  - 凡
+  - 丸
+  - 及
+  - 广
+  - 亡
+  - 门
+  - 丫
+  - 义
+  - 之
+  - 尸
+  - 己
+  - 已
+  - 巳
+  - 弓
+  - 子
+  - 卫
+  - 也
+  - 女
+  - 刃
+  - 飞
+  - 习
+  - 叉
+  - 马
+  - 乡
+  - 丰
+  - 王
+  - 开
+  - 井
+  - 天
+  - 夫
+  - 元
+  - 无
+  - 云
+  - 专
+  - 丐
+  - 扎
+  - 艺
+  - 木
+  - 五
+  - 支
+  - 厅
+  - 不
+  - 犬
+  - 太
+  - 区
+  - 历
+  - 歹
+  - 友
+  - 尤
+  - 匹
+  - 车
+  - 巨
+  - 牙
+  - 屯
+  - 戈
+  - 比
+  - 互
+  - 切
+  - 瓦
+  - 止
+  - 少
+  - 曰
+  - 日
+  - 中
+  - 贝
+  - 冈
+  - 内
+  - 水
+  - 见
+  - 午
+  - 牛
+  - 手
+  - 气
+  - 毛
+  - 壬
+  - 升
+  - 夭
+  - 长
+  - 仁
+  - 什
+  - 片
+  - 仆
+  - 化
+  - 仇
+  - 币
+  - 仍
+  - 仅
+  - 斤
+  - 爪
+  - 反
+  - 介
+  - 父
+  - 从
+  - 仑
+  - 今
+  - 凶
+  - 分
+  - 乏
+  - 公
+  - 仓
+  - 月
+  - 氏
+  - 勿
+  - 欠
+  - 风
+  - 丹
+  - 匀
+  - 乌
+  - 勾
+  - 凤
+  - 六
+  - 文
+  - 亢
+  - 方
+  - 火
+  - 为
+  - 斗
+  - 忆
+  - 计
+  - 订
+  - 户
+  - 认
+  - 冗
+  - 讥
+  - 心
+  - 尺
+  - 引
+  - 丑
+  - 巴
+  - 孔
+  - 队
+  - 办
+  - 以
+  - 允
+  - 予
+  - 邓
+  - 劝
+  - 双
+  - 书
+  - 幻
+  - 玉
+  - 刊
+  - 未
+  - 末
+  - 示
+  - 击
+  - 打
+  - 巧
+  - 正
+  - 扑
+  - 卉
+  - 扒
+  - 功
+  - 扔
+  - 去
+  - 甘
+  - 世
+  - 艾
+  - 古
+  - 节
+  - 本
+  - 术
+  - 可
+  - 丙
+  - 左
+  - 厉
+  - 石
+  - 右
+  - 布
+  - 夯
+  - 戊
+  - 龙
+  - 平
+  - 灭
+  - 轧
+  - 东
+  - 卡
+  - 北
+  - 占
+  - 凸
+  - 卢
+  - 业
+  - 旧
+  - 帅
+  - 归
+  - 旦
+  - 目
+  - 且
+  - 叶
+  - 甲
+  - 申
+  - 叮
+  - 电
+  - 号
+  - 田
+  - 由
+  - 只
+  - 叭
+  - 史
+  - 央
+  - 兄
+  - 叽
+  - 叼
+  - 叫
+  - 叩
+  - 叨
+  - 另
+  - 叹
+  - 冉
+  - 皿
+  - 凹
+  - 囚
+  - 四
+  - 生
+  - 矢
+  - 失
+  - 乍
+  - 禾
+  - 丘
+  - 付
+  - 仗
+  - 代
+  - 仙
+  - 们
+  - 仪
+  - 白
+  - 仔
+  - 他
+  - 斥
+  - 瓜
+  - 乎
+  - 丛
+  - 令
+  - 用
+  - 甩
+  - 印
+  - 尔
+  - 乐
+  - 句
+  - 匆
+  - 册
+  - 卯
+  - 犯
+  - 外
+  - 处
+  - 冬
+  - 鸟
+  - 务
+  - 包
+  - 饥
+  - 主
+  - 市
+  - 立
+  - 冯
+  - 玄
+  - 闪
+  - 兰
+  - 半
+  - 汁
+  - 汇
+  - 头
+  - 汉
+  - 宁
+  - 穴
+  - 它
+  - 讨
+  - 写
+  - 让
+  - 礼
+  - 训
+  - 议
+  - 必
+  - 讯
+  - 记
+  - 永
+  - 司
+  - 尼
+  - 民
+  - 弗
+  - 弘
+  - 出
+  - 辽
+  - 奶
+  - 奴
+  - 召
+  - 加
+  - 皮
+  - 边
+  - 孕
+  - 发
+  - 圣
+  - 对
+  - 台
+  - 矛
+  - 纠
+  - 母
+  - 幼
+  - 丝
+  - 邦
+  - 式
+  - 迂
+  - 刑
+  - 戎
+  - 动
+  - 扛
+  - 寺
+  - 吉
+  - 扣
+  - 考
+  - 托
+  - 老
+  - 巩
+  - 圾
+  - 执
+  - 扩
+  - 扫
+  - 地
+  - 场
+  - 扬
+  - 耳
+  - 芋
+  - 共
+  - 芒
+  - 亚
+  - 芝
+  - 朽
+  - 朴
+  - 机
+  - 权
+  - 过
+  - 臣
+  - 吏
+  - 再
+  - 协
+  - 西
+  - 压
+  - 厌
+  - 戌
+  - 在
+  - 百
+  - 有
+  - 存
+  - 而
+  - 页
+  - 匠
+  - 夸
+  - 夺
+  - 灰
+  - 达
+  - 列
+  - 死
+  - 成
+  - 夹
+  - 夷
+  - 轨
+  - 邪
+  - 尧
+  - 划
+  - 迈
+  - 毕
+  - 至
+  - 此
+  - 贞
+  - 师
+  - 尘
+  - 尖
+  - 劣
+  - 光
+  - 当
+  - 早
+  - 吁
+  - 吐
+  - 吓
+  - 虫
+  - 曲
+  - 团
+  - 吕
+  - 同
+  - 吊
+  - 吃
+  - 因
+  - 吸
+  - 吗
+  - 吆
+  - 屿
+  - 屹
+  - 岁
+  - 帆
+  - 回
+  - 岂
+  - 则
+  - 刚
+  - 网
+  - 肉
+  - 年
+  - 朱
+  - 先
+  - 丢
+  - 廷
+  - 舌
+  - 竹
+  - 迁
+  - 乔
+  - 迄
+  - 伟
+  - 传
+  - 乒
+  - 乓
+  - 休
+  - 伍
+  - 伏
+  - 优
+  - 臼
+  - 伐
+  - 延
+  - 仲
+  - 件
+  - 任
+  - 伤
+  - 价
+  - 伦
+  - 份
+  - 华
+  - 仰
+  - 仿
+  - 伙
+  - 伪
+  - 自
+  - 伊
+  - 血
+  - 向
+  - 似
+  - 后
+  - 行
+  - 舟
+  - 全
+  - 会
+  - 杀
+  - 合
+  - 兆
+  - 企
+  - 众
+  - 爷
+  - 伞
+  - 创
+  - 肌
+  - 肋
+  - 朵
+  - 杂
+  - 危
+  - 旬
+  - 旨
+  - 旭
+  - 负
+  - 匈
+  - 名
+  - 各
+  - 多
+  - 争
+  - 色
+  - 壮
+  - 冲
+  - 妆
+  - 冰
+  - 庄
+  - 庆
+  - 亦
+  - 刘
+  - 齐
+  - 交
+  - 衣
+  - 次
+  - 产
+  - 决
+  - 亥
+  - 充
+  - 妄
+  - 闭
+  - 问
+  - 闯
+  - 羊
+  - 并
+  - 关
+  - 米
+  - 灯
+  - 州
+  - 汗
+  - 污
+  - 江
+  - 汛
+  - 池
+  - 汝
+  - 汤
+  - 忙
+  - 兴
+  - 宇
+  - 守
+  - 宅
+  - 字
+  - 安
+  - 讲
+  - 讳
+  - 军
+  - 讶
+  - 许
+  - 讹
+  - 论
+  - 讼
+  - 农
+  - 讽
+  - 设
+  - 访
+  - 诀
+  - 寻
+  - 那
+  - 迅
+  - 尽
+  - 导
+  - 异
+  - 弛
+  - 孙
+  - 阵
+  - 阳
+  - 收
+  - 阶
+  - 阴
+  - 防
+  - 奸
+  - 如
+  - 妇
+  - 妃
+  - 好
+  - 她
+  - 妈
+  - 戏
+  - 羽
+  - 观
+  - 欢
+  - 买
+  - 红
+  - 驮
+  - 纤
+  - 驯
+  - 约
+  - 级
+  - 纪
+  - 驰
+  - 纫
+  - 巡
+  - 寿
+  - 弄
+  - 麦
+  - 玖
+  - 玛
+  - 形
+  - 进
+  - 戒
+  - 吞
+  - 远
+  - 违
+  - 韧
+  - 运
+  - 扶
+  - 抚
+  - 坛
+  - 技
+  - 坏
+  - 抠
+  - 扰
+  - 扼
+  - 拒
+  - 找
+  - 批
+  - 址
+  - 扯
+  - 走
+  - 抄
+  - 贡
+  - 汞
+  - 坝
+  - 攻
+  - 赤
+  - 折
+  - 抓
+  - 扳
+  - 抡
+  - 扮
+  - 抢
+  - 孝
+  - 坎
+  - 均
+  - 抑
+  - 抛
+  - 投
+  - 坟
+  - 坑
+  - 抗
+  - 坊
+  - 抖
+  - 护
+  - 壳
+  - 志
+  - 块
+  - 扭
+  - 声
+  - 把
+  - 报
+  - 拟
+  - 却
+  - 抒
+  - 劫
+  - 芙
+  - 芜
+  - 苇
+  - 芽
+  - 花
+  - 芹
+  - 芥
+  - 芬
+  - 苍
+  - 芳
+  - 严
+  - 芦
+  - 芯
+  - 劳
+  - 克
+  - 芭
+  - 苏
+  - 杆
+  - 杠
+  - 杜
+  - 材
+  - 村
+  - 杖
+  - 杏
+  - 杉
+  - 巫
+  - 极
+  - 李
+  - 杨
+  - 求
+  - 甫
+  - 匣
+  - 更
+  - 束
+  - 吾
+  - 豆
+  - 两
+  - 酉
+  - 丽
+  - 医
+  - 辰
+  - 励
+  - 否
+  - 还
+  - 尬
+  - 歼
+  - 来
+  - 连
+  - 轩
+  - 步
+  - 卤
+  - 坚
+  - 肖
+  - 旱
+  - 盯
+  - 呈
+  - 时
+  - 吴
+  - 助
+  - 县
+  - 里
+  - 呆
+  - 吱
+  - 吠
+  - 呕
+  - 园
+  - 旷
+  - 围
+  - 呀
+  - 吨
+  - 足
+  - 邮
+  - 男
+  - 困
+  - 吵
+  - 串
+  - 员
+  - 呐
+  - 听
+  - 吟
+  - 吩
+  - 呛
+  - 吻
+  - 吹
+  - 呜
+  - 吭
+  - 吧
+  - 邑
+  - 吼
+  - 囤
+  - 别
+  - 吮
+  - 岖
+  - 岗
+  - 帐
+  - 财
+  - 针
+  - 钉
+  - 牡
+  - 告
+  - 我
+  - 乱
+  - 利
+  - 秃
+  - 秀
+  - 私
+  - 每
+  - 兵
+  - 估
+  - 体
+  - 何
+  - 佐
+  - 佑
+  - 但
+  - 伸
+  - 佃
+  - 作
+  - 伯
+  - 伶
+  - 佣
+  - 低
+  - 你
+  - 住
+  - 位
+  - 伴
+  - 身
+  - 皂
+  - 伺
+  - 佛
+  - 囱
+  - 近
+  - 彻
+  - 役
+  - 返
+  - 余
+  - 希
+  - 坐
+  - 谷
+  - 妥
+  - 含
+  - 邻
+  - 岔
+  - 肝
+  - 肛
+  - 肚
+  - 肘
+  - 肠
+  - 龟
+  - 甸
+  - 免
+  - 狂
+  - 犹
+  - 狈
+  - 角
+  - 删
+  - 条
+  - 彤
+  - 卵
+  - 灸
+  - 岛
+  - 刨
+  - 迎
+  - 饭
+  - 饮
+  - 系
+  - 言
+  - 冻
+  - 状
+  - 亩
+  - 况
+  - 床
+  - 库
+  - 庇
+  - 疗
+  - 吝
+  - 应
+  - 这
+  - 冷
+  - 庐
+  - 序
+  - 辛
+  - 弃
+  - 冶
+  - 忘
+  - 闰
+  - 闲
+  - 间
+  - 闷
+  - 判
+  - 兑
+  - 灶
+  - 灿
+  - 灼
+  - 弟
+  - 汪
+  - 沐
+  - 沛
+  - 汰
+  - 沥
+  - 沙
+  - 汽
+  - 沃
+  - 沦
+  - 汹
+  - 泛
+  - 沧
+  - 没
+  - 沟
+  - 沪
+  - 沈
+  - 沉
+  - 沁
+  - 怀
+  - 忧
+  - 忱
+  - 快
+  - 完
+  - 宋
+  - 宏
+  - 牢
+  - 究
+  - 穷
+  - 灾
+  - 良
+  - 证
+  - 启
+  - 评
+  - 补
+  - 初
+  - 社
+  - 祀
+  - 识
+  - 诈
+  - 诉
+  - 罕
+  - 诊
+  - 词
+  - 译
+  - 君
+  - 灵
+  - 即
+  - 层
+  - 屁
+  - 尿
+  - 尾
+  - 迟
+  - 局
+  - 改
+  - 张
+  - 忌
+  - 际
+  - 陆
+  - 阿
+  - 陈
+  - 阻
+  - 附
+  - 坠
+  - 妓
+  - 妙
+  - 妖
+  - 姊
+  - 妨
+  - 妒
+  - 努
+  - 忍
+  - 劲
+  - 矣
+  - 鸡
+  - 纬
+  - 驱
+  - 纯
+  - 纱
+  - 纲
+  - 纳
+  - 驳
+  - 纵
+  - 纷
+  - 纸
+  - 纹
+  - 纺
+  - 驴
+  - 纽
+  - 奉
+  - 玩
+  - 环
+  - 武
+  - 青
+  - 责
+  - 现
+  - 玫
+  - 表
+  - 规
+  - 抹
+  - 卦
+  - 坷
+  - 坯
+  - 拓
+  - 拢
+  - 拔
+  - 坪
+  - 拣
+  - 坦
+  - 担
+  - 坤
+  - 押
+  - 抽
+  - 拐
+  - 拖
+  - 者
+  - 拍
+  - 顶
+  - 拆
+  - 拎
+  - 拥
+  - 抵
+  - 拘
+  - 势
+  - 抱
+  - 拄
+  - 垃
+  - 拉
+  - 拦
+  - 幸
+  - 拌
+  - 拧
+  - 拂
+  - 拙
+  - 招
+  - 坡
+  - 披
+  - 拨
+  - 择
+  - 抬
+  - 拇
+  - 拗
+  - 其
+  - 取
+  - 茉
+  - 苦
+  - 昔
+  - 苛
+  - 若
+  - 茂
+  - 苹
+  - 苗
+  - 英
+  - 苟
+  - 苑
+  - 苞
+  - 范
+  - 直
+  - 茁
+  - 茄
+  - 茎
+  - 苔
+  - 茅
+  - 枉
+  - 林
+  - 枝
+  - 杯
+  - 枢
+  - 柜
+  - 枚
+  - 析
+  - 板
+  - 松
+  - 枪
+  - 枫
+  - 构
+  - 杭
+  - 杰
+  - 述
+  - 枕
+  - 丧
+  - 或
+  - 画
+  - 卧
+  - 事
+  - 刺
+  - 枣
+  - 雨
+  - 卖
+  - 郁
+  - 矾
+  - 矿
+  - 码
+  - 厕
+  - 奈
+  - 奔
+  - 奇
+  - 奋
+  - 态
+  - 欧
+  - 殴
+  - 垄
+  - 妻
+  - 轰
+  - 顷
+  - 转
+  - 斩
+  - 轮
+  - 软
+  - 到
+  - 非
+  - 叔
+  - 歧
+  - 肯
+  - 齿
+  - 些
+  - 卓
+  - 虎
+  - 虏
+  - 肾
+  - 贤
+  - 尚
+  - 旺
+  - 具
+  - 味
+  - 果
+  - 昆
+  - 国
+  - 哎
+  - 咕
+  - 昌
+  - 呵
+  - 畅
+  - 明
+  - 易
+  - 咙
+  - 昂
+  - 迪
+  - 典
+  - 固
+  - 忠
+  - 呻
+  - 咒
+  - 咋
+  - 咐
+  - 呼
+  - 鸣
+  - 咏
+  - 呢
+  - 咄
+  - 咖
+  - 岸
+  - 岩
+  - 帖
+  - 罗
+  - 帜
+  - 帕
+  - 岭
+  - 凯
+  - 败
+  - 账
+  - 贩
+  - 贬
+  - 购
+  - 贮
+  - 图
+  - 钓
+  - 制
+  - 知
+  - 迭
+  - 氛
+  - 垂
+  - 牧
+  - 物
+  - 乖
+  - 刮
+  - 秆
+  - 和
+  - 季
+  - 委
+  - 秉
+  - 佳
+  - 侍
+  - 岳
+  - 供
+  - 使
+  - 例
+  - 侠
+  - 侥
+  - 版
+  - 侄
+  - 侦
+  - 侣
+  - 侧
+  - 凭
+  - 侨
+  - 佩
+  - 货
+  - 侈
+  - 依
+  - 卑
+  - 的
+  - 迫
+  - 质
+  - 欣
+  - 征
+  - 往
+  - 爬
+  - 彼
+  - 径
+  - 所
+  - 舍
+  - 金
+  - 刹
+  - 命
+  - 肴
+  - 斧
+  - 爸
+  - 采
+  - 觅
+  - 受
+  - 乳
+  - 贪
+  - 念
+  - 贫
+  - 忿
+  - 肤
+  - 肺
+  - 肢
+  - 肿
+  - 胀
+  - 朋
+  - 股
+  - 肮
+  - 肪
+  - 肥
+  - 服
+  - 胁
+  - 周
+  - 昏
+  - 鱼
+  - 兔
+  - 狐
+  - 忽
+  - 狗
+  - 狞
+  - 备
+  - 饰
+  - 饱
+  - 饲
+  - 变
+  - 京
+  - 享
+  - 庞
+  - 店
+  - 夜
+  - 庙
+  - 府
+  - 底
+  - 疟
+  - 疙
+  - 疚
+  - 剂
+  - 卒
+  - 郊
+  - 庚
+  - 废
+  - 净
+  - 盲
+  - 放
+  - 刻
+  - 育
+  - 氓
+  - 闸
+  - 闹
+  - 郑
+  - 券
+  - 卷
+  - 单
+  - 炬
+  - 炒
+  - 炊
+  - 炕
+  - 炎
+  - 炉
+  - 沫
+  - 浅
+  - 法
+  - 泄
+  - 沽
+  - 河
+  - 沾
+  - 泪
+  - 沮
+  - 油
+  - 泊
+  - 沿
+  - 泡
+  - 注
+  - 泣
+  - 泞
+  - 泻
+  - 泌
+  - 泳
+  - 泥
+  - 沸
+  - 沼
+  - 波
+  - 泼
+  - 泽
+  - 治
+  - 怔
+  - 怯
+  - 怖
+  - 性
+  - 怕
+  - 怜
+  - 怪
+  - 怡
+  - 学
+  - 宝
+  - 宗
+  - 定
+  - 宠
+  - 宜
+  - 审
+  - 宙
+  - 官
+  - 空
+  - 帘
+  - 宛
+  - 实
+  - 试
+  - 郎
+  - 诗
+  - 肩
+  - 房
+  - 诚
+  - 衬
+  - 衫
+  - 视
+  - 祈
+  - 话
+  - 诞
+  - 诡
+  - 询
+  - 该
+  - 详
+  - 建
+  - 肃
+  - 录
+  - 隶
+  - 帚
+  - 屉
+  - 居
+  - 届
+  - 刷
+  - 屈
+  - 弧
+  - 弥
+  - 弦
+  - 承
+  - 孟
+  - 陋
+  - 陌
+  - 孤
+  - 陕
+  - 降
+  - 函
+  - 限
+  - 妹
+  - 姑
+  - 姐
+  - 姓
+  - 妮
+  - 始
+  - 姆
+  - 迢
+  - 驾
+  - 叁
+  - 参
+  - 艰
+  - 线
+  - 练
+  - 组
+  - 绅
+  - 细
+  - 驶
+  - 织
+  - 驹
+  - 终
+  - 驻
+  - 绊
+  - 驼
+  - 绍
+  - 绎
+  - 经
+  - 贯
+  - 契
+  - 贰
+  - 奏
+  - 春
+  - 帮
+  - 玷
+  - 珍
+  - 玲
+  - 玻
+  - 毒
+  - 型
+  - 拭
+  - 挂
+  - 封
+  - 持
+  - 拷
+  - 拱
+  - 项
+  - 垮
+  - 挎
+  - 城
+  - 挟
+  - 挠
+  - 政
+  - 赴
+  - 赵
+  - 挡
+  - 拽
+  - 哉
+  - 挺
+  - 括
+  - 垢
+  - 拴
+  - 拾
+  - 挑
+  - 垛
+  - 指
+  - 垫
+  - 挣
+  - 挤
+  - 拼
+  - 挖
+  - 按
+  - 挥
+  - 挪
+  - 拯
+  - 某
+  - 甚
+  - 荆
+  - 茸
+  - 革
+  - 茬
+  - 荐
+  - 巷
+  - 带
+  - 草
+  - 茧
+  - 茵
+  - 茶
+  - 荒
+  - 茫
+  - 荡
+  - 荣
+  - 荤
+  - 荧
+  - 故
+  - 胡
+  - 荫
+  - 荔
+  - 南
+  - 药
+  - 标
+  - 栈
+  - 柑
+  - 枯
+  - 柄
+  - 栋
+  - 相
+  - 查
+  - 柏
+  - 栅
+  - 柳
+  - 柱
+  - 柿
+  - 栏
+  - 柠
+  - 树
+  - 勃
+  - 要
+  - 柬
+  - 咸
+  - 威
+  - 歪
+  - 研
+  - 砖
+  - 厘
+  - 厚
+  - 砌
+  - 砂
+  - 泵
+  - 砚
+  - 砍
+  - 面
+  - 耐
+  - 耍
+  - 牵
+  - 鸥
+  - 残
+  - 殃
+  - 轴
+  - 轻
+  - 鸦
+  - 皆
+  - 韭
+  - 背
+  - 战
+  - 点
+  - 虐
+  - 临
+  - 览
+  - 竖
+  - 省
+  - 削
+  - 尝
+  - 昧
+  - 盹
+  - 是
+  - 盼
+  - 眨
+  - 哇
+  - 哄
+  - 哑
+  - 显
+  - 冒
+  - 映
+  - 星
+  - 昨
+  - 咧
+  - 昭
+  - 畏
+  - 趴
+  - 胃
+  - 贵
+  - 界
+  - 虹
+  - 虾
+  - 蚁
+  - 思
+  - 蚂
+  - 虽
+  - 品
+  - 咽
+  - 骂
+  - 勋
+  - 哗
+  - 咱
+  - 响
+  - 哈
+  - 哆
+  - 咬
+  - 咳
+  - 咪
+  - 哪
+  - 哟
+  - 炭
+  - 峡
+  - 罚
+  - 贱
+  - 贴
+  - 贻
+  - 骨
+  - 幽
+  - 钙
+  - 钝
+  - 钞
+  - 钟
+  - 钢
+  - 钠
+  - 钥
+  - 钦
+  - 钧
+  - 钩
+  - 钮
+  - 卸
+  - 缸
+  - 拜
+  - 看
+  - 矩
+  - 毡
+  - 氢
+  - 怎
+  - 牲
+  - 选
+  - 适
+  - 秒
+  - 香
+  - 种
+  - 秋
+  - 科
+  - 重
+  - 复
+  - 竿
+  - 段
+  - 便
+  - 俩
+  - 贷
+  - 顺
+  - 修
+  - 俏
+  - 保
+  - 促
+  - 俄
+  - 俐
+  - 侮
+  - 俭
+  - 俗
+  - 俘
+  - 信
+  - 皇
+  - 泉
+  - 鬼
+  - 侵
+  - 禹
+  - 侯
+  - 追
+  - 俊
+  - 盾
+  - 待
+  - 徊
+  - 衍
+  - 律
+  - 很
+  - 须
+  - 叙
+  - 剑
+  - 逃
+  - 食
+  - 盆
+  - 胚
+  - 胧
+  - 胆
+  - 胜
+  - 胞
+  - 胖
+  - 脉
+  - 胎
+  - 勉
+  - 狭
+  - 狮
+  - 独
+  - 狰
+  - 狡
+  - 狱
+  - 狠
+  - 贸
+  - 怨
+  - 急
+  - 饵
+  - 饶
+  - 蚀
+  - 饺
+  - 饼
+  - 峦
+  - 弯
+  - 将
+  - 奖
+  - 哀
+  - 亭
+  - 亮
+  - 度
+  - 迹
+  - 庭
+  - 疮
+  - 疯
+  - 疫
+  - 疤
+  - 咨
+  - 姿
+  - 亲
+  - 音
+  - 帝
+  - 施
+  - 闺
+  - 闻
+  - 闽
+  - 阀
+  - 阁
+  - 差
+  - 养
+  - 美
+  - 姜
+  - 叛
+  - 送
+  - 类
+  - 迷
+  - 籽
+  - 娄
+  - 前
+  - 首
+  - 逆
+  - 兹
+  - 总
+  - 炼
+  - 炸
+  - 烁
+  - 炮
+  - 炫
+  - 烂
+  - 剃
+  - 洼
+  - 洁
+  - 洪
+  - 洒
+  - 柒
+  - 浇
+  - 浊
+  - 洞
+  - 测
+  - 洗
+  - 活
+  - 派
+  - 洽
+  - 染
+  - 洛
+  - 浏
+  - 济
+  - 洋
+  - 洲
+  - 浑
+  - 浓
+  - 津
+  - 恃
+  - 恒
+  - 恢
+  - 恍
+  - 恬
+  - 恤
+  - 恰
+  - 恼
+  - 恨
+  - 举
+  - 觉
+  - 宣
+  - 宦
+  - 室
+  - 宫
+  - 宪
+  - 突
+  - 穿
+  - 窃
+  - 客
+  - 诫
+  - 冠
+  - 诬
+  - 语
+  - 扁
+  - 袄
+  - 祖
+  - 神
+  - 祝
+  - 祠
+  - 误
+  - 诱
+  - 诲
+  - 说
+  - 诵
+  - 垦
+  - 退
+  - 既
+  - 屋
+  - 昼
+  - 屏
+  - 屎
+  - 费
+  - 陡
+  - 逊
+  - 眉
+  - 孩
+  - 陨
+  - 除
+  - 险
+  - 院
+  - 娃
+  - 姥
+  - 姨
+  - 姻
+  - 娇
+  - 姚
+  - 娜
+  - 怒
+  - 架
+  - 贺
+  - 盈
+  - 勇
+  - 怠
+  - 癸
+  - 蚤
+  - 柔
+  - 垒
+  - 绑
+  - 绒
+  - 结
+  - 绕
+  - 骄
+  - 绘
+  - 给
+  - 绚
+  - 骆
+  - 络
+  - 绝
+  - 绞
+  - 骇
+  - 统
+  - 耕
+  - 耘
+  - 耗
+  - 耙
+  - 艳
+  - 泰
+  - 秦
+  - 珠
+  - 班
+  - 素
+  - 匿
+  - 蚕
+  - 顽
+  - 盏
+  - 匪
+  - 捞
+  - 栽
+  - 捕
+  - 埂
+  - 捂
+  - 振
+  - 载
+  - 赶
+  - 起
+  - 盐
+  - 捎
+  - 捍
+  - 捏
+  - 埋
+  - 捉
+  - 捆
+  - 捐
+  - 损
+  - 袁
+  - 捌
+  - 都
+  - 哲
+  - 逝
+  - 捡
+  - 挫
+  - 换
+  - 挽
+  - 挚
+  - 热
+  - 恐
+  - 捣
+  - 壶
+  - 捅
+  - 埃
+  - 挨
+  - 耻
+  - 耿
+  - 耽
+  - 聂
+  - 恭
+  - 莽
+  - 莱
+  - 莲
+  - 莫
+  - 莉
+  - 荷
+  - 获
+  - 晋
+  - 恶
+  - 莹
+  - 莺
+  - 真
+  - 框
+  - 梆
+  - 桂
+  - 桔
+  - 栖
+  - 档
+  - 桐
+  - 株
+  - 桥
+  - 桦
+  - 栓
+  - 桃
+  - 格
+  - 桩
+  - 校
+  - 核
+  - 样
+  - 根
+  - 索
+  - 哥
+  - 速
+  - 逗
+  - 栗
+  - 贾
+  - 酌
+  - 配
+  - 翅
+  - 辱
+  - 唇
+  - 夏
+  - 砸
+  - 砰
+  - 砾
+  - 础
+  - 破
+  - 原
+  - 套
+  - 逐
+  - 烈
+  - 殊
+  - 殉
+  - 顾
+  - 轿
+  - 较
+  - 顿
+  - 毙
+  - 致
+  - 柴
+  - 桌
+  - 虑
+  - 监
+  - 紧
+  - 党
+  - 逞
+  - 晒
+  - 眠
+  - 晓
+  - 哮
+  - 唠
+  - 鸭
+  - 晃
+  - 哺
+  - 晌
+  - 剔
+  - 晕
+  - 蚌
+  - 畔
+  - 蚣
+  - 蚊
+  - 蚪
+  - 蚓
+  - 哨
+  - 哩
+  - 圃
+  - 哭
+  - 哦
+  - 恩
+  - 鸯
+  - 唤
+  - 唁
+  - 哼
+  - 唧
+  - 啊
+  - 唉
+  - 唆
+  - 罢
+  - 峭
+  - 峨
+  - 峰
+  - 圆
+  - 峻
+  - 贼
+  - 贿
+  - 赂
+  - 赃
+  - 钱
+  - 钳
+  - 钻
+  - 钾
+  - 铁
+  - 铃
+  - 铅
+  - 缺
+  - 氧
+  - 氨
+  - 特
+  - 牺
+  - 造
+  - 乘
+  - 敌
+  - 秤
+  - 租
+  - 积
+  - 秧
+  - 秩
+  - 称
+  - 秘
+  - 透
+  - 笔
+  - 笑
+  - 笋
+  - 债
+  - 借
+  - 值
+  - 倚
+  - 俺
+  - 倾
+  - 倒
+  - 倘
+  - 俱
+  - 倡
+  - 候
+  - 赁
+  - 俯
+  - 倍
+  - 倦
+  - 健
+  - 臭
+  - 射
+  - 躬
+  - 息
+  - 倔
+  - 徒
+  - 徐
+  - 殷
+  - 舰
+  - 舱
+  - 般
+  - 航
+  - 途
+  - 拿
+  - 耸
+  - 爹
+  - 舀
+  - 爱
+  - 豺
+  - 豹
+  - 颁
+  - 颂
+  - 翁
+  - 胰
+  - 脆
+  - 脂
+  - 胸
+  - 胳
+  - 脏
+  - 脐
+  - 胶
+  - 脑
+  - 脓
+  - 逛
+  - 狸
+  - 狼
+  - 卿
+  - 逢
+  - 鸵
+  - 留
+  - 鸳
+  - 皱
+  - 饿
+  - 馁
+  - 凌
+  - 凄
+  - 恋
+  - 桨
+  - 浆
+  - 衰
+  - 衷
+  - 高
+  - 郭
+  - 席
+  - 准
+  - 座
+  - 症
+  - 病
+  - 疾
+  - 斋
+  - 疹
+  - 疼
+  - 疲
+  - 脊
+  - 效
+  - 离
+  - 紊
+  - 唐
+  - 瓷
+  - 资
+  - 凉
+  - 站
+  - 剖
+  - 竞
+  - 部
+  - 旁
+  - 旅
+  - 畜
+  - 阅
+  - 羞
+  - 羔
+  - 瓶
+  - 拳
+  - 粉
+  - 料
+  - 益
+  - 兼
+  - 烤
+  - 烘
+  - 烦
+  - 烧
+  - 烛
+  - 烟
+  - 烙
+  - 递
+  - 涛
+  - 浙
+  - 涝
+  - 浦
+  - 酒
+  - 涉
+  - 消
+  - 涡
+  - 浩
+  - 海
+  - 涂
+  - 浴
+  - 浮
+  - 涣
+  - 涤
+  - 流
+  - 润
+  - 涧
+  - 涕
+  - 浪
+  - 浸
+  - 涨
+  - 烫
+  - 涩
+  - 涌
+  - 悖
+  - 悟
+  - 悄
+  - 悍
+  - 悔
+  - 悯
+  - 悦
+  - 害
+  - 宽
+  - 家
+  - 宵
+  - 宴
+  - 宾
+  - 窍
+  - 窄
+  - 容
+  - 宰
+  - 案
+  - 请
+  - 朗
+  - 诸
+  - 诺
+  - 读
+  - 扇
+  - 诽
+  - 袜
+  - 袖
+  - 袍
+  - 被
+  - 祥
+  - 课
+  - 冥
+  - 谁
+  - 调
+  - 冤
+  - 谅
+  - 谆
+  - 谈
+  - 谊
+  - 剥
+  - 恳
+  - 展
+  - 剧
+  - 屑
+  - 弱
+  - 陵
+  - 祟
+  - 陶
+  - 陷
+  - 陪
+  - 娱
+  - 娟
+  - 恕
+  - 娥
+  - 娘
+  - 通
+  - 能
+  - 难
+  - 预
+  - 桑
+  - 绢
+  - 绣
+  - 验
+  - 继
+  - 骏
+  - 球
+  - 琐
+  - 理
+  - 琉
+  - 琅
+  - 捧
+  - 堵
+  - 措
+  - 描
+  - 域
+  - 捺
+  - 掩
+  - 捷
+  - 排
+  - 焉
+  - 掉
+  - 捶
+  - 赦
+  - 堆
+  - 推
+  - 埠
+  - 掀
+  - 授
+  - 捻
+  - 教
+  - 掏
+  - 掐
+  - 掠
+  - 掂
+  - 培
+  - 接
+  - 掷
+  - 控
+  - 探
+  - 据
+  - 掘
+  - 掺
+  - 职
+  - 基
+  - 聆
+  - 勘
+  - 聊
+  - 娶
+  - 著
+  - 菱
+  - 勒
+  - 黄
+  - 菲
+  - 萌
+  - 萝
+  - 菌
+  - 萎
+  - 菜
+  - 萄
+  - 菊
+  - 菩
+  - 萍
+  - 菠
+  - 萤
+  - 营
+  - 乾
+  - 萧
+  - 萨
+  - 菇
+  - 械
+  - 彬
+  - 梦
+  - 婪
+  - 梗
+  - 梧
+  - 梢
+  - 梅
+  - 检
+  - 梳
+  - 梯
+  - 桶
+  - 梭
+  - 救
+  - 曹
+  - 副
+  - 票
+  - 酝
+  - 酗
+  - 厢
+  - 戚
+  - 硅
+  - 硕
+  - 奢
+  - 盔
+  - 爽
+  - 聋
+  - 袭
+  - 盛
+  - 匾
+  - 雪
+  - 辅
+  - 辆
+  - 颅
+  - 虚
+  - 彪
+  - 雀
+  - 堂
+  - 常
+  - 眶
+  - 匙
+  - 晨
+  - 睁
+  - 眯
+  - 眼
+  - 悬
+  - 野
+  - 啪
+  - 啦
+  - 曼
+  - 晦
+  - 晚
+  - 啄
+  - 啡
+  - 距
+  - 趾
+  - 啃
+  - 跃
+  - 略
+  - 蚯
+  - 蛀
+  - 蛇
+  - 唬
+  - 累
+  - 鄂
+  - 唱
+  - 患
+  - 啰
+  - 唾
+  - 唯
+  - 啤
+  - 啥
+  - 啸
+  - 崖
+  - 崎
+  - 崭
+  - 逻
+  - 崔
+  - 帷
+  - 崩
+  - 崇
+  - 崛
+  - 婴
+  - 圈
+  - 铐
+  - 铛
+  - 铝
+  - 铜
+  - 铭
+  - 铲
+  - 银
+  - 矫
+  - 甜
+  - 秸
+  - 梨
+  - 犁
+  - 秽
+  - 移
+  - 笨
+  - 笼
+  - 笛
+  - 笙
+  - 符
+  - 第
+  - 敏
+  - 做
+  - 袋
+  - 悠
+  - 偿
+  - 偶
+  - 偎
+  - 偷
+  - 您
+  - 售
+  - 停
+  - 偏
+  - 躯
+  - 兜
+  - 假
+  - 衅
+  - 徘
+  - 徙
+  - 得
+  - 衔
+  - 盘
+  - 舶
+  - 船
+  - 舵
+  - 斜
+  - 盒
+  - 鸽
+  - 敛
+  - 悉
+  - 欲
+  - 彩
+  - 领
+  - 脚
+  - 脖
+  - 脯
+  - 豚
+  - 脸
+  - 脱
+  - 象
+  - 够
+  - 逸
+  - 猜
+  - 猪
+  - 猎
+  - 猫
+  - 凰
+  - 猖
+  - 猛
+  - 祭
+  - 馅
+  - 馆
+  - 凑
+  - 减
+  - 毫
+  - 烹
+  - 庶
+  - 麻
+  - 庵
+  - 痊
+  - 痒
+  - 痕
+  - 廊
+  - 康
+  - 庸
+  - 鹿
+  - 盗
+  - 章
+  - 竟
+  - 商
+  - 族
+  - 旋
+  - 望
+  - 率
+  - 阎
+  - 阐
+  - 着
+  - 羚
+  - 盖
+  - 眷
+  - 粘
+  - 粗
+  - 粒
+  - 断
+  - 剪
+  - 兽
+  - 焊
+  - 焕
+  - 清
+  - 添
+  - 鸿
+  - 淋
+  - 涯
+  - 淹
+  - 渠
+  - 渐
+  - 淑
+  - 淌
+  - 混
+  - 淮
+  - 淆
+  - 渊
+  - 淫
+  - 渔
+  - 淘
+  - 淳
+  - 液
+  - 淤
+  - 淡
+  - 淀
+  - 深
+  - 涮
+  - 涵
+  - 婆
+  - 梁
+  - 渗
+  - 情
+  - 惜
+  - 惭
+  - 悼
+  - 惧
+  - 惕
+  - 惟
+  - 惊
+  - 惦
+  - 悴
+  - 惋
+  - 惨
+  - 惯
+  - 寇
+  - 寅
+  - 寄
+  - 寂
+  - 宿
+  - 窒
+  - 窑
+  - 密
+  - 谋
+  - 谍
+  - 谎
+  - 谐
+  - 袱
+  - 祷
+  - 祸
+  - 谓
+  - 谚
+  - 谜
+  - 逮
+  - 敢
+  - 尉
+  - 屠
+  - 弹
+  - 隋
+  - 堕
+  - 随
+  - 蛋
+  - 隅
+  - 隆
+  - 隐
+  - 婚
+  - 婶
+  - 婉
+  - 颇
+  - 颈
+  - 绩
+  - 绪
+  - 续
+  - 骑
+  - 绰
+  - 绳
+  - 维
+  - 绵
+  - 绷
+  - 绸
+  - 综
+  - 绽
+  - 绿
+  - 缀
+  - 巢
+  - 琴
+  - 琳
+  - 琢
+  - 琼
+  - 斑
+  - 替
+  - 揍
+  - 款
+  - 堪
+  - 塔
+  - 搭
+  - 堰
+  - 揩
+  - 越
+  - 趁
+  - 趋
+  - 超
+  - 揽
+  - 堤
+  - 提
+  - 博
+  - 揭
+  - 喜
+  - 彭
+  - 揣
+  - 插
+  - 揪
+  - 搜
+  - 煮
+  - 援
+  - 搀
+  - 裁
+  - 搁
+  - 搓
+  - 搂
+  - 搅
+  - 壹
+  - 握
+  - 搔
+  - 揉
+  - 斯
+  - 期
+  - 欺
+  - 联
+  - 葫
+  - 散
+  - 惹
+  - 葬
+  - 募
+  - 葛
+  - 董
+  - 葡
+  - 敬
+  - 葱
+  - 蒋
+  - 蒂
+  - 落
+  - 韩
+  - 朝
+  - 辜
+  - 葵
+  - 棒
+  - 棱
+  - 棋
+  - 椰
+  - 植
+  - 森
+  - 焚
+  - 椅
+  - 椒
+  - 棵
+  - 棍
+  - 椎
+  - 棉
+  - 棚
+  - 棕
+  - 棺
+  - 榔
+  - 椭
+  - 惠
+  - 惑
+  - 逼
+  - 粟
+  - 棘
+  - 酣
+  - 酥
+  - 厨
+  - 厦
+  - 硬
+  - 硝
+  - 确
+  - 硫
+  - 雁
+  - 殖
+  - 裂
+  - 雄
+  - 颊
+  - 雳
+  - 暂
+  - 雅
+  - 翘
+  - 辈
+  - 悲
+  - 紫
+  - 凿
+  - 辉
+  - 敞
+  - 棠
+  - 赏
+  - 掌
+  - 晴
+  - 睐
+  - 暑
+  - 最
+  - 晰
+  - 量
+  - 鼎
+  - 喷
+  - 喳
+  - 晶
+  - 喇
+  - 遇
+  - 喊
+  - 遏
+  - 晾
+  - 景
+  - 畴
+  - 践
+  - 跋
+  - 跌
+  - 跑
+  - 跛
+  - 遗
+  - 蛙
+  - 蛛
+  - 蜓
+  - 蜒
+  - 蛤
+  - 喝
+  - 鹃
+  - 喂
+  - 喘
+  - 喉
+  - 喻
+  - 啼
+  - 喧
+  - 嵌
+  - 幅
+  - 帽
+  - 赋
+  - 赌
+  - 赎
+  - 赐
+  - 赔
+  - 黑
+  - 铸
+  - 铺
+  - 链
+  - 销
+  - 锁
+  - 锄
+  - 锅
+  - 锈
+  - 锋
+  - 锌
+  - 锐
+  - 甥
+  - 掰
+  - 短
+  - 智
+  - 氮
+  - 毯
+  - 氯
+  - 鹅
+  - 剩
+  - 稍
+  - 程
+  - 稀
+  - 税
+  - 筐
+  - 等
+  - 筑
+  - 策
+  - 筛
+  - 筒
+  - 筏
+  - 答
+  - 筋
+  - 筝
+  - 傲
+  - 傅
+  - 牌
+  - 堡
+  - 集
+  - 焦
+  - 傍
+  - 储
+  - 皓
+  - 皖
+  - 粤
+  - 奥
+  - 街
+  - 惩
+  - 御
+  - 循
+  - 艇
+  - 舒
+  - 逾
+  - 番
+  - 释
+  - 禽
+  - 腊
+  - 脾
+  - 腋
+  - 腔
+  - 腕
+  - 鲁
+  - 猩
+  - 猬
+  - 猾
+  - 猴
+  - 惫
+  - 然
+  - 馈
+  - 馋
+  - 装
+  - 蛮
+  - 就
+  - 敦
+  - 斌
+  - 痘
+  - 痢
+  - 痪
+  - 痛
+  - 童
+  - 竣
+  - 阔
+  - 善
+  - 翔
+  - 羡
+  - 普
+  - 粪
+  - 尊
+  - 奠
+  - 道
+  - 遂
+  - 曾
+  - 焰
+  - 港
+  - 滞
+  - 湖
+  - 湘
+  - 渣
+  - 渤
+  - 渺
+  - 湿
+  - 温
+  - 渴
+  - 溃
+  - 溅
+  - 滑
+  - 湃
+  - 渝
+  - 湾
+  - 渡
+  - 游
+  - 滋
+  - 渲
+  - 溉
+  - 愤
+  - 慌
+  - 惰
+  - 愕
+  - 愣
+  - 惶
+  - 愧
+  - 愉
+  - 慨
+  - 割
+  - 寒
+  - 富
+  - 寓
+  - 窜
+  - 窝
+  - 窖
+  - 窗
+  - 窘
+  - 遍
+  - 雇
+  - 裕
+  - 裤
+  - 裙
+  - 禅
+  - 禄
+  - 谢
+  - 谣
+  - 谤
+  - 谦
+  - 犀
+  - 属
+  - 屡
+  - 强
+  - 粥
+  - 疏
+  - 隔
+  - 隙
+  - 隘
+  - 媒
+  - 絮
+  - 嫂
+  - 媚
+  - 婿
+  - 登
+  - 缅
+  - 缆
+  - 缉
+  - 缎
+  - 缓
+  - 缔
+  - 缕
+  - 骗
+  - 编
+  - 骚
+  - 缘
+  - 瑟
+  - 鹉
+  - 瑞
+  - 瑰
+  - 瑙
+  - 魂
+  - 肆
+  - 摄
+  - 摸
+  - 填
+  - 搏
+  - 塌
+  - 鼓
+  - 摆
+  - 携
+  - 搬
+  - 摇
+  - 搞
+  - 塘
+  - 摊
+  - 聘
+  - 斟
+  - 蒜
+  - 勤
+  - 靴
+  - 靶
+  - 鹊
+  - 蓝
+  - 墓
+  - 幕
+  - 蓬
+  - 蓄
+  - 蒲
+  - 蓉
+  - 蒙
+  - 蒸
+  - 献
+  - 椿
+  - 禁
+  - 楚
+  - 楷
+  - 榄
+  - 想
+  - 槐
+  - 榆
+  - 楼
+  - 概
+  - 赖
+  - 酪
+  - 酬
+  - 感
+  - 碍
+  - 碘
+  - 碑
+  - 碎
+  - 碰
+  - 碗
+  - 碌
+  - 尴
+  - 雷
+  - 零
+  - 雾
+  - 雹
+  - 辐
+  - 辑
+  - 输
+  - 督
+  - 频
+  - 龄
+  - 鉴
+  - 睛
+  - 睹
+  - 睦
+  - 瞄
+  - 睫
+  - 睡
+  - 睬
+  - 嗜
+  - 鄙
+  - 嗦
+  - 愚
+  - 暖
+  - 盟
+  - 歇
+  - 暗
+  - 暇
+  - 照
+  - 畸
+  - 跨
+  - 跷
+  - 跳
+  - 跺
+  - 跪
+  - 路
+  - 跤
+  - 跟
+  - 遣
+  - 蜈
+  - 蜗
+  - 蛾
+  - 蜂
+  - 蜕
+  - 嗅
+  - 嗡
+  - 嗓
+  - 署
+  - 置
+  - 罪
+  - 罩
+  - 蜀
+  - 幌
+  - 错
+  - 锚
+  - 锡
+  - 锣
+  - 锤
+  - 锥
+  - 锦
+  - 键
+  - 锯
+  - 锰
+  - 矮
+  - 辞
+  - 稚
+  - 稠
+  - 颓
+  - 愁
+  - 筹
+  - 签
+  - 简
+  - 筷
+  - 毁
+  - 舅
+  - 鼠
+  - 催
+  - 傻
+  - 像
+  - 躲
+  - 魁
+  - 衙
+  - 微
+  - 愈
+  - 遥
+  - 腻
+  - 腰
+  - 腥
+  - 腮
+  - 腹
+  - 腺
+  - 鹏
+  - 腾
+  - 腿
+  - 鲍
+  - 猿
+  - 颖
+  - 触
+  - 解
+  - 煞
+  - 雏
+  - 馍
+  - 馏
+  - 酱
+  - 禀
+  - 痹
+  - 廓
+  - 痴
+  - 痰
+  - 廉
+  - 靖
+  - 新
+  - 韵
+  - 意
+  - 誊
+  - 粮
+  - 数
+  - 煎
+  - 塑
+  - 慈
+  - 煤
+  - 煌
+  - 满
+  - 漠
+  - 滇
+  - 源
+  - 滤
+  - 滥
+  - 滔
+  - 溪
+  - 溜
+  - 漓
+  - 滚
+  - 溢
+  - 溯
+  - 滨
+  - 溶
+  - 溺
+  - 粱
+  - 滩
+  - 慎
+  - 誉
+  - 塞
+  - 寞
+  - 窥
+  - 窟
+  - 寝
+  - 谨
+  - 褂
+  - 裸
+  - 福
+  - 谬
+  - 群
+  - 殿
+  - 辟
+  - 障
+  - 媳
+  - 嫉
+  - 嫌
+  - 嫁
+  - 叠
+  - 缚
+  - 缝
+  - 缠
+  - 缤
+  - 剿
+  - 静
+  - 碧
+  - 璃
+  - 赘
+  - 熬
+  - 墙
+  - 墟
+  - 嘉
+  - 摧
+  - 赫
+  - 截
+  - 誓
+  - 境
+  - 摘
+  - 摔
+  - 撇
+  - 聚
+  - 慕
+  - 暮
+  - 摹
+  - 蔓
+  - 蔑
+  - 蔡
+  - 蔗
+  - 蔽
+  - 蔼
+  - 熙
+  - 蔚
+  - 兢
+  - 模
+  - 槛
+  - 榴
+  - 榜
+  - 榨
+  - 榕
+  - 歌
+  - 遭
+  - 酵
+  - 酷
+  - 酿
+  - 酸
+  - 碟
+  - 碱
+  - 碳
+  - 磁
+  - 愿
+  - 需
+  - 辖
+  - 辗
+  - 雌
+  - 裳
+  - 颗
+  - 瞅
+  - 墅
+  - 嗽
+  - 踊
+  - 蜻
+  - 蜡
+  - 蝇
+  - 蜘
+  - 蝉
+  - 嘛
+  - 嘀
+  - 赚
+  - 锹
+  - 锻
+  - 镀
+  - 舞
+  - 舔
+  - 稳
+  - 熏
+  - 箕
+  - 算
+  - 箩
+  - 管
+  - 箫
+  - 舆
+  - 僚
+  - 僧
+  - 鼻
+  - 魄
+  - 魅
+  - 貌
+  - 膜
+  - 膊
+  - 膀
+  - 鲜
+  - 疑
+  - 孵
+  - 馒
+  - 裹
+  - 敲
+  - 豪
+  - 膏
+  - 遮
+  - 腐
+  - 瘩
+  - 瘟
+  - 瘦
+  - 辣
+  - 彰
+  - 竭
+  - 端
+  - 旗
+  - 精
+  - 粹
+  - 歉
+  - 弊
+  - 熄
+  - 熔
+  - 煽
+  - 潇
+  - 漆
+  - 漱
+  - 漂
+  - 漫
+  - 滴
+  - 漾
+  - 演
+  - 漏
+  - 慢
+  - 慷
+  - 寨
+  - 赛
+  - 寡
+  - 察
+  - 蜜
+  - 寥
+  - 谭
+  - 肇
+  - 褐
+  - 褪
+  - 谱
+  - 隧
+  - 嫩
+  - 翠
+  - 熊
+  - 凳
+  - 骡
+  - 缩
+  - 慧
+  - 撵
+  - 撕
+  - 撒
+  - 撩
+  - 趣
+  - 趟
+  - 撑
+  - 撮
+  - 撬
+  - 播
+  - 擒
+  - 墩
+  - 撞
+  - 撤
+  - 增
+  - 撰
+  - 聪
+  - 鞋
+  - 鞍
+  - 蕉
+  - 蕊
+  - 蔬
+  - 蕴
+  - 横
+  - 槽
+  - 樱
+  - 橡
+  - 樟
+  - 橄
+  - 敷
+  - 豌
+  - 飘
+  - 醋
+  - 醇
+  - 醉
+  - 磕
+  - 磊
+  - 磅
+  - 碾
+  - 震
+  - 霄
+  - 霉
+  - 瞒
+  - 题
+  - 暴
+  - 瞎
+  - 嘻
+  - 嘶
+  - 嘲
+  - 嘹
+  - 影
+  - 踢
+  - 踏
+  - 踩
+  - 踪
+  - 蝶
+  - 蝴
+  - 蝠
+  - 蝎
+  - 蝌
+  - 蝗
+  - 蝙
+  - 嘿
+  - 嘱
+  - 幢
+  - 墨
+  - 镇
+  - 镐
+  - 镑
+  - 靠
+  - 稽
+  - 稻
+  - 黎
+  - 稿
+  - 稼
+  - 箱
+  - 篓
+  - 箭
+  - 篇
+  - 僵
+  - 躺
+  - 僻
+  - 德
+  - 艘
+  - 膝
+  - 膛
+  - 鲤
+  - 鲫
+  - 熟
+  - 摩
+  - 褒
+  - 瘪
+  - 瘤
+  - 瘫
+  - 凛
+  - 颜
+  - 毅
+  - 糊
+  - 遵
+  - 憋
+  - 潜
+  - 澎
+  - 潮
+  - 潭
+  - 鲨
+  - 澳
+  - 潘
+  - 澈
+  - 澜
+  - 澄
+  - 懂
+  - 憔
+  - 懊
+  - 憎
+  - 额
+  - 翩
+  - 褥
+  - 谴
+  - 鹤
+  - 憨
+  - 慰
+  - 劈
+  - 履
+  - 豫
+  - 缭
+  - 撼
+  - 擂
+  - 操
+  - 擅
+  - 燕
+  - 蕾
+  - 薯
+  - 薛
+  - 薇
+  - 擎
+  - 薪
+  - 薄
+  - 颠
+  - 翰
+  - 噩
+  - 橱
+  - 橙
+  - 橘
+  - 整
+  - 融
+  - 瓢
+  - 醒
+  - 霍
+  - 霎
+  - 辙
+  - 冀
+  - 餐
+  - 嘴
+  - 踱
+  - 蹄
+  - 蹂
+  - 蟆
+  - 螃
+  - 器
+  - 噪
+  - 鹦
+  - 赠
+  - 默
+  - 黔
+  - 镜
+  - 赞
+  - 穆
+  - 篮
+  - 篡
+  - 篷
+  - 篱
+  - 儒
+  - 邀
+  - 衡
+  - 膨
+  - 雕
+  - 鲸
+  - 磨
+  - 瘾
+  - 瘸
+  - 凝
+  - 辨
+  - 辩
+  - 糙
+  - 糖
+  - 糕
+  - 燃
+  - 濒
+  - 澡
+  - 激
+  - 懒
+  - 憾
+  - 懈
+  - 窿
+  - 壁
+  - 避
+  - 缰
+  - 缴
+  - 戴
+  - 擦
+  - 藉
+  - 鞠
+  - 藏
+  - 藐
+  - 檬
+  - 檐
+  - 檀
+  - 礁
+  - 磷
+  - 霜
+  - 霞
+  - 瞭
+  - 瞧
+  - 瞬
+  - 瞳
+  - 瞩
+  - 瞪
+  - 曙
+  - 蹋
+  - 蹈
+  - 螺
+  - 蟋
+  - 蟀
+  - 嚎
+  - 赡
+  - 穗
+  - 魏
+  - 簧
+  - 簇
+  - 繁
+  - 徽
+  - 爵
+  - 朦
+  - 臊
+  - 鳄
+  - 癌
+  - 辫
+  - 赢
+  - 糟
+  - 糠
+  - 燥
+  - 懦
+  - 豁
+  - 臀
+  - 臂
+  - 翼
+  - 骤
+  - 藕
+  - 鞭
+  - 藤
+  - 覆
+  - 瞻
+  - 蹦
+  - 嚣
+  - 镰
+  - 翻
+  - 鳍
+  - 鹰
+  - 瀑
+  - 襟
+  - 璧
+  - 戳
+  - 孽
+  - 警
+  - 蘑
+  - 藻
+  - 攀
+  - 曝
+  - 蹲
+  - 蹭
+  - 蹬
+  - 巅
+  - 簸
+  - 簿
+  - 蟹
+  - 颤
+  - 靡
+  - 癣
+  - 瓣
+  - 羹
+  - 鳖
+  - 爆
+  - 疆
+  - 鬓
+  - 壤
+  - 馨
+  - 耀
+  - 躁
+  - 蠕
+  - 嚼
+  - 嚷
+  - 巍
+  - 籍
+  - 鳞
+  - 魔
+  - 糯
+  - 灌
+  - 譬
+  - 蠢
+  - 霸
+  - 露
+  - 霹
+  - 躏
+  - 黯
+  - 髓
+  - 赣
+  - 囊
+  - 镶
+  - 瓤
+  - 罐
+  - 矗
+  - 乂
+  - 乜
+  - 兀
+  - 弋
+  - 孑
+  - 孓
+  - 幺
+  - 亓
+  - 韦
+  - 廿
+  - 丏
+  - 卅
+  - 仄
+  - 厄
+  - 仃
+  - 仉
+  - 仂
+  - 兮
+  - 刈
+  - 爻
+  - 卞
+  - 闩
+  - 讣
+  - 尹
+  - 夬
+  - 爿
+  - 毋
+  - 邗
+  - 邛
+  - 艽
+  - 艿
+  - 札
+  - 叵
+  - 匝
+  - 丕
+  - 匜
+  - 劢
+  - 卟
+  - 叱
+  - 叻
+  - 仨
+  - 仕
+  - 仟
+  - 仡
+  - 仫
+  - 仞
+  - 卮
+  - 氐
+  - 犰
+  - 刍
+  - 邝
+  - 邙
+  - 汀
+  - 讦
+  - 讧
+  - 讪
+  - 讫
+  - 尻
+  - 阡
+  - 尕
+  - 弁
+  - 驭
+  - 匡
+  - 耒
+  - 玎
+  - 玑
+  - 邢
+  - 圩
+  - 圬
+  - 圭
+  - 扦
+  - 圪
+  - 圳
+  - 圹
+  - 扪
+  - 圮
+  - 圯
+  - 芊
+  - 芍
+  - 芄
+  - 芨
+  - 芑
+  - 芎
+  - 芗
+  - 亘
+  - 厍
+  - 夼
+  - 戍
+  - 尥
+  - 乩
+  - 旯
+  - 曳
+  - 岌
+  - 屺
+  - 凼
+  - 囡
+  - 钇
+  - 缶
+  - 氘
+  - 氖
+  - 牝
+  - 伎
+  - 伛
+  - 伢
+  - 佤
+  - 仵
+  - 伥
+  - 伧
+  - 伉
+  - 伫
+  - 囟
+  - 汆
+  - 刖
+  - 夙
+  - 旮
+  - 刎
+  - 犷
+  - 犸
+  - 舛
+  - 凫
+  - 邬
+  - 饧
+  - 汕
+  - 汔
+  - 汐
+  - 汲
+  - 汜
+  - 汊
+  - 忖
+  - 忏
+  - 讴
+  - 讵
+  - 祁
+  - 讷
+  - 聿
+  - 艮
+  - 厾
+  - 阱
+  - 阮
+  - 阪
+  - 丞
+  - 妁
+  - 牟
+  - 纡
+  - 纣
+  - 纥
+  - 纨
+  - 玕
+  - 玙
+  - 抟
+  - 抔
+  - 圻
+  - 坂
+  - 坍
+  - 坞
+  - 抃
+  - 抉
+  - 㧐
+  - 芫
+  - 邯
+  - 芸
+  - 芾
+  - 苈
+  - 苣
+  - 芷
+  - 芮
+  - 苋
+  - 芼
+  - 苌
+  - 苁
+  - 芩
+  - 芪
+  - 芡
+  - 芟
+  - 苄
+  - 苎
+  - 苡
+  - 杌
+  - 杓
+  - 杞
+  - 杈
+  - 忑
+  - 孛
+  - 邴
+  - 邳
+  - 矶
+  - 奁
+  - 豕
+  - 忒
+  - 欤
+  - 轫
+  - 迓
+  - 邶
+  - 忐
+  - 卣
+  - 邺
+  - 旰
+  - 呋
+  - 呒
+  - 呓
+  - 呔
+  - 呖
+  - 呃
+  - 旸
+  - 吡
+  - 町
+  - 虬
+  - 呗
+  - 吽
+  - 吣
+  - 吲
+  - 帏
+  - 岐
+  - 岈
+  - 岘
+  - 岑
+  - 岚
+  - 兕
+  - 囵
+  - 囫
+  - 钊
+  - 钋
+  - 钌
+  - 迕
+  - 氙
+  - 氚
+  - 牤
+  - 佞
+  - 邱
+  - 攸
+  - 佚
+  - 佝
+  - 佟
+  - 佗
+  - 伽
+  - 彷
+  - 佘
+  - 佥
+  - 孚
+  - 豸
+  - 坌
+  - 肟
+  - 邸
+  - 奂
+  - 劬
+  - 狄
+  - 狁
+  - 鸠
+  - 邹
+  - 饨
+  - 饩
+  - 饪
+  - 饫
+  - 饬
+  - 亨
+  - 庑
+  - 庋
+  - 疔
+  - 疖
+  - 肓
+  - 闱
+  - 闳
+  - 闵
+  - 羌
+  - 炀
+  - 沣
+  - 沅
+  - 沔
+  - 沤
+  - 沌
+  - 沏
+  - 沚
+  - 汩
+  - 汨
+  - 沂
+  - 汾
+  - 沨
+  - 汴
+  - 汶
+  - 沆
+  - 沩
+  - 泐
+  - 怃
+  - 怄
+  - 忡
+  - 忤
+  - 忾
+  - 怅
+  - 忻
+  - 忪
+  - 怆
+  - 忭
+  - 忸
+  - 诂
+  - 诃
+  - 诅
+  - 诋
+  - 诌
+  - 诏
+  - 诒
+  - 孜
+  - 陇
+  - 陀
+  - 陂
+  - 陉
+  - 妍
+  - 妩
+  - 妪
+  - 妣
+  - 妊
+  - 妗
+  - 妫
+  - 妞
+  - 姒
+  - 妤
+  - 邵
+  - 劭
+  - 刭
+  - 甬
+  - 邰
+  - 纭
+  - 纰
+  - 纴
+  - 纶
+  - 纾
+  - 玮
+  - 玡
+  - 玭
+  - 玠
+  - 玢
+  - 玥
+  - 玦
+  - 盂
+  - 忝
+  - 匦
+  - 坩
+  - 抨
+  - 拤
+  - 坫
+  - 拈
+  - 垆
+  - 抻
+  - 劼
+  - 拃
+  - 拊
+  - 坼
+  - 坻
+  - 㧟
+  - 坨
+  - 坭
+  - 抿
+  - 坳
+  - 耶
+  - 苷
+  - 苯
+  - 苤
+  - 茏
+  - 苫
+  - 苜
+  - 苴
+  - 苒
+  - 苘
+  - 茌
+  - 苻
+  - 苓
+  - 茚
+  - 茆
+  - 茑
+  - 茓
+  - 茔
+  - 茕
+  - 茀
+  - 苕
+  - 枥
+  - 枇
+  - 杪
+  - 杳
+  - 枧
+  - 杵
+  - 枨
+  - 枞
+  - 枋
+  - 杻
+  - 杷
+  - 杼
+  - 矸
+  - 砀
+  - 刳
+  - 奄
+  - 瓯
+  - 殁
+  - 郏
+  - 轭
+  - 郅
+  - 鸢
+  - 盱
+  - 昊
+  - 昙
+  - 杲
+  - 昃
+  - 咂
+  - 呸
+  - 昕
+  - 昀
+  - 旻
+  - 昉
+  - 炅
+  - 咔
+  - 畀
+  - 虮
+  - 咀
+  - 呷
+  - 黾
+  - 呱
+  - 呤
+  - 咚
+  - 咆
+  - 咛
+  - 呶
+  - 呣
+  - 呦
+  - 咝
+  - 岢
+  - 岿
+  - 岬
+  - 岫
+  - 帙
+  - 岣
+  - 峁
+  - 刿
+  - 迥
+  - 岷
+  - 剀
+  - 帔
+  - 峄
+  - 沓
+  - 囹
+  - 罔
+  - 钍
+  - 钎
+  - 钏
+  - 钒
+  - 钕
+  - 钗
+  - 邾
+  - 迮
+  - 牦
+  - 竺
+  - 迤
+  - 佶
+  - 佬
+  - 佰
+  - 侑
+  - 侉
+  - 臾
+  - 岱
+  - 侗
+  - 侃
+  - 侏
+  - 侩
+  - 佻
+  - 佾
+  - 侪
+  - 佼
+  - 佯
+  - 侬
+  - 帛
+  - 阜
+  - 侔
+  - 徂
+  - 刽
+  - 郄
+  - 怂
+  - 籴
+  - 瓮
+  - 戗
+  - 肼
+  - 䏝
+  - 肽
+  - 肱
+  - 肫
+  - 剁
+  - 迩
+  - 郇
+  - 狙
+  - 狎
+  - 狍
+  - 狒
+  - 咎
+  - 炙
+  - 枭
+  - 饯
+  - 饴
+  - 冽
+  - 冼
+  - 庖
+  - 疠
+  - 疝
+  - 疡
+  - 兖
+  - 妾
+  - 劾
+  - 炜
+  - 𬉼
+  - 炖
+  - 炘
+  - 炝
+  - 炔
+  - 泔
+  - 沭
+  - 泷
+  - 泸
+  - 泱
+  - 泅
+  - 泗
+  - 泠
+  - 泺
+  - 泖
+  - 泫
+  - 泮
+  - 沱
+  - 泯
+  - 泓
+  - 泾
+  - 怙
+  - 怵
+  - 怦
+  - 怛
+  - 怏
+  - 怍
+  - 㤘
+  - 怩
+  - 怫
+  - 怿
+  - 宕
+  - 穹
+  - 宓
+  - 诓
+  - 诔
+  - 诖
+  - 诘
+  - 戾
+  - 诙
+  - 戽
+  - 郓
+  - 衩
+  - 祆
+  - 祎
+  - 祉
+  - 祇
+  - 诛
+  - 诜
+  - 诟
+  - 诠
+  - 诣
+  - 诤
+  - 诧
+  - 诨
+  - 诩
+  - 戕
+  - 孢
+  - 亟
+  - 陔
+  - 妲
+  - 妯
+  - 姗
+  - 帑
+  - 弩
+  - 孥
+  - 驽
+  - 虱
+  - 迦
+  - 迨
+  - 绀
+  - 绁
+  - 绂
+  - 驷
+  - 驸
+  - 绉
+  - 绌
+  - 驿
+  - 骀
+  - 甾
+  - 珏
+  - 珐
+  - 珂
+  - 珑
+  - 玳
+  - 珀
+  - 顸
+  - 珉
+  - 珈
+  - 拮
+  - 垭
+  - 挝
+  - 垣
+  - 挞
+  - 垤
+  - 赳
+  - 贲
+  - 垱
+  - 垌
+  - 郝
+  - 垧
+  - 垓
+  - 挦
+  - 垠
+  - 茜
+  - 荚
+  - 荑
+  - 贳
+  - 荜
+  - 莒
+  - 茼
+  - 茴
+  - 茱
+  - 莛
+  - 荞
+  - 茯
+  - 荏
+  - 荇
+  - 荃
+  - 荟
+  - 荀
+  - 茗
+  - 荠
+  - 茭
+  - 茨
+  - 垩
+  - 荥
+  - 荦
+  - 荨
+  - 荩
+  - 剋
+  - 荪
+  - 茹
+  - 荬
+  - 荮
+  - 柰
+  - 栉
+  - 柯
+  - 柘
+  - 栊
+  - 柩
+  - 枰
+  - 栌
+  - 柙
+  - 枵
+  - 柚
+  - 枳
+  - 柞
+  - 柝
+  - 栀
+  - 柢
+  - 栎
+  - 枸
+  - 柈
+  - 柁
+  - 枷
+  - 柽
+  - 剌
+  - 酊
+  - 郦
+  - 甭
+  - 砗
+  - 砘
+  - 砒
+  - 斫
+  - 砭
+  - 砜
+  - 奎
+  - 耷
+  - 虺
+  - 殂
+  - 殇
+  - 殄
+  - 殆
+  - 轱
+  - 轲
+  - 轳
+  - 轶
+  - 轸
+  - 虿
+  - 毖
+  - 觇
+  - 尜
+  - 哐
+  - 眄
+  - 眍
+  - 𠳐
+  - 郢
+  - 眇
+  - 眊
+  - 眈
+  - 禺
+  - 哂
+  - 咴
+  - 曷
+  - 昴
+  - 昱
+  - 昵
+  - 咦
+  - 哓
+  - 哔
+  - 畎
+  - 毗
+  - 呲
+  - 胄
+  - 畋
+  - 畈
+  - 虼
+  - 虻
+  - 盅
+  - 咣
+  - 哕
+  - 剐
+  - 郧
+  - 咻
+  - 囿
+  - 咿
+  - 哌
+  - 哙
+  - 哚
+  - 咯
+  - 咩
+  - 咤
+  - 哝
+  - 哏
+  - 哞
+  - 峙
+  - 峣
+  - 罘
+  - 帧
+  - 峒
+  - 峤
+  - 峋
+  - 峥
+  - 贶
+  - 钚
+  - 钛
+  - 钡
+  - 钣
+  - 钤
+  - 钨
+  - 钫
+  - 钯
+  - 氡
+  - 氟
+  - 牯
+  - 郜
+  - 秕
+  - 秭
+  - 竽
+  - 笈
+  - 笃
+  - 俦
+  - 俨
+  - 俅
+  - 俪
+  - 叟
+  - 垡
+  - 牮
+  - 俣
+  - 俚
+  - 皈
+  - 俑
+  - 俟
+  - 逅
+  - 徇
+  - 徉
+  - 舢
+  - 俞
+  - 郗
+  - 俎
+  - 郤
+  - 爰
+  - 郛
+  - 瓴
+  - 胨
+  - 胪
+  - 胛
+  - 胂
+  - 胙
+  - 胍
+  - 胗
+  - 胝
+  - 朐
+  - 胫
+  - 鸨
+  - 匍
+  - 狨
+  - 狯
+  - 飑
+  - 狩
+  - 狲
+  - 訇
+  - 逄
+  - 昝
+  - 饷
+  - 饸
+  - 饹
+  - 胤
+  - 孪
+  - 娈
+  - 弈
+  - 奕
+  - 庥
+  - 疬
+  - 疣
+  - 疥
+  - 疭
+  - 庠
+  - 竑
+  - 彦
+  - 飒
+  - 闼
+  - 闾
+  - 闿
+  - 阂
+  - 羑
+  - 迸
+  - 籼
+  - 酋
+  - 炳
+  - 炻
+  - 炽
+  - 炯
+  - 烀
+  - 炷
+  - 烃
+  - 洱
+  - 洹
+  - 洧
+  - 洌
+  - 浃
+  - 洇
+  - 洄
+  - 洙
+  - 涎
+  - 洎
+  - 洫
+  - 浍
+  - 洮
+  - 洵
+  - 浒
+  - 浔
+  - 浕
+  - 洳
+  - 恸
+  - 恓
+  - 恹
+  - 恫
+  - 恺
+  - 恻
+  - 恂
+  - 恪
+  - 恽
+  - 宥
+  - 扃
+  - 衲
+  - 衽
+  - 衿
+  - 袂
+  - 祛
+  - 祜
+  - 祓
+  - 祚
+  - 诮
+  - 祗
+  - 祢
+  - 诰
+  - 诳
+  - 鸩
+  - 昶
+  - 郡
+  - 咫
+  - 弭
+  - 牁
+  - 胥
+  - 陛
+  - 陟
+  - 娅
+  - 姮
+  - 娆
+  - 姝
+  - 姣
+  - 姘
+  - 姹
+  - 怼
+  - 羿
+  - 炱
+  - 矜
+  - 绔
+  - 骁
+  - 骅
+  - 绗
+  - 绛
+  - 骈
+  - 耖
+  - 挈
+  - 珥
+  - 珙
+  - 顼
+  - 珰
+  - 珩
+  - 珧
+  - 珣
+  - 珞
+  - 琤
+  - 珲
+  - 敖
+  - 恚
+  - 埔
+  - 埕
+  - 埘
+  - 埙
+  - 埚
+  - 挹
+  - 耆
+  - 耄
+  - 埒
+  - 捋
+  - 贽
+  - 垸
+  - 捃
+  - 盍
+  - 荸
+  - 莆
+  - 莳
+  - 莴
+  - 莪
+  - 莠
+  - 莓
+  - 莜
+  - 莅
+  - 荼
+  - 莩
+  - 荽
+  - 莸
+  - 荻
+  - 莘
+  - 莎
+  - 莞
+  - 莨
+  - 渇
+  - 鸪
+  - 莼
+  - 栲
+  - 栳
+  - 郴
+  - 桓
+  - 桡
+  - 桎
+  - 桢
+  - 桤
+  - 梃
+  - 栝
+  - 桕
+  - 桁
+  - 桧
+  - 桅
+  - 栟
+  - 桉
+  - 栩
+  - 逑
+  - 逋
+  - 彧
+  - 鬲
+  - 豇
+  - 酐
+  - 逦
+  - 厝
+  - 孬
+  - 砝
+  - 砹
+  - 砺
+  - 砧
+  - 砷
+  - 砟
+  - 砼
+  - 砥
+  - 砣
+  - 剞
+  - 砻
+  - 轼
+  - 轾
+  - 辂
+  - 鸫
+  - 趸
+  - 龀
+  - 鸬
+  - 虔
+  - 逍
+  - 眬
+  - 唛
+  - 晟
+  - 眩
+  - 眙
+  - 哧
+  - 哽
+  - 唔
+  - 晁
+  - 晏
+  - 鸮
+  - 趵
+  - 趿
+  - 畛
+  - 蚨
+  - 蚜
+  - 蚍
+  - 蚋
+  - 蚬
+  - 蚝
+  - 蚧
+  - 唢
+  - 圄
+  - 唣
+  - 唏
+  - 盎
+  - 唑
+  - 崂
+  - 崃
+  - 罡
+  - 罟
+  - 峪
+  - 觊
+  - 赅
+  - 钰
+  - 钲
+  - 钴
+  - 钵
+  - 钹
+  - 钺
+  - 钽
+  - 钼
+  - 钿
+  - 铀
+  - 铂
+  - 铄
+  - 铆
+  - 铈
+  - 铉
+  - 铊
+  - 铋
+  - 铌
+  - 铍
+  - 䥽
+  - 铎
+  - 氩
+  - 氤
+  - 氦
+  - 毪
+  - 舐
+  - 秣
+  - 秫
+  - 盉
+  - 笄
+  - 笕
+  - 笊
+  - 笏
+  - 笆
+  - 俸
+  - 倩
+  - 俵
+  - 偌
+  - 俳
+  - 俶
+  - 倬
+  - 倏
+  - 恁
+  - 倭
+  - 倪
+  - 俾
+  - 倜
+  - 隼
+  - 隽
+  - 倌
+  - 倥
+  - 臬
+  - 皋
+  - 郫
+  - 倨
+  - 衄
+  - 颀
+  - 徕
+  - 舫
+  - 釜
+  - 奚
+  - 衾
+  - 胯
+  - 胱
+  - 胴
+  - 胭
+  - 脍
+  - 胼
+  - 朕
+  - 脒
+  - 胺
+  - 鸱
+  - 玺
+  - 鸲
+  - 狷
+  - 猁
+  - 狳
+  - 猃
+  - 狺
+  - 逖
+  - 桀
+  - 袅
+  - 饽
+  - 凇
+  - 栾
+  - 挛
+  - 亳
+  - 疳
+  - 疴
+  - 疸
+  - 疽
+  - 痈
+  - 疱
+  - 痂
+  - 痉
+  - 衮
+  - 凋
+  - 颃
+  - 恣
+  - 旆
+  - 旄
+  - 旃
+  - 阃
+  - 阄
+  - 訚
+  - 阆
+  - 恙
+  - 粑
+  - 朔
+  - 郸
+  - 烜
+  - 烨
+  - 烩
+  - 烊
+  - 剡
+  - 郯
+  - 烬
+  - 涑
+  - 浯
+  - 涞
+  - 涟
+  - 娑
+  - 涅
+  - 涠
+  - 浞
+  - 涓
+  - 浥
+  - 涔
+  - 浜
+  - 浠
+  - 浣
+  - 浚
+  - 悚
+  - 悭
+  - 悝
+  - 悒
+  - 悌
+  - 悛
+  - 宸
+  - 窈
+  - 剜
+  - 诹
+  - 冢
+  - 诼
+  - 袒
+  - 袢
+  - 祯
+  - 诿
+  - 谀
+  - 谂
+  - 谄
+  - 谇
+  - 屐
+  - 屙
+  - 陬
+  - 勐
+  - 奘
+  - 牂
+  - 蚩
+  - 陲
+  - 姬
+  - 娠
+  - 娌
+  - 娉
+  - 娲
+  - 娩
+  - 娴
+  - 娣
+  - 娓
+  - 婀
+  - 畚
+  - 逡
+  - 绠
+  - 骊
+  - 绡
+  - 骋
+  - 绥
+  - 绦
+  - 绨
+  - 骎
+  - 邕
+  - 鸶
+  - 彗
+  - 耜
+  - 焘
+  - 舂
+  - 琏
+  - 琇
+  - 麸
+  - 揶
+  - 埴
+  - 埯
+  - 捯
+  - 掳
+  - 掴
+  - 埸
+  - 埵
+  - 赧
+  - 埤
+  - 捭
+  - 逵
+  - 埝
+  - 堋
+  - 堍
+  - 掬
+  - 鸷
+  - 掖
+  - 捽
+  - 掊
+  - 堉
+  - 掸
+  - 捩
+  - 掮
+  - 悫
+  - 埭
+  - 埽
+  - 掇
+  - 掼
+  - 聃
+  - 菁
+  - 萁
+  - 菘
+  - 堇
+  - 萘
+  - 萋
+  - 菽
+  - 菖
+  - 萜
+  - 萸
+  - 萑
+  - 棻
+  - 菔
+  - 菟
+  - 萏
+  - 萃
+  - 菏
+  - 菹
+  - 菪
+  - 菅
+  - 菀
+  - 萦
+  - 菰
+  - 菡
+  - 梵
+  - 梿
+  - 梏
+  - 觋
+  - 桴
+  - 桷
+  - 梓
+  - 棁
+  - 桫
+  - 棂
+  - 啬
+  - 郾
+  - 匮
+  - 敕
+  - 豉
+  - 鄄
+  - 酞
+  - 酚
+  - 戛
+  - 硎
+  - 硭
+  - 硒
+  - 硖
+  - 硗
+  - 硐
+  - 硇
+  - 硌
+  - 鸸
+  - 瓠
+  - 匏
+  - 厩
+  - 龚
+  - 殒
+  - 殓
+  - 殍
+  - 赉
+  - 雩
+  - 辄
+  - 堑
+  - 眭
+  - 眦
+  - 啧
+  - 晡
+  - 晤
+  - 眺
+  - 眵
+  - 眸
+  - 圊
+  - 喏
+  - 喵
+  - 啉
+  - 勖
+  - 晞
+  - 唵
+  - 晗
+  - 冕
+  - 啭
+  - 畦
+  - 趺
+  - 啮
+  - 跄
+  - 蚶
+  - 蛄
+  - 蛎
+  - 蛆
+  - 蚰
+  - 蛊
+  - 圉
+  - 蚱
+  - 蛉
+  - 蛏
+  - 蚴
+  - 啁
+  - 啕
+  - 唿
+  - 啐
+  - 唼
+  - 唷
+  - 啖
+  - 啵
+  - 啶
+  - 啷
+  - 唳
+  - 唰
+  - 啜
+  - 帻
+  - 崚
+  - 崦
+  - 帼
+  - 崮
+  - 崤
+  - 崆
+  - 赇
+  - 赈
+  - 赊
+  - 铑
+  - 铒
+  - 铗
+  - 铙
+  - 铟
+  - 铠
+  - 铡
+  - 铢
+  - 铣
+  - 铤
+  - 铧
+  - 铨
+  - 铩
+  - 铪
+  - 铫
+  - 铬
+  - 铮
+  - 铯
+  - 铰
+  - 铱
+  - 铳
+  - 铵
+  - 铷
+  - 氪
+  - 牾
+  - 鸹
+  - 秾
+  - 逶
+  - 笺
+  - 筇
+  - 笸
+  - 笪
+  - 笮
+  - 笠
+  - 笥
+  - 笤
+  - 笳
+  - 笾
+  - 笞
+  - 偾
+  - 偃
+  - 偕
+  - 偈
+  - 傀
+  - 偬
+  - 偻
+  - 皑
+  - 皎
+  - 鸻
+  - 徜
+  - 舸
+  - 舻
+  - 舴
+  - 舷
+  - 龛
+  - 翎
+  - 脬
+  - 脘
+  - 脲
+  - 匐
+  - 猗
+  - 猡
+  - 猞
+  - 猝
+  - 斛
+  - 猕
+  - 馗
+  - 馃
+  - 馄
+  - 鸾
+  - 孰
+  - 庹
+  - 庾
+  - 痔
+  - 痍
+  - 疵
+  - 翊
+  - 旌
+  - 旎
+  - 袤
+  - 阇
+  - 阈
+  - 阉
+  - 阊
+  - 阋
+  - 阍
+  - 阏
+  - 羟
+  - 粝
+  - 粕
+  - 敝
+  - 焐
+  - 烯
+  - 焓
+  - 烽
+  - 焖
+  - 烷
+  - 焗
+  - 渍
+  - 渚
+  - 淇
+  - 淅
+  - 淞
+  - 渎
+  - 涿
+  - 淖
+  - 挲
+  - 淠
+  - 涸
+  - 渑
+  - 淦
+  - 淝
+  - 淬
+  - 涪
+  - 淙
+  - 涫
+  - 渌
+  - 淄
+  - 惬
+  - 悻
+  - 悱
+  - 惝
+  - 惘
+  - 悸
+  - 惆
+  - 惚
+  - 惇
+  - 惮
+  - 窕
+  - 谌
+  - 谏
+  - 扈
+  - 皲
+  - 谑
+  - 裆
+  - 袷
+  - 裉
+  - 谒
+  - 谔
+  - 谕
+  - 谖
+  - 谗
+  - 谙
+  - 谛
+  - 谝
+  - 逯
+  - 郿
+  - 隈
+  - 粜
+  - 隍
+  - 隗
+  - 婧
+  - 婊
+  - 婕
+  - 娼
+  - 婢
+  - 婵
+  - 胬
+  - 袈
+  - 翌
+  - 恿
+  - 欸
+  - 绫
+  - 骐
+  - 绮
+  - 绯
+  - 绱
+  - 骒
+  - 绲
+  - 骓
+  - 绶
+  - 绺
+  - 绻
+  - 绾
+  - 骖
+  - 缁
+  - 耠
+  - 琫
+  - 琵
+  - 琶
+  - 琪
+  - 瑛
+  - 琦
+  - 琥
+  - 琨
+  - 靓
+  - 琰
+  - 琮
+  - 琯
+  - 琬
+  - 琛
+  - 琚
+  - 辇
+  - 鼋
+  - 揳
+  - 堞
+  - 搽
+  - 揸
+  - 揠
+  - 堙
+  - 趄
+  - 揖
+  - 颉
+  - 塄
+  - 揿
+  - 耋
+  - 揄
+  - 蛩
+  - 蛰
+  - 塆
+  - 摒
+  - 揆
+  - 掾
+  - 聒
+  - 葑
+  - 葚
+  - 靰
+  - 靸
+  - 葳
+  - 葺
+  - 葸
+  - 萼
+  - 葆
+  - 葩
+  - 葶
+  - 蒌
+  - 萱
+  - 戟
+  - 葭
+  - 楮
+  - 棼
+  - 椟
+  - 棹
+  - 椤
+  - 棰
+  - 赍
+  - 椋
+  - 椁
+  - 椪
+  - 棣
+  - 椐
+  - 鹁
+  - 覃
+  - 酤
+  - 酢
+  - 酡
+  - 鹂
+  - 厥
+  - 殚
+  - 殛
+  - 雯
+  - 雱
+  - 辊
+  - 辋
+  - 椠
+  - 辍
+  - 辎
+  - 斐
+  - 睄
+  - 睑
+  - 睇
+  - 睃
+  - 戢
+  - 喋
+  - 嗒
+  - 喃
+  - 喱
+  - 喹
+  - 晷
+  - 喈
+  - 跖
+  - 跗
+  - 跞
+  - 跚
+  - 跎
+  - 跏
+  - 跆
+  - 蛱
+  - 蛲
+  - 蛭
+  - 蛳
+  - 蛐
+  - 蛔
+  - 蛞
+  - 蛴
+  - 蛟
+  - 蛘
+  - 喁
+  - 喟
+  - 啾
+  - 嗖
+  - 喑
+  - 嗟
+  - 喽
+  - 嗞
+  - 喀
+  - 喔
+  - 喙
+  - 嵘
+  - 嵖
+  - 崴
+  - 遄
+  - 詈
+  - 嵎
+  - 崽
+  - 嵬
+  - 嵛
+  - 嵯
+  - 嵝
+  - 嵫
+  - 幄
+  - 嵋
+  - 赕
+  - 铻
+  - 铼
+  - 铿
+  - 锃
+  - 锂
+  - 锆
+  - 锇
+  - 锉
+  - 锏
+  - 锑
+  - 锒
+  - 锔
+  - 锕
+  - 掣
+  - 矬
+  - 氰
+  - 毳
+  - 毽
+  - 犊
+  - 犄
+  - 犋
+  - 鹄
+  - 犍
+  - 嵇
+  - 黍
+  - 稃
+  - 稂
+  - 筚
+  - 筵
+  - 筌
+  - 傣
+  - 傈
+  - 舄
+  - 牍
+  - 傥
+  - 傧
+  - 遑
+  - 傩
+  - 遁
+  - 徨
+  - 媭
+  - 畲
+  - 弑
+  - 颌
+  - 翕
+  - 釉
+  - 鹆
+  - 舜
+  - 貂
+  - 腈
+  - 腌
+  - 腓
+  - 腆
+  - 腴
+  - 腑
+  - 腚
+  - 腱
+  - 鱿
+  - 鲀
+  - 鲂
+  - 颍
+  - 猢
+  - 猹
+  - 猥
+  - 飓
+  - 觞
+  - 觚
+  - 猱
+  - 颎
+  - 飧
+  - 馇
+  - 馊
+  - 亵
+  - 脔
+  - 裒
+  - 痣
+  - 痨
+  - 痦
+  - 痞
+  - 痤
+  - 痫
+  - 痧
+  - 赓
+  - 竦
+  - 瓿
+  - 啻
+  - 颏
+  - 鹇
+  - 阑
+  - 阒
+  - 阕
+  - 粞
+  - 遒
+  - 孳
+  - 焯
+  - 焜
+  - 焙
+  - 焱
+  - 鹈
+  - 湛
+  - 渫
+  - 湮
+  - 湎
+  - 湜
+  - 渭
+  - 湍
+  - 湫
+  - 溲
+  - 湟
+  - 溆
+  - 湲
+  - 湔
+  - 湉
+  - 渥
+  - 湄
+  - 滁
+  - 愠
+  - 惺
+  - 愦
+  - 惴
+  - 愀
+  - 愎
+  - 愔
+  - 喾
+  - 寐
+  - 谟
+  - 扉
+  - 裢
+  - 裎
+  - 裥
+  - 祾
+  - 祺
+  - 谠
+  - 幂
+  - 谡
+  - 谥
+  - 谧
+  - 遐
+  - 孱
+  - 弼
+  - 巽
+  - 骘
+  - 媪
+  - 媛
+  - 婷
+  - 巯
+  - 翚
+  - 皴
+  - 婺
+  - 骛
+  - 缂
+  - 缃
+  - 缄
+  - 彘
+  - 缇
+  - 缈
+  - 缌
+  - 缑
+  - 缒
+  - 缗
+  - 飨
+  - 耢
+  - 瑚
+  - 瑁
+  - 瑜
+  - 瑗
+  - 瑄
+  - 瑕
+  - 遨
+  - 骜
+  - 韫
+  - 髡
+  - 塬
+  - 鄢
+  - 趔
+  - 趑
+  - 摅
+  - 摁
+  - 蜇
+  - 搋
+  - 搪
+  - 搐
+  - 搛
+  - 搠
+  - 摈
+  - 彀
+  - 毂
+  - 搦
+  - 搡
+  - 蓁
+  - 戡
+  - 蓍
+  - 鄞
+  - 靳
+  - 蓐
+  - 蓦
+  - 鹋
+  - 蒽
+  - 蓓
+  - 蓖
+  - 蓊
+  - 蒯
+  - 蓟
+  - 蓑
+  - 蒿
+  - 蒺
+  - 蓠
+  - 蒟
+  - 蒡
+  - 蒹
+  - 蒴
+  - 蒗
+  - 蓥
+  - 颐
+  - 楔
+  - 楠
+  - 楂
+  - 楝
+  - 楫
+  - 楸
+  - 椴
+  - 槌
+  - 楯
+  - 皙
+  - 榈
+  - 槎
+  - 榉
+  - 楦
+  - 楣
+  - 楹
+  - 椽
+  - 裘
+  - 剽
+  - 甄
+  - 酮
+  - 酰
+  - 酯
+  - 酩
+  - 蜃
+  - 碛
+  - 碓
+  - 硼
+  - 碉
+  - 碚
+  - 碇
+  - 碜
+  - 鹌
+  - 辏
+  - 龃
+  - 龅
+  - 訾
+  - 粲
+  - 虞
+  - 睚
+  - 嗪
+  - 韪
+  - 嗷
+  - 嗉
+  - 睨
+  - 睢
+  - 雎
+  - 睥
+  - 嘟
+  - 嗑
+  - 嗫
+  - 嗬
+  - 嗔
+  - 嗝
+  - 戥
+  - 嗄
+  - 煦
+  - 暄
+  - 遢
+  - 暌
+  - 跬
+  - 跶
+  - 跸
+  - 跐
+  - 跣
+  - 跹
+  - 跻
+  - 蛸
+  - 蜊
+  - 蜍
+  - 蜉
+  - 蜣
+  - 畹
+  - 蛹
+  - 嗣
+  - 嗯
+  - 嗥
+  - 嗲
+  - 嗳
+  - 嗌
+  - 嗍
+  - 嗨
+  - 嗐
+  - 嗤
+  - 嗵
+  - 罨
+  - 嵊
+  - 嵩
+  - 嵴
+  - 骰
+  - 锗
+  - 锛
+  - 锜
+  - 锝
+  - 锞
+  - 锟
+  - 锢
+  - 锨
+  - 锩
+  - 锭
+  - 锱
+  - 雉
+  - 氲
+  - 犏
+  - 歃
+  - 稞
+  - 稗
+  - 稔
+  - 筠
+  - 筢
+  - 筮
+  - 筲
+  - 筱
+  - 牒
+  - 煲
+  - 敫
+  - 徭
+  - 愆
+  - 艄
+  - 觎
+  - 毹
+  - 貊
+  - 貅
+  - 貉
+  - 颔
+  - 腠
+  - 腩
+  - 腼
+  - 腭
+  - 腧
+  - 塍
+  - 媵
+  - 詹
+  - 鲅
+  - 鲆
+  - 鲇
+  - 鲈
+  - 稣
+  - 鲋
+  - 鲐
+  - 肄
+  - 鹐
+  - 飕
+  - 觥
+  - 遛
+  - 馐
+  - 鹑
+  - 亶
+  - 瘃
+  - 痱
+  - 痼
+  - 痿
+  - 瘐
+  - 瘁
+  - 瘆
+  - 麂
+  - 裔
+  - 歆
+  - 旒
+  - 雍
+  - 阖
+  - 阗
+  - 阙
+  - 羧
+  - 豢
+  - 粳
+  - 猷
+  - 煳
+  - 煜
+  - 煨
+  - 煅
+  - 煊
+  - 煸
+  - 煺
+  - 滟
+  - 溱
+  - 溘
+  - 漭
+  - 滢
+  - 溥
+  - 溧
+  - 溽
+  - 裟
+  - 溻
+  - 溷
+  - 滗
+  - 滫
+  - 溴
+  - 滏
+  - 滃
+  - 滦
+  - 溏
+  - 滂
+  - 滓
+  - 溟
+  - 滪
+  - 愫
+  - 慑
+  - 慊
+  - 鲎
+  - 骞
+  - 窦
+  - 窠
+  - 窣
+  - 裱
+  - 褚
+  - 裨
+  - 裾
+  - 裰
+  - 禊
+  - 谩
+  - 谪
+  - 媾
+  - 嫫
+  - 媲
+  - 嫒
+  - 嫔
+  - 媸
+  - 缙
+  - 缜
+  - 缛
+  - 辔
+  - 骝
+  - 缟
+  - 缡
+  - 缢
+  - 缣
+  - 骟
+  - 耥
+  - 璈
+  - 瑶
+  - 瑭
+  - 獒
+  - 觏
+  - 慝
+  - 嫠
+  - 韬
+  - 叆
+  - 髦
+  - 摽
+  - 墁
+  - 撂
+  - 摞
+  - 撄
+  - 翥
+  - 踅
+  - 摭
+  - 墉
+  - 墒
+  - 榖
+  - 綦
+  - 蔫
+  - 蔷
+  - 靺
+  - 靼
+  - 鞅
+  - 靿
+  - 甍
+  - 蔸
+  - 蔟
+  - 蔺
+  - 戬
+  - 蕖
+  - 蔻
+  - 蓿
+  - 斡
+  - 鹕
+  - 蓼
+  - 榛
+  - 榧
+  - 榻
+  - 榫
+  - 榭
+  - 槔
+  - 榱
+  - 槁
+  - 槟
+  - 槠
+  - 榷
+  - 僰
+  - 酽
+  - 酶
+  - 酹
+  - 厮
+  - 碡
+  - 碴
+  - 碣
+  - 碲
+  - 磋
+  - 臧
+  - 豨
+  - 殡
+  - 霆
+  - 霁
+  - 辕
+  - 蜚
+  - 裴
+  - 翡
+  - 龇
+  - 龈
+  - 睿
+  - 䁖
+  - 睽
+  - 嘞
+  - 嘈
+  - 嘌
+  - 嘁
+  - 嘎
+  - 暧
+  - 暝
+  - 踌
+  - 踉
+  - 蜞
+  - 蜥
+  - 蜮
+  - 蝈
+  - 蜴
+  - 蜱
+  - 蜩
+  - 蜷
+  - 蜿
+  - 螂
+  - 蜢
+  - 嘘
+  - 嘡
+  - 鹗
+  - 嘣
+  - 嘤
+  - 嘚
+  - 嗾
+  - 嘧
+  - 罴
+  - 罱
+  - 幔
+  - 嶂
+  - 幛
+  - 赙
+  - 罂
+  - 骷
+  - 骶
+  - 鹘
+  - 锲
+  - 锴
+  - 锶
+  - 锷
+  - 锸
+  - 锵
+  - 镁
+  - 镂
+  - 犒
+  - 箐
+  - 箦
+  - 箧
+  - 箍
+  - 箸
+  - 箬
+  - 箅
+  - 箪
+  - 箔
+  - 箜
+  - 箢
+  - 箓
+  - 毓
+  - 僖
+  - 儆
+  - 僳
+  - 僭
+  - 劁
+  - 僮
+  - 魃
+  - 魆
+  - 睾
+  - 艋
+  - 鄱
+  - 膈
+  - 膑
+  - 鲑
+  - 鲔
+  - 鲚
+  - 鲛
+  - 鲟
+  - 獐
+  - 觫
+  - 雒
+  - 夤
+  - 馑
+  - 銮
+  - 塾
+  - 麽
+  - 瘌
+  - 瘊
+  - 瘘
+  - 瘙
+  - 廖
+  - 韶
+  - 旖
+  - 膂
+  - 阚
+  - 鄯
+  - 鲞
+  - 粿
+  - 粼
+  - 粽
+  - 糁
+  - 槊
+  - 鹚
+  - 熘
+  - 熥
+  - 潢
+  - 漕
+  - 滹
+  - 漯
+  - 漶
+  - 潋
+  - 潴
+  - 漪
+  - 漉
+  - 漳
+  - 漩
+  - 澉
+  - 潍
+  - 慵
+  - 搴
+  - 窨
+  - 寤
+  - 綮
+  - 谮
+  - 褡
+  - 褙
+  - 褓
+  - 褛
+  - 褊
+  - 谯
+  - 谰
+  - 谲
+  - 暨
+  - 屣
+  - 鹛
+  - 嫣
+  - 嫱
+  - 嫖
+  - 嫦
+  - 嫚
+  - 嫘
+  - 嫡
+  - 鼐
+  - 翟
+  - 瞀
+  - 鹜
+  - 骠
+  - 缥
+  - 缦
+  - 缧
+  - 缨
+  - 骢
+  - 缪
+  - 缫
+  - 耦
+  - 耧
+  - 瑾
+  - 璜
+  - 璀
+  - 璎
+  - 璁
+  - 璋
+  - 璇
+  - 奭
+  - 髯
+  - 髫
+  - 撷
+  - 撅
+  - 赭
+  - 撸
+  - 鋆
+  - 撙
+  - 撺
+  - 墀
+  - 聩
+  - 觐
+  - 鞑
+  - 蕙
+  - 鞒
+  - 蕈
+  - 蕨
+  - 蕤
+  - 蕞
+  - 蕺
+  - 瞢
+  - 蕃
+  - 蕲
+  - 赜
+  - 槿
+  - 樯
+  - 槭
+  - 樗
+  - 樘
+  - 樊
+  - 槲
+  - 醌
+  - 醅
+  - 靥
+  - 魇
+  - 餍
+  - 磔
+  - 磙
+  - 霈
+  - 辘
+  - 龉
+  - 龊
+  - 觑
+  - 瞌
+  - 瞋
+  - 瞑
+  - 嘭
+  - 噎
+  - 噶
+  - 颙
+  - 暹
+  - 噘
+  - 踔
+  - 踝
+  - 踟
+  - 踒
+  - 踬
+  - 踮
+  - 踯
+  - 踺
+  - 踞
+  - 蝽
+  - 蝾
+  - 蝻
+  - 蝰
+  - 蝮
+  - 螋
+  - 蝓
+  - 蝣
+  - 蝼
+  - 噗
+  - 嘬
+  - 颚
+  - 噍
+  - 噢
+  - 噙
+  - 噜
+  - 噌
+  - 噔
+  - 颛
+  - 幞
+  - 幡
+  - 嶙
+  - 嶝
+  - 骺
+  - 骼
+  - 骸
+  - 镊
+  - 镉
+  - 镌
+  - 镍
+  - 镏
+  - 镒
+  - 镓
+  - 镔
+  - 稷
+  - 箴
+  - 篑
+  - 篁
+  - 篌
+  - 篆
+  - 牖
+  - 儋
+  - 徵
+  - 磐
+  - 虢
+  - 鹞
+  - 膘
+  - 滕
+  - 鲠
+  - 鲡
+  - 鲢
+  - 鲣
+  - 鲥
+  - 鲧
+  - 鲩
+  - 獗
+  - 獠
+  - 觯
+  - 馓
+  - 馔
+  - 麾
+  - 廛
+  - 瘛
+  - 瘼
+  - 瘢
+  - 瘠
+  - 齑
+  - 羯
+  - 羰
+  - 𥻗
+  - 遴
+  - 糌
+  - 糍
+  - 糅
+  - 熜
+  - 熵
+  - 熠
+  - 澍
+  - 澌
+  - 潸
+  - 潦
+  - 潲
+  - 鋈
+  - 潟
+  - 潼
+  - 潺
+  - 憬
+  - 憧
+  - 寮
+  - 窳
+  - 谳
+  - 褴
+  - 褟
+  - 褫
+  - 谵
+  - 熨
+  - 屦
+  - 嬉
+  - 勰
+  - 戮
+  - 蝥
+  - 缬
+  - 缮
+  - 缯
+  - 骣
+  - 畿
+  - 耩
+  - 耨
+  - 耪
+  - 璞
+  - 璟
+  - 靛
+  - 璠
+  - 璘
+  - 聱
+  - 螯
+  - 髻
+  - 髭
+  - 髹
+  - 擀
+  - 熹
+  - 甏
+  - 擞
+  - 縠
+  - 磬
+  - 颞
+  - 蕻
+  - 鞘
+  - 颟
+  - 薤
+  - 薨
+  - 檠
+  - 薏
+  - 薮
+  - 薜
+  - 薅
+  - 樾
+  - 橛
+  - 橇
+  - 樵
+  - 檎
+  - 橹
+  - 樽
+  - 樨
+  - 橼
+  - 墼
+  - 橐
+  - 翮
+  - 醛
+  - 醐
+  - 醍
+  - 醚
+  - 磲
+  - 赝
+  - 飙
+  - 殪
+  - 霖
+  - 霏
+  - 霓
+  - 錾
+  - 辚
+  - 臻
+  - 遽
+  - 氅
+  - 瞟
+  - 瞠
+  - 瞰
+  - 嚄
+  - 嚆
+  - 噤
+  - 暾
+  - 蹀
+  - 踹
+  - 踵
+  - 踽
+  - 蹉
+  - 蹁
+  - 螨
+  - 蟒
+  - 螈
+  - 螅
+  - 螭
+  - 螠
+  - 螟
+  - 噱
+  - 噬
+  - 噫
+  - 噻
+  - 噼
+  - 罹
+  - 圜
+  - 䦃
+  - 镖
+  - 镗
+  - 镘
+  - 镚
+  - 镛
+  - 镝
+  - 镞
+  - 镠
+  - 氇
+  - 氆
+  - 憩
+  - 穑
+  - 篝
+  - 篥
+  - 篦
+  - 篪
+  - 篙
+  - 盥
+  - 劓
+  - 翱
+  - 魉
+  - 魈
+  - 徼
+  - 歙
+  - 膳
+  - 膦
+  - 膙
+  - 鲮
+  - 鲱
+  - 鲲
+  - 鲳
+  - 鲴
+  - 鲵
+  - 鲷
+  - 鲻
+  - 獴
+  - 獭
+  - 獬
+  - 邂
+  - 鹧
+  - 廨
+  - 赟
+  - 瘰
+  - 廪
+  - 瘿
+  - 瘵
+  - 瘴
+  - 癃
+  - 瘳
+  - 斓
+  - 麇
+  - 麈
+  - 嬴
+  - 壅
+  - 羲
+  - 糗
+  - 瞥
+  - 甑
+  - 燎
+  - 燠
+  - 燔
+  - 燧
+  - 濑
+  - 濉
+  - 潞
+  - 澧
+  - 澹
+  - 澥
+  - 澶
+  - 濂
+  - 褰
+  - 寰
+  - 窸
+  - 褶
+  - 禧
+  - 嬖
+  - 犟
+  - 隰
+  - 嬗
+  - 颡
+  - 缱
+  - 缲
+  - 缳
+  - 璨
+  - 璩
+  - 璐
+  - 璪
+  - 螫
+  - 擤
+  - 壕
+  - 觳
+  - 罄
+  - 擢
+  - 薹
+  - 鞡
+  - 鞬
+  - 薷
+  - 薰
+  - 藓
+  - 藁
+  - 檄
+  - 檩
+  - 懋
+  - 醢
+  - 翳
+  - 礅
+  - 磴
+  - 鹩
+  - 龋
+  - 龌
+  - 豳
+  - 壑
+  - 黻
+  - 嚏
+  - 嚅
+  - 蹑
+  - 蹒
+  - 蹊
+  - 蟥
+  - 螬
+  - 螵
+  - 疃
+  - 螳
+  - 蟑
+  - 嚓
+  - 羁
+  - 罽
+  - 罾
+  - 嶷
+  - 黜
+  - 黝
+  - 髁
+  - 髀
+  - 镡
+  - 镢
+  - 镣
+  - 镦
+  - 镧
+  - 镩
+  - 镪
+  - 镫
+  - 罅
+  - 黏
+  - 簌
+  - 篾
+  - 篼
+  - 簖
+  - 簋
+  - 鼢
+  - 黛
+  - 儡
+  - 鹪
+  - 鼾
+  - 皤
+  - 魍
+  - 龠
+  - 繇
+  - 貘
+  - 邈
+  - 貔
+  - 臌
+  - 膻
+  - 臆
+  - 臃
+  - 鲼
+  - 鲽
+  - 鳀
+  - 鳃
+  - 鳅
+  - 鳇
+  - 鳊
+  - 螽
+  - 燮
+  - 鹫
+  - 襄
+  - 糜
+  - 縻
+  - 膺
+  - 癍
+  - 麋
+  - 懑
+  - 濡
+  - 濮
+  - 濞
+  - 濠
+  - 濯
+  - 蹇
+  - 謇
+  - 邃
+  - 襁
+  - 檗
+  - 擘
+  - 孺
+  - 隳
+  - 嬷
+  - 蟊
+  - 鹬
+  - 鍪
+  - 鏊
+  - 鳌
+  - 鬈
+  - 鬃
+  - 瞽
+  - 鞯
+  - 鞨
+  - 鞫
+  - 鞧
+  - 鞣
+  - 藜
+  - 藠
+  - 藩
+  - 醪
+  - 蹙
+  - 礓
+  - 燹
+  - 餮
+  - 瞿
+  - 曛
+  - 颢
+  - 曜
+  - 躇
+  - 蹚
+  - 鹭
+  - 蟛
+  - 蟪
+  - 蟠
+  - 蟮
+  - 鹮
+  - 黠
+  - 黟
+  - 髅
+  - 髂
+  - 镬
+  - 镭
+  - 镯
+  - 馥
+  - 簟
+  - 簪
+  - 鼬
+  - 雠
+  - 艟
+  - 鳎
+  - 鳏
+  - 鳐
+  - 癞
+  - 癔
+  - 癜
+  - 癖
+  - 糨
+  - 蹩
+  - 鎏
+  - 懵
+  - 彝
+  - 邋
+  - 鬏
+  - 攉
+  - 攒
+  - 鞲
+  - 鞴
+  - 藿
+  - 蘧
+  - 蘅
+  - 麓
+  - 醮
+  - 醯
+  - 酃
+  - 霪
+  - 霭
+  - 霨
+  - 黼
+  - 嚯
+  - 蹰
+  - 蹶
+  - 蹽
+  - 蹼
+  - 蹴
+  - 蹾
+  - 蹿
+  - 蠖
+  - 蠓
+  - 蟾
+  - 蠊
+  - 黢
+  - 髋
+  - 髌
+  - 镲
+  - 籀
+  - 籁
+  - 齁
+  - 魑
+  - 艨
+  - 鳓
+  - 鳔
+  - 鳕
+  - 鳗
+  - 鳙
+  - 麒
+  - 鏖
+  - 羸
+  - 㸆
+  - 瀚
+  - 瀣
+  - 瀛
+  - 襦
+  - 谶
+  - 襞
+  - 骥
+  - 缵
+  - 瓒
+  - 攘
+  - 蘩
+  - 蘖
+  - 醴
+  - 霰
+  - 酆
+  - 矍
+  - 曦
+  - 躅
+  - 鼍
+  - 巉
+  - 黩
+  - 黥
+  - 黪
+  - 镳
+  - 镴
+  - 黧
+  - 纂
+  - 璺
+  - 鼯
+  - 臜
+  - 鳜
+  - 鳝
+  - 鳟
+  - 獾
+  - 孀
+  - 骧
+  - 瓘
+  - 鼙
+  - 醺
+  - 礴
+  - 颦
+  - 曩
+  - 鳢
+  - 癫
+  - 麝
+  - 夔
+  - 爝
+  - 灏
+  - 禳
+  - 鐾
+  - 羼
+  - 蠡
+  - 耱
+  - 懿
+  - 蘸
+  - 鹳
+  - 霾
+  - 氍
+  - 饕
+  - 躐
+  - 髑
+  - 镵
+  - 穰
+  - 饔
+  - 鬻
+  - 鬟
+  - 趱
+  - 攫
+  - 攥
+  - 颧
+  - 躜
+  - 鼹
+  - 癯
+  - 麟
+  - 蠲
+  - 蠹
+  - 躞
+  - 衢
+  - 鑫
+  - 灞
+  - 襻
+  - 纛
+  - 鬣
+  - 攮
+  - 囔
+  - 馕
+  - 戆
+  - 爨
+  - 齉
+  - 亍
+  - 尢
+  - 彳
+  - 卬
+  - 殳
+  - 𠙶
+  - 毌
+  - 邘
+  - 戋
+  - 圢
+  - 氕
+  - 伋
+  - 仝
+  - 冮
+  - 氿
+  - 汈
+  - 氾
+  - 忉
+  - 宄
+  - 讱
+  - 扞
+  - 圲
+  - 圫
+  - 芏
+  - 芃
+  - 朳
+  - 朸
+  - 𨙸
+  - 邨
+  - 吒
+  - 吖
+  - 屼
+  - 屾
+  - 辿
+  - 钆
+  - 仳
+  - 伣
+  - 伈
+  - 癿
+  - 甪
+  - 邠
+  - 犴
+  - 冱
+  - 邡
+  - 闫
+  - 汋
+  - 䜣
+  - 讻
+  - 孖
+  - 纩
+  - 玒
+  - 玓
+  - 玘
+  - 玚
+  - 刬
+  - 坜
+  - 坉
+  - 扽
+  - 坋
+  - 扺
+  - 㧑
+  - 毐
+  - 芰
+  - 芣
+  - 苊
+  - 苉
+  - 芘
+  - 芴
+  - 芠
+  - 芤
+  - 杕
+  - 杙
+  - 杄
+  - 杧
+  - 杩
+  - 尪
+  - 尨
+  - 轪
+  - 坒
+  - 芈
+  - 旴
+  - 旵
+  - 呙
+  - 㕮
+  - 岍
+  - 岠
+  - 岜
+  - 呇
+  - 冏
+  - 觃
+  - 岙
+  - 伾
+  - 㑇
+  - 伭
+  - 佖
+  - 伲
+  - 佁
+  - 飏
+  - 狃
+  - 闶
+  - 汧
+  - 汫
+  - 𣲘
+  - 𣲗
+  - 沄
+  - 沘
+  - 汭
+  - 㳇
+  - 沇
+  - 忮
+  - 忳
+  - 忺
+  - 祃
+  - 诇
+  - 邲
+  - 诎
+  - 诐
+  - 屃
+  - 岊
+  - 阽
+  - 䢺
+  - 阼
+  - 妧
+  - 妘
+  - 𨚕
+  - 纮
+  - 驲
+  - 纻
+  - 纼
+  - 玤
+  - 玞
+  - 玱
+  - 玟
+  - 邽
+  - 邿
+  - 坥
+  - 坰
+  - 坬
+  - 坽
+  - 弆
+  - 耵
+  - 䢼
+  - 𦭜
+  - 茋
+  - 苧
+  - 苾
+  - 苠
+  - 枅
+  - 㭎
+  - 枘
+  - 枍
+  - 矼
+  - 矻
+  - 匼
+  - 旿
+  - 昇
+  - 昄
+  - 昒
+  - 昈
+  - 咉
+  - 咇
+  - 咍
+  - 岵
+  - 岽
+  - 岨
+  - 岞
+  - 峂
+  - 㟃
+  - 囷
+  - 钐
+  - 钔
+  - 钖
+  - 牥
+  - 佴
+  - 垈
+  - 侁
+  - 侹
+  - 佸
+  - 佺
+  - 隹
+  - 㑊
+  - 侂
+  - 佽
+  - 侘
+  - 郈
+  - 舠
+  - 郐
+  - 郃
+  - 攽
+  - 肭
+  - 肸
+  - 肷
+  - 狉
+  - 狝
+  - 饳
+  - 忞
+  - 於
+  - 炌
+  - 炆
+  - 泙
+  - 沺
+  - 泂
+  - 泜
+  - 泃
+  - 泇
+  - 怊
+  - 峃
+  - 穸
+  - 祋
+  - 祊
+  - 鸤
+  - 弢
+  - 弨
+  - 陑
+  - 陎
+  - 卺
+  - 乸
+  - 妭
+  - 姈
+  - 迳
+  - 叕
+  - 驵
+  - 䌹
+  - 驺
+  - 绋
+  - 绐
+  - 砉
+  - 耔
+  - 㛃
+  - 玶
+  - 珇
+  - 珅
+  - 珋
+  - 玹
+  - 珌
+  - 玿
+  - 韨
+  - 垚
+  - 垯
+  - 垙
+  - 垲
+  - 埏
+  - 垍
+  - 耇
+  - 垎
+  - 垴
+  - 垟
+  - 垞
+  - 挓
+  - 垵
+  - 垏
+  - 拶
+  - 荖
+  - 荁
+  - 荙
+  - 荛
+  - 茈
+  - 茽
+  - 荄
+  - 茺
+  - 荓
+  - 茳
+  - 𦰡
+  - 茛
+  - 荭
+  - 㭕
+  - 柷
+  - 柃
+  - 柊
+  - 枹
+  - 栐
+  - 柖
+  - 郚
+  - 剅
+  - 䴓
+  - 迺
+  - 厖
+  - 砆
+  - 砑
+  - 砄
+  - 耏
+  - 奓
+  - 䶮
+  - 轵
+  - 轷
+  - 轹
+  - 轺
+  - 昺
+  - 昽
+  - 盷
+  - 咡
+  - 咺
+  - 昳
+  - 昣
+  - 哒
+  - 昤
+  - 昫
+  - 昡
+  - 咥
+  - 昪
+  - 虷
+  - 虸
+  - 哃
+  - 峘
+  - 耑
+  - 峛
+  - 峗
+  - 峧
+  - 帡
+  - 钘
+  - 钜
+  - 钪
+  - 钬
+  - 钭
+  - 矧
+  - 秬
+  - 俫
+  - 舁
+  - 俜
+  - 俙
+  - 俍
+  - 垕
+  - 衎
+  - 舣
+  - 弇
+  - 侴
+  - 鸧
+  - 䏡
+  - 胠
+  - 𦙶
+  - 胈
+  - 胩
+  - 胣
+  - 朏
+  - 飐
+  - 訄
+  - 饻
+  - 庤
+  - 疢
+  - 炣
+  - 炟
+  - 㶲
+  - 洭
+  - 洘
+  - 洓
+  - 洿
+  - 㳚
+  - 泚
+  - 浈
+  - 浉
+  - 洸
+  - 洑
+  - 洢
+  - 洈
+  - 洚
+  - 洺
+  - 洨
+  - 浐
+  - 㳘
+  - 洴
+  - 洣
+  - 恔
+  - 宬
+  - 窀
+  - 扂
+  - 袆
+  - 祏
+  - 祐
+  - 祕
+  - 叚
+  - 陧
+  - 陞
+  - 娀
+  - 姞
+  - 姱
+  - 姤
+  - 姶
+  - 姽
+  - 枲
+  - 绖
+  - 骃
+  - 彖
+  - 骉
+  - 恝
+  - 珪
+  - 珛
+  - 珹
+  - 琊
+  - 玼
+  - 珖
+  - 珽
+  - 珦
+  - 珫
+  - 珒
+  - 珢
+  - 珕
+  - 珝
+  - 埗
+  - 垾
+  - 垺
+  - 埆
+  - 垿
+  - 埌
+  - 埇
+  - 莰
+  - 茝
+  - 鄀
+  - 莶
+  - 莝
+  - 䓖
+  - 莙
+  - 栻
+  - 桠
+  - 桄
+  - 梠
+  - 栴
+  - 梴
+  - 栒
+  - 酎
+  - 酏
+  - 砵
+  - 砠
+  - 砫
+  - 砬
+  - 硁
+  - 恧
+  - 翃
+  - 郪
+  - 𨐈
+  - 辀
+  - 辁
+  - 剕
+  - 赀
+  - 哢
+  - 晅
+  - 晊
+  - 唝
+  - 哳
+  - 哱
+  - 冔
+  - 晔
+  - 晐
+  - 晖
+  - 畖
+  - 蚄
+  - 蚆
+  - 帱
+  - 崁
+  - 峿
+  - 崄
+  - 帨
+  - 崀
+  - 赆
+  - 钷
+  - 眚
+  - 甡
+  - 笫
+  - 倻
+  - 倴
+  - 脩
+  - 倮
+  - 倕
+  - 倞
+  - 倓
+  - 倧
+  - 衃
+  - 虒
+  - 舭
+  - 舯
+  - 舥
+  - 瓞
+  - 鬯
+  - 鸰
+  - 脎
+  - 朓
+  - 胲
+  - 虓
+  - 鱽
+  - 狴
+  - 峱
+  - 狻
+  - 眢
+  - 勍
+  - 痄
+  - 疰
+  - 痃
+  - 竘
+  - 羖
+  - 羓
+  - 桊
+  - 敉
+  - 烠
+  - 烔
+  - 烶
+  - 烻
+  - 涍
+  - 浡
+  - 浭
+  - 浬
+  - 涄
+  - 涢
+  - 涐
+  - 浰
+  - 浟
+  - 浛
+  - 浼
+  - 浲
+  - 涘
+  - 悈
+  - 悃
+  - 悢
+  - 宧
+  - 窅
+  - 窊
+  - 窎
+  - 扅
+  - 扆
+  - 袪
+  - 袗
+  - 袯
+  - 祧
+  - 隺
+  - 堲
+  - 疍
+  - 𨺙
+  - 陴
+  - 烝
+  - 砮
+  - 㛚
+  - 哿
+  - 翀
+  - 翂
+  - 剟
+  - 绤
+  - 骍
+  - 䂮
+  - 琎
+  - 珸
+  - 珵
+  - 琄
+  - 琈
+  - 琀
+  - 珺
+  - 掭
+  - 堎
+  - 堐
+  - 埼
+  - 掎
+  - 埫
+  - 堌
+  - 晢
+  - 掞
+  - 埪
+  - 壸
+  - 㙍
+  - 聍
+  - 菝
+  - 萚
+  - 菥
+  - 莿
+  - 䓫
+  - 勚
+  - 䓬
+  - 萆
+  - 菂
+  - 菍
+  - 菼
+  - 萣
+  - 䓨
+  - 菉
+  - 䓛
+  - 梼
+  - 梽
+  - 桲
+  - 梾
+  - 桯
+  - 梣
+  - 梌
+  - 桹
+  - 敔
+  - 厣
+  - 硔
+  - 硙
+  - 硚
+  - 硊
+  - 硍
+  - 勔
+  - 䴕
+  - 龁
+  - 逴
+  - 唪
+  - 啫
+  - 翈
+  - 㫰
+  - 晙
+  - 畤
+  - 趼
+  - 跂
+  - 蛃
+  - 蚲
+  - 蚺
+  - 啴
+  - 䎃
+  - 崧
+  - 崟
+  - 崞
+  - 崒
+  - 崌
+  - 崡
+  - 铏
+  - 铕
+  - 铖
+  - 铘
+  - 铚
+  - 铞
+  - 铥
+  - 铴
+  - 牻
+  - 牿
+  - 稆
+  - 笱
+  - 笯
+  - 偰
+  - 偡
+  - 鸺
+  - 偭
+  - 偲
+  - 偁
+  - 㿠
+  - 鄅
+  - 偓
+  - 徛
+  - 衒
+  - 舳
+  - 舲
+  - 鸼
+  - 悆
+  - 鄃
+  - 瓻
+  - 䝙
+  - 脶
+  - 脞
+  - 脟
+  - 䏲
+  - 鱾
+  - 猇
+  - 猊
+  - 猄
+  - 觖
+  - 𠅤
+  - 庱
+  - 庼
+  - 庳
+  - 痓
+  - 䴔
+  - 竫
+  - 堃
+  - 阌
+  - 羝
+  - 羕
+  - 焆
+  - 烺
+  - 焌
+  - 淏
+  - 淟
+  - 淜
+  - 淴
+  - 淯
+  - 湴
+  - 涴
+  - 㥄
+  - 惛
+  - 惔
+  - 悰
+  - 惙
+  - 寁
+  - 逭
+  - 袼
+  - 裈
+  - 祲
+  - 谞
+  - 艴
+  - 弸
+  - 弶
+  - 隃
+  - 婞
+  - 娵
+  - 婼
+  - 媖
+  - 婳
+  - 婍
+  - 婌
+  - 婫
+  - 婤
+  - 婘
+  - 婠
+  - 绹
+  - 骕
+  - 絜
+  - 珷
+  - 琲
+  - 琡
+  - 琟
+  - 琔
+  - 琭
+  - 堾
+  - 堼
+  - 揕
+  - 㙘
+  - 堧
+  - 喆
+  - 堨
+  - 塅
+  - 堠
+  - 絷
+  - 𡎚
+  - 葜
+  - 惎
+  - 萳
+  - 葙
+  - 靬
+  - 葴
+  - 蒇
+  - 蒈
+  - 鄚
+  - 蒉
+  - 蓇
+  - 萩
+  - 蒐
+  - 葰
+  - 葎
+  - 鄑
+  - 蒎
+  - 葖
+  - 蒄
+  - 萹
+  - 棤
+  - 棽
+  - 棫
+  - 椓
+  - 椑
+  - 鹀
+  - 椆
+  - 棓
+  - 棬
+  - 棪
+  - 椀
+  - 楗
+  - 甦
+  - 酦
+  - 觌
+  - 奡
+  - 皕
+  - 硪
+  - 欹
+  - 詟
+  - 辌
+  - 棐
+  - 龂
+  - 黹
+  - 牚
+  - 睎
+  - 晫
+  - 晪
+  - 晱
+  - 𧿹
+  - 蛑
+  - 畯
+  - 斝
+  - 喤
+  - 崶
+  - 嵁
+  - 崾
+  - 嵅
+  - 崿
+  - 嵚
+  - 翙
+  - 圌
+  - 圐
+  - 赑
+  - 淼
+  - 赒
+  - 铹
+  - 铽
+  - 𨱇
+  - 锊
+  - 锍
+  - 锎
+  - 锓
+  - 犇
+  - 颋
+  - 稌
+  - 筀
+  - 筘
+  - 筜
+  - 筥
+  - 筅
+  - 傃
+  - 傉
+  - 翛
+  - 傒
+  - 傕
+  - 舾
+  - 畬
+  - 脿
+  - 腘
+  - 䐃
+  - 腙
+  - 腒
+  - 鲃
+  - 猰
+  - 猯
+  - 㺄
+  - 馉
+  - 鄗
+  - 廋
+  - 廆
+  - 鄌
+  - 粢
+  - 遆
+  - 旐
+  - 焞
+  - 欻
+  - 𣸣
+  - 溚
+  - 溁
+  - 湝
+  - 渰
+  - 湓
+  - 㴔
+  - 渟
+  - 溠
+  - 渼
+  - 溇
+  - 湣
+  - 湑
+  - 溞
+  - 愐
+  - 愃
+  - 敩
+  - 甯
+  - 棨
+  - 扊
+  - 裣
+  - 祼
+  - 婻
+  - 媆
+  - 媞
+  - 㛹
+  - 媓
+  - 媂
+  - 媄
+  - 毵
+  - 矞
+  - 缊
+  - 缐
+  - 骙
+  - 瑃
+  - 瑓
+  - 瑅
+  - 瑆
+  - 䴖
+  - 瑖
+  - 瑝
+  - 瑔
+  - 瑀
+  - 𤧛
+  - 瑳
+  - 瑂
+  - 嶅
+  - 瑑
+  - 遘
+  - 髢
+  - 塥
+  - 堽
+  - 赪
+  - 摛
+  - 塝
+  - 搒
+  - 搌
+  - 蒱
+  - 蒨
+  - 蓏
+  - 蔀
+  - 蓢
+  - 蓂
+  - 蒻
+  - 蓣
+  - 椹
+  - 楪
+  - 榃
+  - 榅
+  - 楒
+  - 楞
+  - 楩
+  - 榇
+  - 椸
+  - 楙
+  - 歅
+  - 碃
+  - 碏
+  - 碈
+  - 䃅
+  - 硿
+  - 鄠
+  - 辒
+  - 龆
+  - 觜
+  - 䣘
+  - 暕
+  - 鹍
+  - 㬊
+  - 暅
+  - 跱
+  - 蜐
+  - 蜎
+  - 嵲
+  - 赗
+  - 骱
+  - 锖
+  - 锘
+  - 锳
+  - 锧
+  - 锪
+  - 锫
+  - 锬
+  - 稑
+  - 稙
+  - 䅟
+  - 筻
+  - 筼
+  - 筶
+  - 筦
+  - 筤
+  - 傺
+  - 鹎
+  - 僇
+  - 艅
+  - 艉
+  - 谼
+  - 貆
+  - 腽
+  - 腨
+  - 腯
+  - 鲉
+  - 鲊
+  - 鲌
+  - 䲟
+  - 鲏
+  - 雊
+  - 猺
+  - 飔
+  - 觟
+  - 𦝼
+  - 馌
+  - 裛
+  - 廒
+  - 瘀
+  - 瘅
+  - 鄘
+  - 鹒
+  - 鄜
+  - 麀
+  - 鄣
+  - 阘
+  - 煁
+  - 煃
+  - 煴
+  - 煋
+  - 煟
+  - 煓
+  - 滠
+  - 溍
+  - 溹
+  - 滆
+  - 滉
+  - 溦
+  - 溵
+  - 漷
+  - 滧
+  - 滘
+  - 滍
+  - 愭
+  - 慥
+  - 慆
+  - 塱
+  - 裼
+  - 禋
+  - 禔
+  - 禘
+  - 禒
+  - 谫
+  - 鹔
+  - 愍
+  - 嫄
+  - 媱
+  - 戤
+  - 戣
+  - 缞
+  - 耤
+  - 瑧
+  - 瑨
+  - 瑱
+  - 瑷
+  - 瑢
+  - 斠
+  - 摏
+  - 墕
+  - 墈
+  - 墐
+  - 墘
+  - 摴
+  - 銎
+  - 𡐓
+  - 墚
+  - 撖
+  - 靽
+  - 鞁
+  - 蔌
+  - 蔈
+  - 蓰
+  - 蔹
+  - 蔊
+  - 嘏
+  - 榰
+  - 榑
+  - 槚
+  - 𣗋
+  - 槜
+  - 榍
+  - 疐
+  - 酺
+  - 酾
+  - 酲
+  - 酴
+  - 碶
+  - 䃎
+  - 碨
+  - 𥔲
+  - 碹
+  - 碥
+  - 劂
+  - 䴗
+  - 夥
+  - 瞍
+  - 鹖
+  - 㬎
+  - 跽
+  - 蜾
+  - 幖
+  - 嶍
+  - 圙
+  - 𨱏
+  - 锺
+  - 锼
+  - 锽
+  - 锾
+  - 锿
+  - 镃
+  - 镄
+  - 镅
+  - 馝
+  - 鹙
+  - 箨
+  - 箖
+  - 劄
+  - 僬
+  - 僦
+  - 僔
+  - 僎
+  - 槃
+  - 㙦
+  - 鲒
+  - 鲕
+  - 鲖
+  - 鲗
+  - 鲘
+  - 鲙
+  - 𩽾
+  - 夐
+  - 獍
+  - 飗
+  - 凘
+  - 廑
+  - 廙
+  - 瘗
+  - 瘥
+  - 瘕
+  - 鲝
+  - 鄫
+  - 熇
+  - 漹
+  - 漖
+  - 潆
+  - 漤
+  - 潩
+  - 漼
+  - 漴
+  - 㽏
+  - 漈
+  - 漋
+  - 漻
+  - 慬
+  - 窬
+  - 窭
+  - 㮾
+  - 褕
+  - 禛
+  - 禚
+  - 隩
+  - 嫕
+  - 嫭
+  - 嫜
+  - 嫪
+  - 㻬
+  - 麹
+  - 璆
+  - 漦
+  - 叇
+  - 墣
+  - 墦
+  - 墡
+  - 劐
+  - 薁
+  - 蕰
+  - 蔃
+  - 鼒
+  - 槱
+  - 鹝
+  - 磏
+  - 磉
+  - 殣
+  - 慭
+  - 霅
+  - 暵
+  - 暲
+  - 暶
+  - 踦
+  - 踣
+  - 䗖
+  - 蝘
+  - 蝲
+  - 蝤
+  - 噇
+  - 噂
+  - 噀
+  - 罶
+  - 嶲
+  - 嶓
+  - 㠇
+  - 嶟
+  - 嶒
+  - 镆
+  - 镈
+  - 镋
+  - 镎
+  - 镕
+  - 稹
+  - 儇
+  - 皞
+  - 皛
+  - 䴘
+  - 艎
+  - 艏
+  - 鹟
+  - 𩾃
+  - 鲦
+  - 鲪
+  - 鲬
+  - 橥
+  - 觭
+  - 鹠
+  - 鹡
+  - 糇
+  - 糈
+  - 翦
+  - 鹢
+  - 鹣
+  - 熛
+  - 潖
+  - 潵
+  - 㵐
+  - 澂
+  - 澛
+  - 瑬
+  - 潽
+  - 潾
+  - 潏
+  - 憭
+  - 憕
+  - 戭
+  - 褯
+  - 禤
+  - 嫽
+  - 遹
+  - 璥
+  - 璲
+  - 璒
+  - 憙
+  - 擐
+  - 鄹
+  - 薳
+  - 鞔
+  - 黇
+  - 蕗
+  - 薢
+  - 蕹
+  - 橞
+  - 橑
+  - 橦
+  - 醑
+  - 觱
+  - 磡
+  - 𥕢
+  - 磜
+  - 豮
+  - 鹾
+  - 虤
+  - 暿
+  - 曌
+  - 曈
+  - 㬚
+  - 蹅
+  - 踶
+  - 䗛
+  - 螗
+  - 疁
+  - 㠓
+  - 幪
+  - 嶦
+  - 𨱑
+  - 馞
+  - 穄
+  - 篚
+  - 篯
+  - 簉
+  - 鼽
+  - 衠
+  - 盦
+  - 螣
+  - 縢
+  - 鲭
+  - 鲯
+  - 鲰
+  - 鲺
+  - 鲹
+  - 亸
+  - 癀
+  - 瘭
+  - 羱
+  - 糒
+  - 燋
+  - 熻
+  - 燊
+  - 燚
+  - 燏
+  - 濩
+  - 濋
+  - 澪
+  - 澽
+  - 澴
+  - 澭
+  - 澼
+  - 憷
+  - 憺
+  - 懔
+  - 黉
+  - 嬛
+  - 鹨
+  - 翯
+  - 璱
+  - 𤩽
+  - 璬
+  - 璮
+  - 髽
+  - 擿
+  - 薿
+  - 薸
+  - 檑
+  - 櫆
+  - 檞
+  - 醨
+  - 繄
+  - 磹
+  - 磻
+  - 瞫
+  - 瞵
+  - 蹐
+  - 蟏
+  - 㘎
+  - 镤
+  - 镥
+  - 镨
+  - 𨱔
+  - 矰
+  - 穙
+  - 穜
+  - 穟
+  - 簕
+  - 簃
+  - 簏
+  - 儦
+  - 魋
+  - 斶
+  - 艚
+  - 谿
+  - 䲠
+  - 鲾
+  - 鲿
+  - 鳁
+  - 鳂
+  - 鳈
+  - 鳉
+  - 獯
+  - 䗪
+  - 馘
+  - 襕
+  - 襚
+  - 螱
+  - 甓
+  - 嬬
+  - 嬥
+  - 𦈡
+  - 瓀
+  - 釐
+  - 鬶
+  - 爇
+  - 鞳
+  - 鞮
+  - 藟
+  - 藦
+  - 藨
+  - 鹲
+  - 檫
+  - 黡
+  - 礞
+  - 礌
+  - 𥖨
+  - 蹢
+  - 蹜
+  - 蟫
+  - 䗴
+  - 嚚
+  - 髃
+  - 镮
+  - 镱
+  - 酂
+  - 馧
+  - 簠
+  - 簝
+  - 簰
+  - 鼫
+  - 鼩
+  - 皦
+  - 臑
+  - 䲢
+  - 鳑
+  - 鳒
+  - 鹱
+  - 鹯
+  - 癗
+  - 𦒍
+  - 旞
+  - 翷
+  - 冁
+  - 䎖
+  - 瀔
+  - 瀍
+  - 瀌
+  - 襜
+  - 䴙
+  - 嚭
+  - 㰀
+  - 鬷
+  - 醭
+  - 蹯
+  - 蠋
+  - 翾
+  - 鳘
+  - 儳
+  - 儴
+  - 鼗
+  - 𩾌
+  - 鳚
+  - 鳛
+  - 麑
+  - 麖
+  - 蠃
+  - 彟
+  - 嬿
+  - 鬒
+  - 蘘
+  - 欂
+  - 醵
+  - 颥
+  - 甗
+  - 𨟠
+  - 巇
+  - 酅
+  - 髎
+  - 犨
+  - 𨭉
+  - 㸌
+  - 爔
+  - 瀱
+  - 瀹
+  - 瀼
+  - 瀵
+  - 襫
+  - 孅
+  - 骦
+  - 耰
+  - 𤫉
+  - 瓖
+  - 鬘
+  - 趯
+  - 罍
+  - 鼱
+  - 鳠
+  - 鳡
+  - 鳣
+  - 爟
+  - 爚
+  - 灈
+  - 韂
+  - 糵
+  - 蘼
+  - 礵
+  - 鹴
+  - 躔
+  - 皭
+  - 龢
+  - 鳤
+  - 亹
+  - 籥
+  - 鼷
+  - 玃
+  - 醾
+  - 齇
+  - 觿
+  - 蠼
+  - 𬣙
+  - 𬇕
+  - 𬣞
+  - 𬘓
+  - 𫭟
+  - 𫭢
+  - 𫇭
+  - 𫐄
+  - 𫵷
+  - 𬇙
+  - 𬣡
+  - 𫸩
+  - 𫘜
+  - 𬘘
+  - 𫘝
+  - 𬨂
+  - 𬀩
+  - 𬀪
+  - 𬬩
+  - 𫍣
+  - 𬣳
+  - 𬩽
+  - 𬮿
+  - 𬯀
+  - 𫰛
+  - 𬳵
+  - 𬳶
+  - 𫠊
+  - 𬍛
+  - 鿍
+  - 𬜬
+  - 𪾢
+  - 𪨰
+  - 𫓧
+  - 𬬮
+  - 𬬱
+  - 𬬭
+  - 𬘡
+  - 𬳽
+  - 𬘩
+  - 𫄧
+  - 𪟝
+  - 𬍤
+  - 𫭼
+  - 𬜯
+  - 𬂩
+  - 𫠆
+  - 𬌗
+  - 𫑡
+  - 𪨶
+  - 𬬸
+  - 𬬻
+  - 𬬹
+  - 𬬿
+  - 𬭁
+  - 𫢸
+  - 𫗧
+  - 𬊈
+  - 𬒈
+  - 𬳿
+  - 𫄨
+  - 𬘫
+  - 𫮃
+  - 鿎
+  - 𬱖
+  - 𬟽
+  - 𫓯
+  - 𫟹
+  - 𫟼
+  - 𬇹
+  - 𬍡
+  - 𬤇
+  - 𫍯
+  - 𬤊
+  - 𫍲
+  - 𬯎
+  - 𬘬
+  - 𬘭
+  - 𬴂
+  - 𫘦
+  - 𫟅
+  - 𬘯
+  - 𫘧
+  - 𪣻
+  - 𬃊
+  - 𬷕
+  - 𫐐
+  - 𬹼
+  - 𫶇
+  - 𫖮
+  - 鿏
+  - 𬭊
+  - 𫓶
+  - 𬭎
+  - 𫖯
+  - 𬱟
+  - 𫛭
+  - 𫷷
+  - 𬮱
+  - 𬊤
+  - 𬴃
+  - 𫘨
+  - 𬪩
+  - 𬒔
+  - 𬨎
+  - 𫐓
+  - 𫫇
+  - 𫓹
+  - 𬭚
+  - 𬭛
+  - 𬕂
+  - 𬶋
+  - 𬶍
+  - 𫔶
+  - 𫌀
+  - 𫖳
+  - 𫘪
+  - 𫘬
+  - 𫞩
+  - 𪤗
+  - 𬸘
+  - 𬒗
+  - 𫚖
+  - 𬭤
+  - 𫚕
+  - 𬶐
+  - 𬶏
+  - 𬸚
+  - 𬤝
+  - 𬙂
+  - 𬭩
+  - 𬸣
+  - 𫍽
+  - 𬴊
+  - 𬞟
+  - 𫟦
+  - 𬺈
+  - 𫠜
+  - 𪩘
+  - 𬭬
+  - 𬭯
+  - 𫗴
+  - 𬸦
+  - 𫄷
+  - 𬭳
+  - 𬭶
+  - 𫔍
+  - 𬭸
+  - 𬭼
+  - 𫔎
+  - 𬸪
+  - 𬶟
+  - 𬶠
+  - 𬶨
+  - 𫄸
+  - 𬟁
+  - 𬙊
+  - 𬶭
+  - 𬶮
+  - 𬙋
+  - 𬺓
+  - 𫚭
+  - 廠
+  - 蔔
+  - 兒
+  - 幾
+  - 幹
+  - 虧
+  - 纔
+  - 與
+  - 萬
+  - 韆
+  - 億
+  - 個
+  - 廣
+  - 門
+  - 義
+  - 衛
+  - 飛
+  - 習
+  - 馬
+  - 鄉
+  - 豐
+  - 開
+  - 無
+  - 雲
+  - 專
+  - 藝
+  - 廳
+  - 區
+  - 歷
+  - 曆
+  - 車
+  - 貝
+  - 岡
+  - 見
+  - 氣
+  - 長
+  - 僕
+  - 幣
+  - 僅
+  - 從
+  - 侖
+  - 倉
+  - 風
+  - 烏
+  - 鳳
+  - 爲
+  - 鬥
+  - 憶
+  - 計
+  - 訂
+  - 認
+  - 譏
+  - 醜
+  - 隊
+  - 辦
+  - 鄧
+  - 勸
+  - 雙
+  - 書
+  - 擊
+  - 撲
+  - 節
+  - 術
+  - 厲
+  - 龍
+  - 滅
+  - 軋
+  - 東
+  - 盧
+  - 業
+  - 舊
+  - 帥
+  - 歸
+  - 葉
+  - 電
+  - 號
+  - 衹
+  - 隻
+  - 嘰
+  - 嘆
+  - 們
+  - 儀
+  - 叢
+  - 爾
+  - 樂
+  - 處
+  - 鼕
+  - 鳥
+  - 務
+  - 飢
+  - 饑
+  - 馮
+  - 閃
+  - 蘭
+  - 匯
+  - 彙
+  - 頭
+  - 漢
+  - 寧
+  - 討
+  - 寫
+  - 讓
+  - 禮
+  - 訓
+  - 議
+  - 訊
+  - 記
+  - 齣
+  - 遼
+  - 邊
+  - 發
+  - 髮
+  - 聖
+  - 對
+  - 臺
+  - 颱
+  - 檯
+  - 糾
+  - 絲
+  - 動
+  - 鞏
+  - 執
+  - 擴
+  - 掃
+  - 場
+  - 揚
+  - 亞
+  - 樸
+  - 機
+  - 權
+  - 過
+  - 協
+  - 壓
+  - 厭
+  - 頁
+  - 誇
+  - 奪
+  - 達
+  - 夾
+  - 軌
+  - 堯
+  - 劃
+  - 邁
+  - 畢
+  - 貞
+  - 師
+  - 塵
+  - 當
+  - 噹
+  - 籲
+  - 嚇
+  - 蟲
+  - 麯
+  - 團
+  - 糰
+  - 嗎
+  - 嶼
+  - 歲
+  - 迴
+  - 豈
+  - 則
+  - 剛
+  - 網
+  - 硃
+  - 遷
+  - 喬
+  - 偉
+  - 傳
+  - 優
+  - 傷
+  - 價
+  - 倫
+  - 華
+  - 僞
+  - 嚮
+  - 後
+  - 會
+  - 殺
+  - 閤
+  - 衆
+  - 爺
+  - 傘
+  - 創
+  - 雜
+  - 負
+  - 壯
+  - 衝
+  - 妝
+  - 莊
+  - 慶
+  - 劉
+  - 齊
+  - 産
+  - 閉
+  - 問
+  - 闖
+  - 關
+  - 燈
+  - 湯
+  - 興
+  - 講
+  - 諱
+  - 軍
+  - 訝
+  - 許
+  - 訛
+  - 論
+  - 訟
+  - 農
+  - 諷
+  - 設
+  - 訪
+  - 訣
+  - 尋
+  - 盡
+  - 儘
+  - 導
+  - 孫
+  - 陣
+  - 陽
+  - 階
+  - 陰
+  - 婦
+  - 媽
+  - 戲
+  - 觀
+  - 歡
+  - 買
+  - 紅
+  - 馱
+  - 纖
+  - 縴
+  - 馴
+  - 約
+  - 級
+  - 紀
+  - 馳
+  - 紉
+  - 壽
+  - 麥
+  - 瑪
+  - 進
+  - 遠
+  - 違
+  - 韌
+  - 運
+  - 撫
+  - 壇
+  - 罎
+  - 壞
+  - 摳
+  - 擾
+  - 貢
+  - 垻
+  - 壩
+  - 摺
+  - 掄
+  - 搶
+  - 墳
+  - 護
+  - 殻
+  - 塊
+  - 聲
+  - 報
+  - 擬
+  - 蕪
+  - 葦
+  - 蒼
+  - 嚴
+  - 蘆
+  - 勞
+  - 蘇
+  - 囌
+  - 極
+  - 楊
+  - 兩
+  - 麗
+  - 醫
+  - 勵
+  - 還
+  - 殲
+  - 來
+  - 連
+  - 軒
+  - 鹵
+  - 滷
+  - 堅
+  - 時
+  - 縣
+  - 裏
+  - 嘔
+  - 園
+  - 曠
+  - 圍
+  - 噸
+  - 郵
+  - 睏
+  - 員
+  - 聽
+  - 嗆
+  - 嗚
+  - 彆
+  - 嶇
+  - 崗
+  - 帳
+  - 財
+  - 針
+  - 釘
+  - 亂
+  - 體
+  - 傭
+  - 徹
+  - 餘
+  - 穀
+  - 鄰
+  - 腸
+  - 龜
+  - 猶
+  - 狽
+  - 條
+  - 島
+  - 飯
+  - 飲
+  - 係
+  - 繫
+  - 凍
+  - 狀
+  - 畝
+  - 庫
+  - 療
+  - 應
+  - 這
+  - 廬
+  - 閏
+  - 閑
+  - 間
+  - 悶
+  - 竈
+  - 燦
+  - 瀝
+  - 淪
+  - 滄
+  - 溝
+  - 滬
+  - 瀋
+  - 懷
+  - 憂
+  - 窮
+  - 證
+  - 啓
+  - 評
+  - 補
+  - 識
+  - 詐
+  - 訴
+  - 診
+  - 詞
+  - 譯
+  - 靈
+  - 層
+  - 遲
+  - 張
+  - 際
+  - 陸
+  - 陳
+  - 墜
+  - 勁
+  - 鷄
+  - 緯
+  - 驅
+  - 純
+  - 紗
+  - 綱
+  - 納
+  - 駁
+  - 縱
+  - 紛
+  - 紙
+  - 紋
+  - 紡
+  - 驢
+  - 紐
+  - 環
+  - 責
+  - 現
+  - 錶
+  - 規
+  - 攏
+  - 揀
+  - 擔
+  - 頂
+  - 擁
+  - 勢
+  - 攔
+  - 擰
+  - 撥
+  - 擇
+  - 蘋
+  - 範
+  - 莖
+  - 樞
+  - 櫃
+  - 闆
+  - 鬆
+  - 槍
+  - 楓
+  - 構
+  - 喪
+  - 畫
+  - 棗
+  - 賣
+  - 鬱
+  - 礬
+  - 礦
+  - 碼
+  - 厠
+  - 奮
+  - 態
+  - 歐
+  - 毆
+  - 壟
+  - 轟
+  - 頃
+  - 轉
+  - 斬
+  - 輪
+  - 軟
+  - 齒
+  - 虜
+  - 腎
+  - 賢
+  - 國
+  - 暢
+  - 嚨
+  - 鳴
+  - 羅
+  - 幟
+  - 嶺
+  - 凱
+  - 敗
+  - 賬
+  - 販
+  - 貶
+  - 購
+  - 貯
+  - 圖
+  - 釣
+  - 製
+  - 颳
+  - 俠
+  - 僥
+  - 偵
+  - 側
+  - 憑
+  - 僑
+  - 貨
+  - 質
+  - 徑
+  - 捨
+  - 覓
+  - 貪
+  - 貧
+  - 膚
+  - 腫
+  - 脹
+  - 骯
+  - 脅
+  - 魚
+  - 獰
+  - 備
+  - 飾
+  - 飽
+  - 飼
+  - 變
+  - 龐
+  - 廟
+  - 瘧
+  - 劑
+  - 廢
+  - 閘
+  - 鬧
+  - 鄭
+  - 捲
+  - 單
+  - 爐
+  - 淺
+  - 濘
+  - 瀉
+  - 潑
+  - 澤
+  - 憐
+  - 學
+  - 寶
+  - 寵
+  - 審
+  - 簾
+  - 實
+  - 試
+  - 詩
+  - 誠
+  - 襯
+  - 視
+  - 話
+  - 誕
+  - 詭
+  - 詢
+  - 該
+  - 詳
+  - 肅
+  - 録
+  - 隸
+  - 彌
+  - 瀰
+  - 陝
+  - 駕
+  - 參
+  - 艱
+  - 綫
+  - 練
+  - 組
+  - 紳
+  - 細
+  - 駛
+  - 織
+  - 駒
+  - 終
+  - 駐
+  - 絆
+  - 駝
+  - 紹
+  - 繹
+  - 經
+  - 貫
+  - 貳
+  - 幫
+  - 項
+  - 挾
+  - 撓
+  - 趙
+  - 擋
+  - 墊
+  - 擠
+  - 揮
+  - 薦
+  - 帶
+  - 繭
+  - 蕩
+  - 榮
+  - 葷
+  - 熒
+  - 鬍
+  - 蔭
+  - 藥
+  - 標
+  - 棧
+  - 棟
+  - 欄
+  - 檸
+  - 樹
+  - 鹹
+  - 磚
+  - 硯
+  - 麵
+  - 牽
+  - 鷗
+  - 殘
+  - 軸
+  - 輕
+  - 鴉
+  - 戰
+  - 點
+  - 臨
+  - 覽
+  - 竪
+  - 嘗
+  - 啞
+  - 顯
+  - 貴
+  - 蝦
+  - 蟻
+  - 螞
+  - 雖
+  - 駡
+  - 勛
+  - 嘩
+  - 響
+  - 喲
+  - 峽
+  - 罰
+  - 賤
+  - 貼
+  - 貽
+  - 鈣
+  - 鈍
+  - 鈔
+  - 鍾
+  - 鐘
+  - 鋼
+  - 鈉
+  - 鑰
+  - 欽
+  - 鈞
+  - 鈎
+  - 鈕
+  - 氈
+  - 氫
+  - 選
+  - 適
+  - 種
+  - 鞦
+  - 復
+  - 複
+  - 倆
+  - 貸
+  - 順
+  - 儉
+  - 須
+  - 鬚
+  - 劍
+  - 朧
+  - 膽
+  - 勝
+  - 狹
+  - 獅
+  - 獨
+  - 獄
+  - 貿
+  - 餌
+  - 饒
+  - 蝕
+  - 餃
+  - 餅
+  - 巒
+  - 彎
+  - 將
+  - 奬
+  - 瘡
+  - 瘋
+  - 親
+  - 閨
+  - 聞
+  - 閩
+  - 閥
+  - 閣
+  - 養
+  - 薑
+  - 類
+  - 婁
+  - 總
+  - 煉
+  - 爍
+  - 爛
+  - 窪
+  - 潔
+  - 灑
+  - 澆
+  - 濁
+  - 測
+  - 瀏
+  - 濟
+  - 渾
+  - 濃
+  - 惱
+  - 舉
+  - 覺
+  - 憲
+  - 竊
+  - 誡
+  - 誣
+  - 語
+  - 襖
+  - 誤
+  - 誘
+  - 誨
+  - 説
+  - 誦
+  - 墾
+  - 晝
+  - 費
+  - 遜
+  - 隕
+  - 險
+  - 嬌
+  - 賀
+  - 壘
+  - 綁
+  - 絨
+  - 結
+  - 繞
+  - 驕
+  - 繪
+  - 給
+  - 絢
+  - 駱
+  - 絡
+  - 絶
+  - 絞
+  - 駭
+  - 統
+  - 艷
+  - 蠶
+  - 頑
+  - 盞
+  - 撈
+  - 載
+  - 趕
+  - 鹽
+  - 損
+  - 撿
+  - 摯
+  - 剝
+  - 熱
+  - 搗
+  - 壺
+  - 聶
+  - 萊
+  - 蓮
+  - 獲
+  - 穫
+  - 惡
+  - 噁
+  - 瑩
+  - 鶯
+  - 檔
+  - 橋
+  - 樺
+  - 樁
+  - 樣
+  - 賈
+  - 礫
+  - 礎
+  - 顧
+  - 轎
+  - 較
+  - 頓
+  - 斃
+  - 緻
+  - 慮
+  - 監
+  - 緊
+  - 黨
+  - 曬
+  - 曉
+  - 嘮
+  - 鴨
+  - 暈
+  - 鴦
+  - 罷
+  - 圓
+  - 賊
+  - 賄
+  - 賂
+  - 贜
+  - 錢
+  - 鉗
+  - 鑽
+  - 鉀
+  - 鐵
+  - 鈴
+  - 鉛
+  - 犧
+  - 敵
+  - 積
+  - 稱
+  - 筆
+  - 債
+  - 傾
+  - 賃
+  - 艦
+  - 艙
+  - 聳
+  - 愛
+  - 頒
+  - 頌
+  - 臟
+  - 髒
+  - 臍
+  - 膠
+  - 腦
+  - 膿
+  - 鴕
+  - 鴛
+  - 皺
+  - 餓
+  - 餒
+  - 戀
+  - 槳
+  - 漿
+  - 準
+  - 癥
+  - 齋
+  - 離
+  - 資
+  - 競
+  - 閲
+  - 煩
+  - 燒
+  - 燭
+  - 遞
+  - 濤
+  - 澇
+  - 渦
+  - 塗
+  - 滌
+  - 潤
+  - 澗
+  - 漲
+  - 燙
+  - 澀
+  - 憫
+  - 寬
+  - 傢
+  - 賓
+  - 竅
+  - 請
+  - 諸
+  - 諾
+  - 讀
+  - 誹
+  - 襪
+  - 課
+  - 誰
+  - 調
+  - 諒
+  - 諄
+  - 談
+  - 誼
+  - 懇
+  - 劇
+  - 難
+  - 預
+  - 絹
+  - 綉
+  - 驗
+  - 繼
+  - 駿
+  - 瑣
+  - 擲
+  - 據
+  - 摻
+  - 職
+  - 蘿
+  - 螢
+  - 營
+  - 蕭
+  - 薩
+  - 夢
+  - 檢
+  - 醖
+  - 碩
+  - 聾
+  - 襲
+  - 輔
+  - 輛
+  - 顱
+  - 懸
+  - 躍
+  - 纍
+  - 囉
+  - 嘯
+  - 嶄
+  - 邏
+  - 嬰
+  - 銬
+  - 鐺
+  - 鋁
+  - 銅
+  - 銘
+  - 鏟
+  - 銀
+  - 矯
+  - 穢
+  - 籠
+  - 償
+  - 軀
+  - 釁
+  - 銜
+  - 盤
+  - 鴿
+  - 斂
+  - 領
+  - 臉
+  - 獵
+  - 餡
+  - 館
+  - 癢
+  - 鏇
+  - 閻
+  - 闡
+  - 蓋
+  - 斷
+  - 獸
+  - 鴻
+  - 漸
+  - 淵
+  - 漁
+  - 澱
+  - 滲
+  - 慚
+  - 懼
+  - 驚
+  - 慘
+  - 慣
+  - 謀
+  - 諜
+  - 謊
+  - 諧
+  - 禱
+  - 禍
+  - 謂
+  - 諺
+  - 謎
+  - 彈
+  - 墮
+  - 隨
+  - 隱
+  - 嬸
+  - 頗
+  - 頸
+  - 績
+  - 緒
+  - 續
+  - 騎
+  - 綽
+  - 繩
+  - 維
+  - 綿
+  - 綳
+  - 綢
+  - 綜
+  - 綻
+  - 緑
+  - 綴
+  - 瓊
+  - 趨
+  - 攬
+  - 攙
+  - 擱
+  - 摟
+  - 攪
+  - 聯
+  - 蔣
+  - 韓
+  - 橢
+  - 確
+  - 頰
+  - 靂
+  - 暫
+  - 翹
+  - 輩
+  - 鑿
+  - 輝
+  - 賞
+  - 睞
+  - 噴
+  - 疇
+  - 踐
+  - 遺
+  - 鵑
+  - 賦
+  - 賭
+  - 贖
+  - 賜
+  - 賠
+  - 鑄
+  - 鋪
+  - 鏈
+  - 銷
+  - 鎖
+  - 鋤
+  - 鍋
+  - 銹
+  - 鋒
+  - 鋅
+  - 鋭
+  - 鵝
+  - 築
+  - 篩
+  - 儲
+  - 懲
+  - 禦
+  - 釋
+  - 臘
+  - 魯
+  - 憊
+  - 饋
+  - 饞
+  - 裝
+  - 蠻
+  - 闊
+  - 糞
+  - 滯
+  - 濕
+  - 潰
+  - 濺
+  - 灣
+  - 憤
+  - 竄
+  - 窩
+  - 褲
+  - 禪
+  - 謝
+  - 謡
+  - 謗
+  - 謙
+  - 屬
+  - 屢
+  - 緬
+  - 纜
+  - 緝
+  - 緞
+  - 緩
+  - 締
+  - 縷
+  - 騙
+  - 編
+  - 騷
+  - 緣
+  - 鵡
+  - 攝
+  - 擺
+  - 襬
+  - 攤
+  - 鵲
+  - 藍
+  - 濛
+  - 懞
+  - 矇
+  - 獻
+  - 欖
+  - 樓
+  - 賴
+  - 礙
+  - 尷
+  - 霧
+  - 輻
+  - 輯
+  - 輸
+  - 頻
+  - 齡
+  - 鑒
+  - 蹺
+  - 蝸
+  - 錯
+  - 錨
+  - 錫
+  - 鑼
+  - 錘
+  - 錐
+  - 錦
+  - 鍵
+  - 鋸
+  - 錳
+  - 辭
+  - 頽
+  - 籌
+  - 簽
+  - 籤
+  - 簡
+  - 膩
+  - 鵬
+  - 騰
+  - 鮑
+  - 穎
+  - 觸
+  - 雛
+  - 饃
+  - 餾
+  - 醬
+  - 謄
+  - 糧
+  - 數
+  - 滿
+  - 濾
+  - 濫
+  - 灕
+  - 濱
+  - 灘
+  - 譽
+  - 窺
+  - 寢
+  - 謹
+  - 謬
+  - 闢
+  - 縛
+  - 縫
+  - 纏
+  - 繽
+  - 贅
+  - 墻
+  - 衊
+  - 藹
+  - 檻
+  - 釀
+  - 願
+  - 轄
+  - 輾
+  - 顆
+  - 踴
+  - 蠟
+  - 蠅
+  - 蟬
+  - 賺
+  - 鍬
+  - 鍛
+  - 鍍
+  - 穩
+  - 籮
+  - 簫
+  - 輿
+  - 鮮
+  - 饅
+  - 瀟
+  - 賽
+  - 譚
+  - 譜
+  - 騾
+  - 縮
+  - 攆
+  - 聰
+  - 藴
+  - 櫻
+  - 飄
+  - 黴
+  - 瞞
+  - 題
+  - 囑
+  - 鎮
+  - 鎬
+  - 鎊
+  - 簍
+  - 鯉
+  - 鯽
+  - 癟
+  - 癱
+  - 顔
+  - 鯊
+  - 瀾
+  - 額
+  - 譴
+  - 鶴
+  - 繚
+  - 顛
+  - 轍
+  - 鸚
+  - 贈
+  - 鏡
+  - 贊
+  - 籃
+  - 籬
+  - 鯨
+  - 癮
+  - 辯
+  - 瀕
+  - 懶
+  - 繮
+  - 繳
+  - 矚
+  - 贍
+  - 鰐
+  - 辮
+  - 贏
+  - 驟
+  - 囂
+  - 鐮
+  - 鰭
+  - 鷹
+  - 巔
+  - 顫
+  - 癬
+  - 鱉
+  - 鬢
+  - 鱗
+  - 躪
+  - 贛
+  - 鑲
+  - 韋
+  - 閂
+  - 訃
+  - 勱
+  - 芻
+  - 鄺
+  - 訐
+  - 訌
+  - 訕
+  - 訖
+  - 馭
+  - 璣
+  - 壙
+  - 捫
+  - 薌
+  - 厙
+  - 釔
+  - 傴
+  - 倀
+  - 傖
+  - 獷
+  - 獁
+  - 鳬
+  - 鄔
+  - 餳
+  - 懺
+  - 謳
+  - 詎
+  - 訥
+  - 紆
+  - 紂
+  - 紇
+  - 紈
+  - 璵
+  - 摶
+  - 塢
+  - 㩳
+  - 蕓
+  - 藶
+  - 莧
+  - 萇
+  - 蓯
+  - 磯
+  - 奩
+  - 歟
+  - 軔
+  - 鄴
+  - 嘸
+  - 囈
+  - 嚦
+  - 暘
+  - 唄
+  - 幃
+  - 峴
+  - 嵐
+  - 圇
+  - 釗
+  - 釙
+  - 釕
+  - 僉
+  - 鳩
+  - 鄒
+  - 飩
+  - 餼
+  - 飪
+  - 飫
+  - 飭
+  - 廡
+  - 癤
+  - 闈
+  - 閎
+  - 閔
+  - 煬
+  - 灃
+  - 漚
+  - 渢
+  - 潙
+  - 憮
+  - 慪
+  - 愾
+  - 悵
+  - 愴
+  - 詁
+  - 訶
+  - 詛
+  - 詆
+  - 謅
+  - 詔
+  - 詒
+  - 隴
+  - 陘
+  - 嫵
+  - 嫗
+  - 嬀
+  - 剄
+  - 紜
+  - 紕
+  - 紝
+  - 綸
+  - 紓
+  - 瑋
+  - 匭
+  - 壚
+  - 擓
+  - 蘢
+  - 蔦
+  - 塋
+  - 煢
+  - 櫪
+  - 梘
+  - 棖
+  - 樅
+  - 碭
+  - 甌
+  - 郟
+  - 軛
+  - 鳶
+  - 曇
+  - 蟣
+  - 黽
+  - 嚀
+  - 噝
+  - 巋
+  - 劌
+  - 剴
+  - 嶧
+  - 釷
+  - 釺
+  - 釧
+  - 釩
+  - 釹
+  - 釵
+  - 儈
+  - 儕
+  - 儂
+  - 劊
+  - 慫
+  - 糴
+  - 戧
+  - 膞
+  - 邇
+  - 梟
+  - 餞
+  - 飴
+  - 癘
+  - 瘍
+  - 煒
+  - 熰
+  - 熗
+  - 瀧
+  - 瀘
+  - 濼
+  - 涇
+  - 㥮
+  - 懌
+  - 誆
+  - 誄
+  - 詿
+  - 詰
+  - 詼
+  - 鄆
+  - 禕
+  - 誅
+  - 詵
+  - 詬
+  - 詮
+  - 詣
+  - 諍
+  - 詫
+  - 諢
+  - 詡
+  - 駑
+  - 紺
+  - 紲
+  - 紱
+  - 駟
+  - 駙
+  - 縐
+  - 絀
+  - 驛
+  - 駘
+  - 瓏
+  - 頇
+  - 埡
+  - 撾
+  - 撻
+  - 賁
+  - 壋
+  - 撏
+  - 莢
+  - 貰
+  - 蓽
+  - 蕎
+  - 薈
+  - 薺
+  - 堊
+  - 滎
+  - 犖
+  - 蕁
+  - 藎
+  - 蓀
+  - 蕒
+  - 葤
+  - 櫛
+  - 櫳
+  - 櫨
+  - 櫟
+  - 檉
+  - 酈
+  - 硨
+  - 碸
+  - 殤
+  - 軲
+  - 軻
+  - 轤
+  - 軼
+  - 軫
+  - 蠆
+  - 覘
+  - 瞘
+  - 嘵
+  - 嗶
+  - 噦
+  - 剮
+  - 鄖
+  - 噲
+  - 噥
+  - 嶢
+  - 幀
+  - 嶠
+  - 貺
+  - 鈈
+  - 鈦
+  - 鋇
+  - 鈑
+  - 鈐
+  - 鎢
+  - 鈁
+  - 鈀
+  - 篤
+  - 儔
+  - 儼
+  - 儷
+  - 腖
+  - 臚
+  - 脛
+  - 鴇
+  - 獪
+  - 颮
+  - 猻
+  - 餉
+  - 餄
+  - 餎
+  - 孿
+  - 孌
+  - 癧
+  - 瘲
+  - 颯
+  - 闥
+  - 閭
+  - 闓
+  - 閡
+  - 熾
+  - 烴
+  - 浹
+  - 澮
+  - 滸
+  - 潯
+  - 濜
+  - 慟
+  - 懨
+  - 愷
+  - 惻
+  - 惲
+  - 誚
+  - 禰
+  - 誥
+  - 誑
+  - 鴆
+  - 婭
+  - 嬈
+  - 懟
+  - 絝
+  - 驍
+  - 驊
+  - 絎
+  - 絳
+  - 駢
+  - 頊
+  - 璫
+  - 琿
+  - 塒
+  - 塤
+  - 堝
+  - 贄
+  - 蒔
+  - 萵
+  - 蕕
+  - 鴣
+  - 蒓
+  - 橈
+  - 楨
+  - 榿
+  - 檜
+  - 邐
+  - 礪
+  - 礱
+  - 軾
+  - 輊
+  - 輅
+  - 鶇
+  - 躉
+  - 齔
+  - 鸕
+  - 矓
+  - 嘜
+  - 鴞
+  - 蜆
+  - 嗩
+  - 嶗
+  - 崍
+  - 覬
+  - 賅
+  - 鈺
+  - 鉦
+  - 鈷
+  - 鉢
+  - 鈸
+  - 鉞
+  - 鉭
+  - 鉬
+  - 鈿
+  - 鈾
+  - 鉑
+  - 鑠
+  - 鉚
+  - 鈰
+  - 鉉
+  - 鉈
+  - 鉍
+  - 鈮
+  - 鈹
+  - 鏺
+  - 鐸
+  - 氬
+  - 筧
+  - 頎
+  - 徠
+  - 膾
+  - 鴟
+  - 璽
+  - 鴝
+  - 獫
+  - 裊
+  - 餑
+  - 欒
+  - 攣
+  - 癰
+  - 痙
+  - 頏
+  - 閫
+  - 鬮
+  - 誾
+  - 閬
+  - 鄲
+  - 燁
+  - 燴
+  - 燼
+  - 淶
+  - 漣
+  - 潿
+  - 慳
+  - 諏
+  - 諑
+  - 禎
+  - 諉
+  - 諛
+  - 諗
+  - 諂
+  - 誶
+  - 媧
+  - 嫻
+  - 綆
+  - 驪
+  - 綃
+  - 騁
+  - 綏
+  - 縧
+  - 綈
+  - 駸
+  - 鷥
+  - 燾
+  - 璉
+  - 麩
+  - 擄
+  - 摑
+  - 鷙
+  - 撣
+  - 慤
+  - 摜
+  - 縈
+  - 槤
+  - 覡
+  - 欞
+  - 嗇
+  - 匱
+  - 硤
+  - 磽
+  - 鴯
+  - 龔
+  - 殞
+  - 殮
+  - 賚
+  - 輒
+  - 塹
+  - 嘖
+  - 囀
+  - 嚙
+  - 蹌
+  - 蠣
+  - 蠱
+  - 蟶
+  - 幘
+  - 幗
+  - 賕
+  - 賑
+  - 賒
+  - 銠
+  - 鉺
+  - 鋏
+  - 鐃
+  - 銦
+  - 鎧
+  - 鍘
+  - 銖
+  - 銑
+  - 鋌
+  - 鏵
+  - 銓
+  - 鎩
+  - 鉿
+  - 銚
+  - 鉻
+  - 錚
+  - 銫
+  - 鉸
+  - 銥
+  - 銃
+  - 銨
+  - 銣
+  - 鴰
+  - 穠
+  - 箋
+  - 籩
+  - 僨
+  - 僂
+  - 皚
+  - 鴴
+  - 艫
+  - 龕
+  - 玀
+  - 獼
+  - 餜
+  - 餛
+  - 鸞
+  - 闍
+  - 閾
+  - 閹
+  - 閶
+  - 鬩
+  - 閽
+  - 閼
+  - 羥
+  - 糲
+  - 燜
+  - 漬
+  - 瀆
+  - 澠
+  - 愜
+  - 憚
+  - 諶
+  - 諫
+  - 皸
+  - 謔
+  - 襠
+  - 謁
+  - 諤
+  - 諭
+  - 諼
+  - 讒
+  - 諳
+  - 諦
+  - 諞
+  - 糶
+  - 嬋
+  - 綾
+  - 騏
+  - 綺
+  - 緋
+  - 緔
+  - 騍
+  - 緄
+  - 騅
+  - 綬
+  - 綹
+  - 綣
+  - 綰
+  - 驂
+  - 緇
+  - 靚
+  - 輦
+  - 黿
+  - 頡
+  - 撳
+  - 蟄
+  - 壪
+  - 蔞
+  - 櫝
+  - 欏
+  - 賫
+  - 鵓
+  - 鸝
+  - 殫
+  - 輥
+  - 輞
+  - 槧
+  - 輟
+  - 輜
+  - 瞼
+  - 躒
+  - 蛺
+  - 蟯
+  - 螄
+  - 蠐
+  - 嘍
+  - 嶸
+  - 嶁
+  - 賧
+  - 鋙
+  - 錸
+  - 鏗
+  - 鋥
+  - 鋰
+  - 鋯
+  - 鋨
+  - 銼
+  - 鐧
+  - 銻
+  - 鋃
+  - 鋦
+  - 錒
+  - 犢
+  - 鵠
+  - 篳
+  - 牘
+  - 儻
+  - 儐
+  - 儺
+  - 嬃
+  - 頜
+  - 鵒
+  - 魷
+  - 魨
+  - 魴
+  - 潁
+  - 颶
+  - 觴
+  - 熲
+  - 餷
+  - 餿
+  - 褻
+  - 臠
+  - 癆
+  - 癇
+  - 賡
+  - 頦
+  - 鷳
+  - 闌
+  - 闃
+  - 闋
+  - 鵜
+  - 憒
+  - 嚳
+  - 謨
+  - 褳
+  - 襇
+  - 讜
+  - 謖
+  - 謚
+  - 謐
+  - 騭
+  - 巰
+  - 翬
+  - 騖
+  - 緙
+  - 緗
+  - 緘
+  - 緹
+  - 緲
+  - 緦
+  - 緱
+  - 縋
+  - 緡
+  - 饗
+  - 耮
+  - 驁
+  - 韞
+  - 攄
+  - 擯
+  - 轂
+  - 驀
+  - 鶓
+  - 薊
+  - 蘺
+  - 鎣
+  - 頤
+  - 櫚
+  - 櫸
+  - 磧
+  - 磣
+  - 鵪
+  - 輳
+  - 齟
+  - 齙
+  - 韙
+  - 囁
+  - 躂
+  - 蹕
+  - 躚
+  - 躋
+  - 噯
+  - 鍺
+  - 錛
+  - 錡
+  - 鍀
+  - 錁
+  - 錕
+  - 錮
+  - 鍁
+  - 錈
+  - 錠
+  - 錙
+  - 覦
+  - 頷
+  - 鮁
+  - 鮃
+  - 鮎
+  - 鱸
+  - 穌
+  - 鮒
+  - 鮐
+  - 鵮
+  - 颼
+  - 饈
+  - 鶉
+  - 瘮
+  - 闔
+  - 闐
+  - 闕
+  - 灧
+  - 瀅
+  - 潷
+  - 灤
+  - 澦
+  - 懾
+  - 鱟
+  - 騫
+  - 竇
+  - 謾
+  - 謫
+  - 嬡
+  - 嬪
+  - 縉
+  - 縝
+  - 縟
+  - 轡
+  - 騮
+  - 縞
+  - 縭
+  - 縊
+  - 縑
+  - 騸
+  - 覯
+  - 韜
+  - 靉
+  - 攖
+  - 薔
+  - 藺
+  - 鶘
+  - 檳
+  - 櫧
+  - 釅
+  - 殯
+  - 霽
+  - 轅
+  - 齜
+  - 齦
+  - 瞜
+  - 曖
+  - 躊
+  - 蟈
+  - 鶚
+  - 嚶
+  - 羆
+  - 賻
+  - 罌
+  - 鶻
+  - 鍥
+  - 鍇
+  - 鍶
+  - 鍔
+  - 鍤
+  - 鏘
+  - 鎂
+  - 鏤
+  - 簀
+  - 篋
+  - 簞
+  - 籙
+  - 臏
+  - 鮭
+  - 鮪
+  - 鱭
+  - 鮫
+  - 鱘
+  - 饉
+  - 鑾
+  - 瘻
+  - 闞
+  - 鮝
+  - 糝
+  - 鷀
+  - 瀲
+  - 濰
+  - 譖
+  - 褸
+  - 譙
+  - 讕
+  - 譎
+  - 鶥
+  - 嬙
+  - 鶩
+  - 驃
+  - 縹
+  - 縵
+  - 縲
+  - 纓
+  - 驄
+  - 繆
+  - 繅
+  - 耬
+  - 瓔
+  - 擷
+  - 擼
+  - 攛
+  - 聵
+  - 覲
+  - 韃
+  - 鞽
+  - 蘄
+  - 賾
+  - 檣
+  - 靨
+  - 魘
+  - 饜
+  - 轆
+  - 齬
+  - 齪
+  - 覷
+  - 顒
+  - 躓
+  - 躑
+  - 蠑
+  - 螻
+  - 顎
+  - 嚕
+  - 顓
+  - 鑷
+  - 鎘
+  - 鎸
+  - 鎳
+  - 鎦
+  - 鎰
+  - 鎵
+  - 鑌
+  - 簣
+  - 鷂
+  - 鯁
+  - 鱺
+  - 鰱
+  - 鰹
+  - 鰣
+  - 鯀
+  - 鯇
+  - 觶
+  - 饊
+  - 饌
+  - 齏
+  - 讞
+  - 襤
+  - 譫
+  - 屨
+  - 纈
+  - 繕
+  - 繒
+  - 驏
+  - 擻
+  - 顳
+  - 顢
+  - 藪
+  - 櫓
+  - 櫞
+  - 贋
+  - 飆
+  - 鏨
+  - 轔
+  - 蟎
+  - 鐯
+  - 鏢
+  - 鏜
+  - 鏝
+  - 鏰
+  - 鏞
+  - 鏑
+  - 鏃
+  - 鏐
+  - 氌
+  - 穡
+  - 魎
+  - 鯪
+  - 鯡
+  - 鯤
+  - 鯧
+  - 鯝
+  - 鯢
+  - 鯛
+  - 鯔
+  - 獺
+  - 鷓
+  - 贇
+  - 癭
+  - 斕
+  - 瀨
+  - 顙
+  - 繾
+  - 繰
+  - 繯
+  - 蘚
+  - 鷯
+  - 齲
+  - 齷
+  - 躡
+  - 蹣
+  - 羈
+  - 鐔
+  - 鐝
+  - 鐐
+  - 鐓
+  - 鑭
+  - 鑹
+  - 鏹
+  - 鐙
+  - 籪
+  - 鷦
+  - 鱝
+  - 鰈
+  - 鯷
+  - 鰓
+  - 鰍
+  - 鰉
+  - 鯿
+  - 鷲
+  - 懣
+  - 鷸
+  - 鰲
+  - 韉
+  - 顥
+  - 鷺
+  - 䴉
+  - 髏
+  - 鑊
+  - 鐳
+  - 鐲
+  - 讎
+  - 鰨
+  - 鰥
+  - 鰩
+  - 癩
+  - 攢
+  - 靄
+  - 躥
+  - 髖
+  - 髕
+  - 鑔
+  - 籟
+  - 鰳
+  - 鰾
+  - 鱈
+  - 鰻
+  - 鱅
+  - 讖
+  - 驥
+  - 纘
+  - 瓚
+  - 鼉
+  - 黷
+  - 黲
+  - 鑣
+  - 鑞
+  - 臢
+  - 鱖
+  - 鱔
+  - 鱒
+  - 驤
+  - 顰
+  - 鱧
+  - 癲
+  - 灝
+  - 鸛
+  - 鑱
+  - 趲
+  - 顴
+  - 躦
+  - 饢
+  - 戇
+  - 戔
+  - 訏
+  - 訒
+  - 釓
+  - 俔
+  - 閆
+  - 澫
+  - 訢
+  - 訩
+  - 詝
+  - 紃
+  - 纊
+  - 瑒
+  - 剗
+  - 塸
+  - 壢
+  - 埨
+  - 撝
+  - 蔿
+  - 榪
+  - 軑
+  - 軏
+  - 咼
+  - 㠣
+  - 覎
+  - 㑳
+  - 颺
+  - 閌
+  - 潕
+  - 湋
+  - 澐
+  - 浿
+  - 諓
+  - 禡
+  - 詗
+  - 詘
+  - 詖
+  - 屓
+  - 彄
+  - 紘
+  - 馹
+  - 馼
+  - 紵
+  - 紞
+  - 駃
+  - 紖
+  - 瑲
+  - 薴
+  - 棡
+  - 軝
+  - 暐
+  - 晛
+  - 崬
+  - 釴
+  - 釤
+  - 鍆
+  - 鍚
+  - 鄶
+  - 獮
+  - 飿
+  - 嶨
+  - 詷
+  - 詪
+  - 鄩
+  - 鳲
+  - 隑
+  - 隮
+  - 娙
+  - 逕
+  - 駓
+  - 駔
+  - 駉
+  - 絅
+  - 騶
+  - 䮄
+  - 紼
+  - 紿
+  - 瓅
+  - 韍
+  - 墶
+  - 塏
+  - 薘
+  - 蕘
+  - 蔄
+  - 葒
+  - 鳾
+  - 龑
+  - 軹
+  - 軤
+  - 轢
+  - 軺
+  - 睍
+  - 曨
+  - 噠
+  - 鈃
+  - 鈇
+  - 鉅
+  - 鋹
+  - 釿
+  - 錀
+  - 鈧
+  - 鈥
+  - 鈄
+  - 倈
+  - 艤
+  - 鶬
+  - 颭
+  - 餏
+  - 湞
+  - 溮
+  - 滻
+  - 褘
+  - 絰
+  - 駰
+  - 絪
+  - 駪
+  - 綎
+  - 綖
+  - 驫
+  - 勣
+  - 璕
+  - 𡑍
+  - 䓣
+  - 薟
+  - 藭
+  - 椏
+  - 梜
+  - 頍
+  - 硜
+  - 輄
+  - 輈
+  - 輇
+  - 貲
+  - 嗊
+  - 曄
+  - 暉
+  - 鄳
+  - 幬
+  - 輋
+  - 嶮
+  - 贐
+  - 鉥
+  - 鉕
+  - 鑪
+  - 鉮
+  - 鉊
+  - 鉧
+  - 僤
+  - 鴒
+  - 魛
+  - 餗
+  - 燖
+  - 溳
+  - 礐
+  - 窵
+  - 襏
+  - 駼
+  - 絺
+  - 綌
+  - 騂
+  - 綄
+  - 璡
+  - 墠
+  - 壼
+  - 聹
+  - 蘀
+  - 勩
+  - 罃
+  - 檮
+  - 棶
+  - 厴
+  - 䃮
+  - 磑
+  - 礄
+  - 鴷
+  - 齕
+  - 頔
+  - 廼
+  - 凢
+  - 亾
+  - 枒
+  - 屍
+  - 匃
+  - 匄
+  - 紥
+  - 紮
+  - 疋
+  - 殀
+  - 讐
+  - 觔
+  - 兇
+  - 宂
+  - 㕥
+  - 㠯
+  - 栞
+  - 佈
+  - 佔
+  - 呌
+  - 敂
+  - 冄
+  - 坵
+  - 僊
+  - 怱
+  - 悤
+  - 冊
+  - 夘
+  - 戼
+  - 牠
+  - 妳
+  - 嬭
+  - 摃
+  - 釦
+  - 攷
+  - 託
+  - 衺
+  - 衕
+  - 弔
+  - 喫
+  - 囙
+  - 㠶
+  - 颿
+  - 秊
+  - 倣
+  - 髣
+  - 佀
+  - 朶
+  - 氷
+  - 決
+  - 併
+  - 並
+  - 竝
+  - 汙
+  - 汚
+  - 異
+  - 姦
+  - 廵
+  - 挵
+  - 衖
+  - 搤
+  - 阯
+  - 撦
+  - 埳
+  - 阬
+  - 誌
+  - 㕁
+  - 卻
+  - 刦
+  - 刧
+  - 刼
+  - 芲
+  - 蘤
+  - 桿
+  - 槓
+  - 荳
+  - 獃
+  - 唫
+  - 脗
+  - 皁
+  - 彿
+  - 髴
+  - 疘
+  - 刪
+  - 鉋
+  - 鑤
+  - 況
+  - 牀
+  - 恡
+  - 棄
+  - 洶
+  - 汎
+  - 災
+  - 烖
+  - 菑
+  - 禩
+  - 侷
+  - 跼
+  - 坿
+  - 玅
+  - 姉
+  - 妬
+  - 翫
+  - 搨
+  - 柺
+  - 拕
+  - 牴
+  - 觝
+  - 倖
+  - 抝
+  - 盃
+  - 桮
+  - 傑
+  - 逩
+  - 肎
+  - 菓
+  - 崐
+  - 崑
+  - 呪
+  - 虖
+  - 嘑
+  - 謼
+  - 詠
+  - 㟁
+  - 嵒
+  - 巗
+  - 巖
+  - 雰
+  - 稈
+  - 咊
+  - 嶽
+  - 妷
+  - 姪
+  - 廹
+  - 徃
+  - 餚
+  - 採
+  - 寀
+  - 唸
+  - 週
+  - 昬
+  - 兎
+  - 兔
+  - 亯
+  - 亱
+  - 䘚
+  - 淨
+  - 劵
+  - 匟
+  - 㳒
+  - 灋
+  - 洩
+  - 霑
+  - 淚
+  - 註
+  - 恠
+  - 箒
+  - 屆
+  - 絃
+  - 圅
+  - 旾
+  - 珎
+  - 掛
+  - 垜
+  - 艸
+  - 茘
+  - 査
+  - 栢
+  - 柵
+  - 栁
+  - 桺
+  - 柹
+  - 韮
+  - 揹
+  - 昰
+  - 閧
+  - 鬨
+  - 冐
+  - 暎
+  - 嚥
+  - 倃
+  - 𠴰
+  - 偺
+  - 喒
+  - 齩
+  - 欬
+  - 榘
+  - 㑺
+  - 儁
+  - 敍
+  - 敘
+  - 肧
+  - 脈
+  - 䘑
+  - 衇
+  - 跡
+  - 蹟
+  - 砲
+  - 礮
+  - 薙
+  - 鬀
+  - 恆
+  - 怳
+  - 卹
+  - 䘏
+  - 賉
+  - 婣
+  - 畊
+  - 揑
+  - 綑
+  - 輓
+  - 恥
+  - 躭
+  - 晉
+  - 棲
+  - 覈
+  - 慄
+  - 翄
+  - 脣
+  - 槕
+  - 㨪
+  - 螡
+  - 蟁
+  - 㤙
+  - 陗
+  - 峩
+  - 峯
+  - 乗
+  - 椉
+  - 咲
+  - 筍
+  - 俛
+  - 頫
+  - 勌
+  - 䠶
+  - 躳
+  - 慇
+  - 拏
+  - 㧱
+  - 挐
+  - 脃
+  - 胷
+  - 肐
+  - 貍
+  - 㽞
+  - 畱
+  - 淒
+  - 悽
+  - 蓆
+  - 効
+  - 傚
+  - 涼
+  - 缾
+  - 菸
+  - 煙
+  - 淛
+  - 湧
+  - 誖
+  - 猂
+  - 醼
+  - 讌
+  - 㝠
+  - 寃
+  - 孃
+  - 桒
+  - 毬
+  - 瑠
+  - 璢
+  - 瑯
+  - 㨗
+  - 搥
+  - 搯
+  - 蔆
+  - 惏
+  - 楳
+  - 槑
+  - 捄
+  - 廂
+  - 慽
+  - 慼
+  - 瞇
+  - 埜
+  - 畧
+  - 虵
+  - 稭
+  - 棃
+  - 犂
+  - 迻
+  - 媮
+  - 兠
+  - 舩
+  - 慾
+  - 綵
+  - 腳
+  - 𩓐
+  - 夠
+  - 豬
+  - 貓
+  - 湊
+  - 減
+  - 庻
+  - 蔴
+  - 菴
+  - 朢
+  - 睠
+  - 觕
+  - 麤
+  - 釬
+  - 銲
+  - 痳
+  - 殽
+  - 婬
+  - 滛
+  - 湻
+  - 㴱
+  - 樑
+  - 顇
+  - 㝛
+  - 窰
+  - 窯
+  - 琹
+  - 欵
+  - 墖
+  - 趂
+  - 隄
+  - 愽
+  - 揷
+  - 揫
+  - 煑
+  - 朞
+  - 㪚
+  - 塟
+  - 蔥
+  - 蔕
+  - 稜
+  - 棊
+  - 碁
+  - 椶
+  - 偪
+  - 㕑
+  - 廚
+  - 廈
+  - 鴈
+  - 冣
+  - 㝡
+  - 晳
+  - 鼃
+  - 餧
+  - 餵
+  - 嗁
+  - 諠
+  - 㡌
+  - 賸
+  - 筴
+  - 筞
+  - 筩
+  - 栰
+  - 暠
+  - 皜
+  - 踰
+  - 蝟
+  - 㪟
+  - 燄
+  - 遊
+  - 媿
+  - 嘅
+  - 庽
+  - 窓
+  - 牎
+  - 牕
+  - 窻
+  - 徧
+  - 僱
+  - 帬
+  - 裠
+  - 強
+  - 彊
+  - 疎
+  - 壻
+  - 瓌
+  - 䰟
+  - 皷
+  - 擕
+  - 㩗
+  - 㩦
+  - 攜
+  - 懃
+  - 鞾
+  - 幙
+  - 㮣
+  - 酧
+  - 詶
+  - 醻
+  - 掽
+  - 踫
+  - 㼝
+  - 盌
+  - 磟
+  - 覩
+  - 倸
+  - 㬉
+  - 煗
+  - 煖
+  - 晻
+  - 闇
+  - 炤
+  - 跥
+  - 䗬
+  - 蠭
+  - 寘
+  - 辠
+  - 稺
+  - 穉
+  - 燬
+  - 譭
+  - 瘉
+  - 癒
+  - 顋
+  - 骽
+  - 猨
+  - 蝯
+  - 稟
+  - 痺
+  - 癡
+  - 亷
+  - 㢘
+  - 韻
+  - 泝
+  - 遡
+  - 昚
+  - 躶
+  - 臝
+  - 羣
+  - 㬪
+  - 曡
+  - 疊
+  - 勦
+  - 琍
+  - 瓈
+  - 𤋮
+  - 熈
+  - 牓
+  - 搾
+  - 謌
+  - 堿
+  - 鹻
+  - 鹼
+  - 矁
+  - 燻
+  - 髈
+  - 𤺥
+  - 辢
+  - 旂
+  - 𡚁
+  - 潄
+  - 砦
+  - 詧
+  - 嫰
+  - 櫈
+  - 撐
+  - 墪
+  - 譔
+  - 鞵
+  - 鞌
+  - 蕋
+  - 橤
+  - 蘂
+  - 醕
+  - 譆
+  - 跴
+  - 蹤
+  - 蜨
+  - 蠍
+  - 稾
+  - 殭
+  - 惪
+  - 厀
+  - 襃
+  - 癅
+  - 䊀
+  - 餬
+  - 潛
+  - 癄
+  - 顦
+  - 鷰
+  - 藷
+  - 櫥
+  - 螎
+  - 蹏
+  - 蟇
+  - 譟
+  - 簒
+  - 彫
+  - 琱
+  - 鵰
+  - 餹
+  - 餻
+  - 簷
+  - 粦
+  - 燐
+  - 緐
+  - 幑
+  - 蹧
+  - 粇
+  - 穅
+  - 臋
+  - 籐
+  - 繙
+  - 飜
+  - 孼
+  - 蠏
+  - 燿
+  - 蝡
+  - 稬
+  - 穤
+  - 惷
+  - 覇
+  - 鑵
+  - 戹
+  - 阨
+  - 剳
+  - 帀
+  - 巵
+  - 亙
+  - 佇
+  - 竚
+  - 穽
+  - 岅
+  - 虯
+  - 𦍑
+  - 羗
+  - 啎
+  - 姙
+  - 㘭
+  - 袟
+  - 袠
+  - 逈
+  - 㒺
+  - 犛
+  - 氂
+  - 偘
+  - 甕
+  - 罋
+  - 冺
+  - 姍
+  - 蝨
+  - 琺
+  - 瑇
+  - 尅
+  - 梔
+  - 斮
+  - 斲
+  - 斵
+  - 暱
+  - 毘
+  - 蝱
+  - 吚
+  - 哶
+  - 峝
+  - 粃
+  - 竢
+  - 狥
+  - 秈
+  - 烱
+  - 㳄
+  - 袵
+  - 盇
+  - 涖
+  - 蒞
+  - 碪
+  - 蠔
+  - 唕
+  - 倐
+  - 儵
+  - 雋
+  - 皐
+  - 臯
+  - 衂
+  - 䶊
+  - 臙
+  - 獧
+  - 痾
+  - 皰
+  - 湼
+  - 澣
+  - 濬
+  - 塚
+  - 襢
+  - 娿
+  - 勅
+  - 勑
+  - 戞
+  - 廐
+  - 廄
+  - 眥
+  - 覜
+  - 勗
+  - 啗
+  - 噉
+  - 傯
+  - 挱
+  - 㥫
+  - 惥
+  - 慂
+  - 陻
+  - 蕚
+  - 萲
+  - 蕿
+  - 蘐
+  - 藼
+  - 櫂
+  - 箠
+  - 槨
+  - 啑
+  - 蹠
+  - 蚘
+  - 痐
+  - 蛕
+  - 蜖
+  - 瘖
+  - 遯
+  - 醃
+  - 飱
+  - 冪
+  - 簑
+  - 枏
+  - 柟
+  - 檝
+  - 楥
+  - 矴
+  - 椗
+  - 嘷
+  - 獋
+  - 粺
+  - 䈰
+  - 諐
+  - 齶
+  - 堘
+  - 疿
+  - 雝
+  - 秔
+  - 稉
+  - 槀
+  - 搉
+  - 廝
+  - 叡
+  - 嘠
+  - 蜋
+  - 筯
+  - 篛
+  - 麞
+  - 糉
+  - 緥
+  - 璿
+  - 髥
+  - 臕
+  - 餈
+  - 剹
+  - 橜
+  - 罇
+  - 蜺
+  - 矙
+  - 憇
+  - 翺
+  - 饍
+  - 瞖
+  - 羴
+  - 羶
+  - 爕
+  - 繦
+  - 騌
+  - 鬉
+  - 騣
+  - 蔾
+  - 䠀
+  - 簮
+  - 躕
+  - 蹵
+  - 䝔
+  - 貛
+  - 鼴
+  - 麐
+  - 塡
+  - あ
+  - い
+  - う
+  - え
+  - お
+  - か
+  - き
+  - く
+  - け
+  - こ
+  - さ
+  - し
+  - す
+  - せ
+  - そ
+  - た
+  - ち
+  - つ
+  - て
+  - と
+  - な
+  - に
+  - ぬ
+  - ね
+  - の
+  - は
+  - ひ
+  - ふ
+  - へ
+  - ほ
+  - ま
+  - み
+  - む
+  - め
+  - も
+  - や
+  - ゆ
+  - よ
+  - ら
+  - り
+  - る
+  - れ
+  - ろ
+  - わ
+  - を
+  - ん
+  - が
+  - ぎ
+  - ぐ
+  - げ
+  - ご
+  - ざ
+  - じ
+  - ず
+  - ぜ
+  - ぞ
+  - だ
+  - ぢ
+  - づ
+  - で
+  - ど
+  - ば
+  - び
+  - ぶ
+  - べ
+  - ぼ
+  - ぱ
+  - ぴ
+  - ぷ
+  - ぺ
+  - ぽ
+  - ぁ
+  - ぃ
+  - ぅ
+  - ぇ
+  - ぉ
+  - っ
+  - ゃ
+  - ゅ
+  - ょ
+  - ゎ
+  - ゕ
+  - ゖ
+  - ア
+  - イ
+  - ウ
+  - エ
+  - オ
+  - カ
+  - キ
+  - ク
+  - ケ
+  - コ
+  - サ
+  - シ
+  - ス
+  - セ
+  - ソ
+  - タ
+  - チ
+  - ツ
+  - テ
+  - ト
+  - ナ
+  - ニ
+  - ヌ
+  - ネ
+  - ノ
+  - ハ
+  - ヒ
+  - フ
+  - ヘ
+  - ホ
+  - マ
+  - ミ
+  - ム
+  - メ
+  - モ
+  - ヤ
+  - ユ
+  - ヨ
+  - ラ
+  - リ
+  - ル
+  - レ
+  - ロ
+  - ワ
+  - ヲ
+  - ン
+  - ガ
+  - ギ
+  - グ
+  - ゲ
+  - ゴ
+  - ザ
+  - ジ
+  - ズ
+  - ゼ
+  - ゾ
+  - ダ
+  - ヂ
+  - ヅ
+  - デ
+  - ド
+  - バ
+  - ビ
+  - ブ
+  - ベ
+  - ボ
+  - パ
+  - ピ
+  - プ
+  - ペ
+  - ポ
+  - ァ
+  - ィ
+  - ゥ
+  - ェ
+  - ォ
+  - ッ
+  - ャ
+  - ュ
+  - ョ
+  - ヮ
+  - ヵ
+  - ヶ
+  - ヷ
+  - ヸ
+  - ヹ
+  - ヺ
+  - ・
+  - ー
+  - ヽ
+  - ヾ
+  - ヿ
+  - ｱ
+  - ｲ
+  - ｳ
+  - ｴ
+  - ｵ
+  - ｶ
+  - ｷ
+  - ｸ
+  - ｹ
+  - ｺ
+  - ｻ
+  - ｼ
+  - ｽ
+  - ｾ
+  - ｿ
+  - ﾀ
+  - ﾁ
+  - ﾂ
+  - ﾃ
+  - ﾄ
+  - ﾅ
+  - ﾆ
+  - ﾇ
+  - ﾈ
+  - ﾉ
+  - ﾊ
+  - ﾋ
+  - ﾌ
+  - ﾍ
+  - ﾎ
+  - ﾏ
+  - ﾐ
+  - ﾑ
+  - ﾒ
+  - ﾓ
+  - ﾔ
+  - ﾕ
+  - ﾖ
+  - ﾗ
+  - ﾘ
+  - ﾙ
+  - ﾚ
+  - ﾛ
+  - ﾜ
+  - ｦ
+  - ﾝ
+  - ﾞ
+  - ﾟ
+  - ｧ
+  - ｨ
+  - ｩ
+  - ｪ
+  - ｫ
+  - ｯ
+  - ｬ
+  - ｭ
+  - ｮ
+  - 円
+  - 気
+  - 糸
+  - 絵
+  - 楽
+  - 帰
+  - 戸
+  - 広
+  - 黒
+  - 図
+  - 線
+  - 読
+  - 売
+  - 歩
+  - 毎
+  - 亜
+  - 悪
+  - 圧
+  - 扱
+  - 囲
+  - 為
+  - 壱
+  - 隠
+  - 栄
+  - 営
+  - 駅
+  - 塩
+  - 縁
+  - 艶
+  - 応
+  - 桜
+  - 穏
+  - 仮
+  - 価
+  - 箇
+  - ゑ
+  - ゝ
+  - ゞ
+  - ヰ
+  - ヴ
+  - ㈱
+  - 両
+  - 丼
+  - 丿
+  - 亀
+  - 仏
+  - 伝
+  - 侶
+  - 俤
+  - 値
+  - 倶
+  - 倹
+  - 偐
+  - 偽
+  - 働
+  - 儛
+  - 兌
+  - 児
+  - 冑
+  - 冨
+  - 凞
+  - 処
+  - 凪
+  - 別
+  - 剣
+  - 剤
+  - 剰
+  - 劔
+  - 労
+  - 勧
+  - 勲
+  - 匁
+  - 匂
+  - 匲
+  - 卍
+  - 単
+  - 厳
+  - 収
+  - 呂
+  - 呉
+  - 呑
+  - 呰
+  - 唖
+  - 喚
+  - 喩
+  - 喰
+  - 噛
+  - 噺
+  - 嚢
+  - 囃
+  - 団
+  - 圀
+  - 圏
+  - 堀
+  - 堺
+  - 塀
+  - 塁
+  - 塙
+  - 増
+  - 墺
+  - 壊
+  - 壌
+  - 壷
+  - 変
+  - 奨
+  - 姫
+  - 娯
+  - 嫐
+  - 嬢
+  - 嬾
+  - 孁
+  - 宍
+  - 実
+  - 宮
+  - 寔
+  - 寛
+  - 対
+  - 専
+  - 尭
+  - 峠
+  - 崋
+  - 嶋
+  - 巀
+  - 巌
+  - 巣
+  - 巻
+  - 帯
+  - 幇
+  - 庁
+  - 廃
+  - 廻
+  - 弉
+  - 弌
+  - 弐
+  - 弖
+  - 弾
+  - 従
+  - 徳
+  - 徴
+  - 忯
+  - 恵
+  - 悩
+  - 惣
+  - 懐
+  - 懽
+  - 戦
+  - 戯
+  - 戻
+  - 払
+  - 抜
+  - 択
+  - 拝
+  - 拠
+  - 拡
+  - 拵
+  - 挙
+  - 挿
+  - 捗
+  - 捜
+  - 掟
+  - 掲
+  - 掻
+  - 揃
+  - 換
+  - 揺
+  - 摂
+  - 撃
+  - 撹
+  - 斉
+  - 斎
+  - 旛
+  - 旡
+  - 晧
+  - 晩
+  - 暁
+  - 暦
+  - 曽
+  - 杁
+  - 杢
+  - 杣
+  - 杮
+  - 枓
+  - 枠
+  - 枡
+  - 柾
+  - 栂
+  - 栃
+  - 桝
+  - 桟
+  - 桾
+  - 梛
+  - 梱
+  - 梲
+  - 梶
+  - 椙
+  - 検
+  - 椥
+  - 楕
+  - 楡
+  - 楢
+  - 榊
+  - 榎
+  - 槇
+  - 様
+  - 槙
+  - 槻
+  - 樋
+  - 権
+  - 樫
+  - 橿
+  - 檥
+  - 欅
+  - 歎
+  - 歓
+  - 歯
+  - 歳
+  - 歴
+  - 毀
+  - 沖
+  - 沢
+  - 浄
+  - 涙
+  - 済
+  - 渉
+  - 渋
+  - 渓
+  - 渕
+  - 満
+  - 滝
+  - 漑
+  - 潅
+  - 澁
+  - 瀞
+  - 瀬
+  - 焔
+  - 焼
+  - 煇
+  - 煕
+  - 煥
+  - 燗
+  - 爼
+  - 犠
+  - 狛
+  - 猟
+  - 獏
+  - 獣
+  - 珊
+  - 瑤
+  - 甞
+  - 畑
+  - 畠
+  - 畳
+  - 畷
+  - 畺
+  - 痩
+  - 癪
+  - 発
+  - 県
+  - 眞
+  - 砕
+  - 碕
+  - 礒
+  - 禖
+  - 禿
+  - 稲
+  - 穂
+  - 穣
+  - 竃
+  - 竜
+  - 竴
+  - 笹
+  - 筈
+  - 筬
+  - 筰
+  - 箆
+  - 箏
+  - 箙
+  - 篠
+  - 篭
+  - 簺
+  - 籾
+  - 粂
+  - 粋
+  - 粛
+  - 粧
+  - 糺
+  - 紬
+  - 絁
+  - 経
+  - 絖
+  - 絣
+  - 絽
+  - 継
+  - 続
+  - 綟
+  - 総
+  - 縄
+  - 縅
+  - 縒
+  - 縦
+  - 繊
+  - 繋
+  - 繍
+  - 繝
+  - 繧
+  - 纐
+  - 纒
+  - 罠
+  - 罧
+  - 罵
+  - 羂
+  - 羇
+  - 羨
+  - 聟
+  - 聡
+  - 聨
+  - 聴
+  - 脇
+  - 脳
+  - 膣
+  - 膵
+  - 臈
+  - 臓
+  - 臥
+  - 舎
+  - 舖
+  - 舗
+  - 舘
+  - 芿
+  - 苅
+  - 茲
+  - 荊
+  - 荘
+  - 莬
+  - 莵
+  - 菫
+  - 萠
+  - 蔵
+  - 薗
+  - 薫
+  - 薬
+  - 薭
+  - 蘊
+  - 蛍
+  - 蝋
+  - 蝿
+  - 蟷
+  - 衞
+  - 衵
+  - 袙
+  - 袞
+  - 袰
+  - 袴
+  - 袿
+  - 裃
+  - 裡
+  - 裲
+  - 褄
+  - 褌
+  - 襴
+  - 襷
+  - 覗
+  - 覚
+  - 覧
+  - 観
+  - 訳
+  - 証
+  - 諌
+  - 諚
+  - 諟
+  - 諡
+  - 諮
+  - 譛
+  - 譲
+  - 讃
+  - 豅
+  - 豊
+  - 豎
+  - 賎
+  - 賛
+  - 贔
+  - 躙
+  - 躰
+  - 転
+  - 軽
+  - 輌
+  - 辥
+  - 辺
+  - 辻
+  - 込
+  - 逓
+  - 遅
+  - 遙
+  - 邉
+  - 郷
+  - 酔
+  - 醗
+  - 醤
+  - 醸
+  - 釈
+  - 鉄
+  - 鉇
+  - 鉤
+  - 鉱
+  - 鉾
+  - 銈
+  - 銕
+  - 銭
+  - 鋲
+  - 鋳
+  - 鋺
+  - 錆
+  - 錍
+  - 錣
+  - 錬
+  - 錵
+  - 鍑
+  - 鍮
+  - 鍼
+  - 鎌
+  - 鎗
+  - 鎚
+  - 鎹
+  - 鐇
+  - 鐚
+  - 鐡
+  - 鑁
+  - 鑑
+  - 鑚
+  - 鑢
+  - 閇
+  - 関
+  - 閦
+  - 闘
+  - 陥
+  - 険
+  - 隣
+  - 隷
+  - 雑
+  - 雫
+  - 霊
+  - 靜
+  - 靫
+  - 靭
+  - 靱
+  - 鞄
+  - 鞆
+  - 頚
+  - 頬
+  - 頴
+  - 頼
+  - 顕
+  - 顗
+  - 餝
+  - 饂
+  - 駄
+  - 駆
+  - 駈
+  - 騒
+  - 験
+  - 騨
+  - 髄
+  - 髙
+  - 髪
+  - 髷
+  - 鯖
+  - 鯰
+  - 鯱
+  - 鰒
+  - 鰯
+  - 鰰
+  - 鳰
+  - 鴎
+  - 鴫
+  - 鵄
+  - 鵞
+  - 鵺
+  - 鶏
+  - 鹸
+  - 麁
+  - 麺
+  - 麿
+  - 黌
+  - 黙
+  - 鼈
+  - 齢
+  - 龗
+  - 縯
+  - 蟅
+  - 坖
+  - 祂
+  - 鼂
+  - 鱚
+  - 蛻
+  - 屌
+  - 呾
+  - 煔
+  - 吶
+  - 扥
+  - 蚖
+  - 銂
+  - 尃
+  - 夋
+  - 鵼
+  - 徬
+  - 寳
+  - 彡
+  - 舨
+  - 湳
+  - 麼
+  - 鍈
+  - 崈
+  - 鱣
+  - 盺
+  - 拺
+  - 瑥
+  - 茷
+  - 焻
+  - 奀
+  - 驎
+  - 鱰
+  - 砢
+  - 痟
+  - 廱
+  - 僜
+  - 瘺
+  - 鱊
+  - 擥
+  - 嶰
+  - 淓
+  - 跅
+  - 浵
+  - 媗
+  - 璦
+  - 煠
+  - 檊
+  - 媃
+  - 峅
+  - 躄
+  - 鉟
+  - 塽
+  - 蟴
+  - 鯮
+  - 弍
+  - 烒
+  - 鵵
+  - 妑
+  - 孋
+  - 蚡
+  - 恊
+  - 輭
+  - 廞
+  - 產
+  - 曅
+  - 盜
+  - 騤
+  - 囪
+  - 鱀
+  - 茇
+  - 葊
+  - 逹
+  - 狓
+  - 崢
+  - 趖
+  - 凃
+  - 羙
+  - 鮸
+  - 昞
+  - 楿
+  - 渽
+  - 圗
+  - 麪
+  - 屇
+  - 鍉
+  - 葝
+  - 沯
+  - 爭
+  - 幵
+  - 筭
+  - 寊
+  - 銋
+  - 貮
+  - 鎭
+  - 熺
+  - 昜
+  - 鍱
+  - 墬
+  - 愒
+  - 磺
+  - 嚈
+  - 稘
+  - 珮
+  - 釆
+  - 殑
+  - 鍩
+  - 䲁
+  - 蕷
+  - 鐿
+  - 僡
+  - 佹
+  - 輶
+  - 冴
+  - 襶
+  - 賔
+  - 猙
+  - 辧
+  - 絛
+  - 磾
+  - 韁
+  - 螔
+  - 譳
+  - 礑
+  - 鋱
+  - 魩
+  - 嚗
+  - 棆
+  - 牆
+  - 敟
+  - 柶
+  - 瓛
+  - 魣
+  - 巎
+  - 轘
+  - 襌
+  - 枼
+  - 鸌
+  - 逺
+  - 錏
+  - 縡
+  - 帢
+  - 騄
+  - 媼
+  - 埅
+  - 鄤
+  - 萐
+  - 祙
+  - 旼
+  - 詥
+  - 鶲
+  - 燉
+  - 卲
+  - 銱
+  - 庲
+  - 伱
+  - 氽
+  - 嵿
+  - 挻
+  - 煵
+  - 窋
+  - 鐤
+  - 鮊
+  - 鱬
+  - 鰧
+  - 嬤
+  - 譞
+  - 諲
+  - 脭
+  - 悳
+  - 崘
+  - 阭
+  - 內
+  - 袾
+  - 冚
+  - 壐
+  - 咗
+  - 礠
+  - 孮
+  - 痲
+  - 埈
+  - 肹
+  - 鰮
+  - 鮓
+  - 濊
+  - 塜
+  - 凜
+  - 蒢
+  - 噰
+  - 桼
+  - 峍
+  - 焴
+  - 鶒
+  - 鋮
+  - 綠
+  - 鶹
+  - 熿
+  - 毴
+  - 咟
+  - 嘥
+  - 睺
+  - 繡
+  - 郎
+  - 瘞
+  - 鉶
+  - 蔎
+  - 秠
+  - 緤
+  - 蝀
+  - 躝
+  - 蟜
+  - 繃
+  - 囮
+  - 墫
+  - 乭
+  - 胊
+  - 濙
+  - 瘓
+  - 榣
+  - 鑛
+  - 鐫
+  - 嶴
+  - 甹
+  - 坮
+  - 銾
+  - 蒭
+  - 睜
+  - 俋
+  - 餠
+  - 榢
+  - 蓳
+  - 盋
+  - 堷
+  - 鍏
+  - 苝
+  - 巛
+  - 蚵
+  - 暏
+  - 熤
+  - 嬨
+  - 墎
+  - 鏽
+  - 戶
+  - 菺
+  - 膮
+  - 熖
+  - 睪
+  - 栜
+  - 捱
+  - 榗
+  - 鍷
+  - 曧
+  - 犽
+  - 韑
+  - 袓
+  - 䖝
+  - 焄
+  - 喦
+  - 髲
+  - 疌
+  - 㴪
+  - 侊
+  - 貐
+  - 蕅
+  - 禠
+  - 蕑
+  - 囯
+  - 暊
+  - 儞
+  - 佋
+  - 柎
+  - 㐱
+  - 鰤
+  - 苳
+  - 鱥
+  - 謤
+  - 遶
+  - 眀
+  - 鑀
+  - 羋
+  - 顏
+  - 陜
+  - 銩
+  - 黶
+  - 苼
+  - 蒤
+  - 棛
+  - 儫
+  - 咁
+  - 抦
+  - 衚
+  - 棩
+  - 焿
+  - 脫
+  - 麅
+  - 玏
+  - 埧
+  - 淸
+  - 黁
+  - 淽
+  - 彠
+  - 鮨
+  - 沜
+  - 糀
+  - 厓
+  - 楧
+  - 嶌
+  - 簹
+  - 檵
+  - 鱇
+  - 嶬
+  - 廸
+  - 卽
+  - 樀
+  - 贌
+  - 酼
+  - 籛
+  - 沒
+  - 晸
+  - 諪
+  - 蕡
+  - 妏
+  - 鄋
+  - 蒍
+  - 奧
+  - 抇
+  - 蓨
+  - 薆
+  - 鱷
+  - 巘
+  - 䝉
+  - 亰
+  - 寈
+  - 槩
+  - 誒
+  - 麴
+  - 蕟
+  - 溎
+  - 蘗
+  - 榦
+  - 斿
+  - 暟
+  - 炲
+  - 拚
+  - 娖
+  - 繖
+  - 橚
+  - 寜
+  - 爀
+  - 饟
+  - 悅
+  - 鯏
+  - 彜
+  - 眾
+  - 葯
+  - 嬝
+  - 埮
+  - 獇
+  - 馛
+  - 溙
+  - 瀦
+  - 熼
+  - 硓
+  - 鈢
+  - 樆
+  - 輬
+  - 鰜
+  - 蔘
+  - 渙
+  - 澔
+  - 嗮
+  - 旉
+  - 籜
+  - 媊
+  - 燘
+  - 儚
+  - 頹
+  - 缽
+  - 俽
+  - 逨
+  - 鱓
+  - 郞
+  - 歊
+  - 杴
+  - 珡
+  - 杋
+  - 醁
+  - 鰏
+  - 鵾
+  - 鐽
+  - 鮋
+  - 巶
+  - 荅
+  - 薾
+  - 囓
+  - 蹻
+  - 獎
+  - 禑
+  - 鎓
+  - 榲
+  - 僴
+  - 綞
+  - 尓
+  - 敭
+  - 曔
+  - 褔
+  - 鬅
+  - 亊
+  - 鏦
+  - 蓘
+  - 裬
+  - 鱲
+  - 薡
+  - 鰗
+  - 箑
+  - 鬪
+  - 縂
+  - 璸
+  - 甙
+  - 茮
+  - 辵
+  - 岻
+  - 覿
+  - 滈
+  - 鯶
+  - 鑂
+  - 囶
+  - 舺
+  - 溋
+  - 拋
+  - 菾
+  - 敾
+  - 虨
+  - 綝
+  - 蝍
+  - 醂
+  - 禨
+  - 賹
+  - 廧
+  - 絕
+  - 槗
+  - 徫
+  - 鎔
+  - 曮
+  - 蠂
+  - 捒
+  - 堈
+  - 莕
+  - 蓪
+  - 敎
+  - 禃
+  - 櫱
+  - 綧
+  - 瀶
+  - 逌
+  - 浤
+  - 碻
+  - 刄
+  - 逤
+  - 剏
+  - 氹
+  - 菈
+  - 娫
+  - 蜛
+  - 嵗
+  - 糎
+  - 螶
+  - 譓
+  - 鏳
+  - 嵙
+  - 瑊
+  - 隲
+  - 檨
+  - 緈
+  - 畵
+  - 砯
+  - 簗
+  - 彅
+  - 鰺
+  - 騋
+  - 窶
+  - 嚒
+  - 嵻
+  - 尙
+  - 頵
+  - 槰
+  - 虉
+  - 醞
+  - 巂
+  - 彔
+  - 偊
+  - 畇
+  - 鱨
+  - 妸
+  - 塲
+  - 畐
+  - 鈫
+  - 錟
+  - 磪
+  - 摠
+  - 彥
+  - 璙
+  - 囝
+  - 寗
+  - 耎
+  - 鮡
+  - 蘓
+  - 弅
+  - 焃
+  - 飥
+  - 戙
+  - 塰
+  - 儱
+  - 槺
+  - 噏
+  - 魟
+  - 禵
+  - 佧
+  - 咘
+  - 盪
+  - 瑈
+  - 鉲
+  - 睭
+  - 鏌
+  - 鼇
+  - 郋
+  - 魮
+  - 朖
+  - 滽
+  - 渃
+  - 滙
+  - 熯
+  - 醿
+  - 鎅
+  - 褀
+  - 鬬
+  - 巄
+  - 螥
+  - 眜
+  - 釚
+  - 柉
+  - 壎
+  - 峇
+  - 姸
+  - 唭
+  - 鮜
+  - 鈖
+  - 嫈
+  - 壄
+  - 洤
+  - 黃
+  - 伕
+  - 堦
+  - 嶔
+  - 鮰
+  - 鞞
+  - 漎
+  - 鉓
+  - 鮗
+  - 壴
+  - 阝
+  - 妀
+  - 矽
+  - 獢
+  - 倗
+  - 銪
+  - 鴓
+  - 橒
+  - 凈
+  - 哖
+  - 屚
+  - 偍
+  - 瑺
+  - 媯
+  - 淍
+  - 驌
+  - 椇
+  - 赬
+  - 薐
+  - 糹
+  - 碽
+  - 濲
+  - 釭
+  - 晭
+  - 纕
+  - 寖
+  - 閞
+  - 歿
+  - 呎
+  - 鶆
+  - 屄
+  - 櫿
+  - 犎
+  - 旲
+  - 㙟
+  - 龎
+  - 翜
+  - 螾
+  - 說
+  - 衜
+  - 泆
+  - 軎
+  - 鵂
+  - 荎
+  - 嚧
+  - 硂
+  - 桖
+  - 褭
+  - 筊
+  - 鰷
+  - 秳
+  - 戩
+  - 轀
+  - 鬹
+  - 飬
+  - 卋
+  - 暸
+  - 狦
+  - 搢
+  - 娋
+  - 鏴
+  - 溫
+  - 毉
+  - 淰
+  - 謩
+  - 餺
+  - 鵙
+  - 鳽
+  - 鮀
+  - 狶
+  - 氻
+  - 轝
+  - 妺
+  - 袛
+  - 蓭
+  - 梂
+  - 娛
+  - 牼
+  - 稅
+  - 兿
+  - 玾
+  - 煚
+  - 僩
+  - 鶿
+  - 鬄
+  - 崠
+  - 鉆
+  - 鯓
+  - 蚢
+  - 庀
+  - 鵟
+  - 坣
+  - 殼
+  - 悞
+  - 熅
+  - 敻
+  - 鍠
+  - 曶
+  - 愼
+  - 搳
+  - 姃
+  - 砳
+  - 槼
+  - 臞
+  - 韾
+  - 靑
+  - 鸊
+  - 薲
+  - 虛
+  - 蠄
+  - 啟
+  - 鶺
+  - 苺
+  - 滾
+  - 褞
+  - 仺
+  - 胇
+  - 憻
+  - 郳
+  - 烉
+  - 驩
+  - 冇
+  - 枖
+  - 夌
+  - 搵
+  - 匸
+  - 盨
+  - 櫾
+  - 霤
+  - 麊
+  - 貒
+  - 噓
+  - 嗢
+  - 笩
+  - 晈
+  - 冂
+  - 銳
+  - 毿
+  - 慜
+  - 囧
+  - 閜
+  - 娸
+  - 庢
+  - 壆
+  - 馯
+  - 桱
+  - 兗
+  - 葃
+  - 侅
+  - 煐
+  - 鐦
+  - 藸
+  - 鷎
+  - 嵰
+  - 逎
+  - 弒
+  - 匋
+  - 鐭
+  - 廔
+  - 砩
+  - 孆
+  - 灴
+  - 伷
+  - 兪
+  - 鴗
+  - 澯
+  - 幚
+  - 旙
+  - 勻
+  - 礽
+  - 婑
+  - 鱮
+  - 娍
+  - 銶
+  - 吳
+  - 鍟
+  - 仼
+  - 鳧
+  - 彞
+  - 娽
+  - 昛
+  - 鰼
+  - 剎
+  - 佉
+  - 鉏
+  - 偸
+  - 鰆
+  - 讙
+  - 橪
+  - 啱
+  - 岀
+  - 孻
+  - 釪
+  - 乹
+  - 鈳
+  - 漇
+  - 檦
+  - 埻
+  - 祿
+  - 爌
+  - 禇
+  - 鱵
+  - 㸃
+  - 梉
+  - 燝
+  - 霙
+  - 炁
+  - 飮
+  - 蠙
+  - 勷
+  - 鵎
+  - 儥
+  - 鐠
+  - 唻
+  - 廰
+  - 嚿
+  - 嵕
+  - 墱
+  - 紑
+  - 搖
+  - 瘜
+  - 皝
+  - 鸑
+  - 瀁
+  - 粵
+  - 撚
+  - 巑
+  - 梀
+  - 啯
+  - 眛
+  - 諴
+  - 夊
+  - 僙
+  - 鍝
+  - 裖
+  - 鮣
+  - 凬
+  - 飡
+  - 灊
+  - 橓
+  - 嫳
+  - 筳
+  - 咑
+  - 粍
+  - 瓑
+  - 璌
+  - 伃
+  - 閰
+  - 傜
+  - 黐
+  - 謢
+  - 驒
+  - 橫
+  - 蛯
+  - 寕
+  - 蠵
+  - 瞓
+  - 旳
+  - 翏
+  - 硏
+  - 寯
+  - 韡
+  - 楤
+  - 鰃
+  - 朿
+  - 侞
+  - 鵯
+  - 愨
+  - 祹
+  - 厔
+  - 丌
+  - 盩
+  - 謏
+  - 魕
+  - 啣
+  - 閱
+  - 曺
+  - 枛
+  - 罉
+  - 卐
+  - 樻
+  - 鷉
+  - 鯒
+  - 鋡
+  - 磱
+  - 枱
+  - 攴
+  - 蠷
+  - 穈
+  - 嚟
+  - 檽
+  - 趐
+  - 奐
+  - 鋐
+  - 檇
+  - 薀
+  - 峼
+  - 咭
+  - 訔
+  - 韠
+  - 鑴
+  - 鸐
+  - 唃
+  - 捦
+  - 鸜
+  - 誴
+  - 罳
+  - 璄
+  - 暃
+  - 夀
+  - 賨
+  - 鞥
+  - 鈊
+  - 灡
+  - 鮍
+  - 懮
+  - 籣
+  - 昐
+  - 陁
+  - 襾
+  - 鮠
+  - 鈏
+  - 囍
+  - 婯
+  - 艔
+  - 貭
+  - 䰾
+  - 姁
+  - 禼
+  - 堖
+  - 鋶
+  - 仛
+  - 鏷
+  - 謜
+  - 鑅
+  - 忬
+  - 蘶
+  - 謠
+  - 觙
+  - 奫
+  - 狟
+  - 泩
+  - 桙
+  - 飈
+  - 垰
+  - 啍
+  - 嚞
+  - 鯕
+  - 蒧
+  - 榞
+  - 徸
+  - 璹
+  - 揔
+  - 欉
+  - 魞
+  - 菶
+  - 玧
+  - 鳯
+  - 廍
+  - 侚
+  - 岰
+  - 岧
+  - 鋕
+  - 凵
+  - 彣
+  - 崱
+  - 媜
+  - 倢
+  - 鵐
+  - 砋
+  - 鷚
+  - 鱠
+  - 鮻
+  - 繻
+  - 摵
+  - 贓
+  - 磵
+  - 錻
+  - 痠
+  - 粩
+  - 胅
+  - 奣
+  - 塨
+  - 瀠
+  - 鸘
+  - 啚
+  - 娳
+  - 霶
+  - 壔
+  - 峚
+  - 甂
+  - 廁
+  - 覌
+  - 鰂
+  - 猳
+  - 鱻
+  - 盫
+  - 裿
+  - 杬
+  - 歛
+  - 澋
+  - 蘞
+  - 嵜
+  - 尐
+  - 旽
+  - 鉌
+  - 鎛
+  - 豿
+  - 凖
+  - 榤
+  - 禓
+  - 龝
+  - 悧
+  - 鷟
+  - 鮟
+  - 吋
+  - 喢
+  - 岪
+  - 吥
+  - 漵
+  - 頠
+  - 豔
+  - 巿
+  - 鑨
+  - 醣
+  - 熳
+  - 懍
+  - 湥
+  - 檡
+  - 韺
+  - 戱
+  - 緖
+  - 鐈
+  - 凉
+  - 緃
+  - 鮹
+  - 媐
+  - 爯
+  - 巆
+  - 褍
+  - 鐬
+  - 昍
+  - 扙
+  - 鍳
+  - 芛
+  - 蟳
+  - 嬅
+  - 糬
+  - 吔
+  - 塭
+  - 譿
+  - 冧
+  - 鏓
+  - 嶪
+  - 嗹
+  - 椵
+  - 姀
+  - 閿
+  - 褧
+  - 錞
+  - 玆
+  - 笘
+  - 篔
+  - 萡
+  - 鶡
+  - 螐
+  - 鮄
+  - 鰟
+  - 脷
+  - 啲
+  - 杤
+  - 蓚
+  - 尗
+  - 娎
+  - 殟
+  - 淥
+  - 蝚
+  - 蓧
+  - 彐
+  - 嚤
+  - 銍
+  - 囒
+  - 坶
+  - 淩
+  - 鶼
+  - 鱂
+  - 喼
+  - 燫
+  - 肏
+  - 姵
+  - 廌
+  - 禟
+  - 籝
+  - 迵
+  - 嵨
+  - 堮
+  - 蟌
+  - 憍
+  - 廕
+  - 蜑
+  - 緁
+  - 唘
+  - 竩
+  - 崙
+  - 璚
+  - 粄
+  - 栨
+  - 罈
+  - 梫
+  - 貤
+  - 藔
+  - 蜯
+  - 訁
+  - 斖
+  - 煶
+  - 馦
+  - 妠
+  - 閟
+  - 疕
+  - 夆
+  - 鎪
+  - 膥
+  - 澻
+  - 嘢
+  - 嚐
+  - 靁
+  - 鎻
+  - 鰛
+  - 穵
+  - 烋
+  - 縕
+  - 褎
+  - 疒
+  - 壠
+  - 溼
+  - 圂
+  - 咅
+  - 鯭
+  - 鯙
+  - 磘
+  - 玨
+  - 珤
+  - 朊
+  - 蚼
+  - 濶
+  - 薞
+  - 嚩
+  - 丟
+  - 嫺
+  - 鯻
+  - 椲
+  - 鰕
+  - 刂
+  - 蠘
+  - 踎
+  - 瀴
+  - 琁
+  - 鰶
+  - 瑴
+  - 肜
+  - 㐂
+  - 欥
+  - 媺
+  - 竻
+  - 讚
+  - 𣇉
+  - 裵
+  - 緜
+  - 廩
+  - 齧
+  - 叄
+  - 俌
+  - 厰
+  - 滀
+  - 錄
+  - 鷫
+  - 鯗
+  - 攞
+  - 姌
+  - 蔝
+  - 幷
+  - 縤
+  - 屻
+  - 鯃
+  - 雞
+  - 纁
+  - 嫲
+  - 嵮
+  - 屭
+  - 嶃
+  - 跩
+  - 鋗
+  - 蕢
+  - 篊
+  - 俬
+  - 淎
+  - 暻
+  - 鏻
+  - 憓
+  - 玗
+  - 溈
+  - 笭
+  - 糢
+  - 勳
+  - 閒
+  - 沍
+  - 咾
+  - 鉷
+  - 蘵
+  - 俁
+  - 崵
+  - 毸
+  - 苪
+  - 掙
+  - 鴡
+  - 萭
+  - 俴
+  - 屜
+  - 蒾
+  - 艹
+  - 剷
+  - 慍
+  - 朮
+  - 枴
+  - 氳
+  - 猓
+  - 甽
+  - 箝
+  - 譁
+  - 贗
+  - 迆
+  - 鈽
+  - 鍊
+  - 鍰
+  - 鏍
+  - 靦
+  - 餽
+  - 丮
+  - 丱
+  - 仜
+  - 仩
+  - 伬
+  - 伔
+  - 仱
+  - 伀
+  - 伻
+  - 佢
+  - 佒
+  - 侀
+  - 侇
+  - 佷
+  - 佌
+  - 佪
+  - 侐
+  - 侜
+  - 俓
+  - 侲
+  - 俉
+  - 侻
+  - 侳
+  - 俇
+  - 倅
+  - 倇
+  - 倰
+  - 倛
+  - 倳
+  - 倷
+  - 俷
+  - 倠
+  - 偯
+  - 偞
+  - 偠
+  - 偋
+  - 偝
+  - 偛
+  - 偢
+  - 偅
+  - 偟
+  - 偩
+  - 偫
+  - 傛
+  - 傔
+  - 傞
+  - 傋
+  - 傌
+  - 傎
+  - 傝
+  - 偨
+  - 傂
+  - 傽
+  - 傿
+  - 僆
+  - 傮
+  - 僄
+  - 僈
+  - 傰
+  - 僁
+  - 傱
+  - 僋
+  - 僗
+  - 僛
+  - 僪
+  - 僝
+  - 僓
+  - 僿
+  - 儃
+  - 儰
+  - 僸
+  - 僶
+  - 僾
+  - 儌
+  - 僽
+  - 儜
+  - 儓
+  - 儗
+  - 儑
+  - 儢
+  - 儤
+  - 儠
+  - 儸
+  - 儹
+  - 儽
+  - 冓
+  - 冘
+  - 冞
+  - 凊
+  - 凅
+  - 凔
+  - 刌
+  - 刉
+  - 刓
+  - 刜
+  - 刞
+  - 刵
+  - 刲
+  - 剆
+  - 刱
+  - 剉
+  - 剚
+  - 剒
+  - 剫
+  - 剭
+  - 剬
+  - 剺
+  - 剸
+  - 剻
+  - 剼
+  - 劀
+  - 劋
+  - 劖
+  - 劘
+  - 劗
+  - 劙
+  - 劦
+  - 勴
+  - 匊
+  - 匢
+  - 匰
+  - 匴
+  - 匷
+  - 匽
+  - 卌
+  - 卼
+  - 厎
+  - 厒
+  - 厗
+  - 厞
+  - 厜
+  - 厤
+  - 厬
+  - 厹
+  - 吰
+  - 吷
+  - 吪
+  - 呿
+  - 咈
+  - 呫
+  - 呺
+  - 呥
+  - 呬
+  - 呴
+  - 茍
+  - 咷
+  - 咮
+  - 咶
+  - 哅
+  - 咠
+  - 咢
+  - 唦
+  - 唗
+  - 唒
+  - 哤
+  - 唚
+  - 唈
+  - 哫
+  - 唅
+  - 唴
+  - 啢
+  - 唶
+  - 啒
+  - 啅
+  - 唌
+  - 唲
+  - 喨
+  - 喥
+  - 喭
+  - 噅
+  - 喓
+  - 喣
+  - 啽
+  - 喌
+  - 嗃
+  - 嗛
+  - 嗋
+  - 嗀
+  - 喿
+  - 喍
+  - 嗏
+  - 嗕
+  - 嗈
+  - 嘕
+  - 嘒
+  - 嗼
+  - 嘐
+  - 嘓
+  - 嘂
+  - 嗺
+  - 嘝
+  - 嘄
+  - 嗿
+  - 噈
+  - 噊
+  - 噆
+  - 噚
+  - 嘳
+  - 嘽
+  - 嘾
+  - 噮
+  - 噳
+  - 噣
+  - 噭
+  - 噞
+  - 嚌
+  - 嚍
+  - 嚃
+  - 嚘
+  - 嚜
+  - 嚫
+  - 嚪
+  - 嚬
+  - 嚲
+  - 嚵
+  - 嚽
+  - 嚾
+  - 囆
+  - 囅
+  - 囋
+  - 囗
+  - 圁
+  - 圞
+  - 圠
+  - 坁
+  - 坅
+  - 坲
+  - 坱
+  - 垀
+  - 坴
+  - 垗
+  - 垝
+  - 垔
+  - 垘
+  - 垽
+  - 垼
+  - 埢
+  - 埶
+  - 堩
+  - 堣
+  - 塈
+  - 堥
+  - 塓
+  - 塉
+  - 塯
+  - 塕
+  - 塼
+  - 墆
+  - 塿
+  - 塴
+  - 墋
+  - 塺
+  - 墝
+  - 墯
+  - 壈
+  - 墽
+  - 壖
+  - 壝
+  - 壛
+  - 壾
+  - 壿
+  - 夃
+  - 夎
+  - 夒
+  - 夗
+  - 奅
+  - 奊
+  - 奰
+  - 奲
+  - 奼
+  - 妦
+  - 妎
+  - 妢
+  - 妐
+  - 妵
+  - 姏
+  - 姎
+  - 㚷
+  - 姡
+  - 姺
+  - 姼
+  - 娭
+  - 婐
+  - 婟
+  - 婥
+  - 婓
+  - 婗
+  - 媔
+  - 媟
+  - 媢
+  - 婸
+  - 媦
+  - 媥
+  - 媬
+  - 媕
+  - 娷
+  - 嫇
+  - 嫋
+  - 媰
+  - 媻
+  - 嫮
+  - 嫥
+  - 嫢
+  - 嫛
+  - 嫿
+  - 嫴
+  - 嫷
+  - 嫶
+  - 嬎
+  - 嬓
+  - 嬐
+  - 嬲
+  - 嬽
+  - 孈
+  - 屘
+  - 孲
+  - 孷
+  - 宎
+  - 宨
+  - 寪
+  - 寍
+  - 寋
+  - 寑
+  - 寙
+  - 寠
+  - 寱
+  - 尌
+  - 尒
+  - 尟
+  - 尰
+  - 尳
+  - 屖
+  - 屔
+  - 屝
+  - 屧
+  - 屩
+  - 屮
+  - 屴
+  - 岏
+  - 岋
+  - 岉
+  - 岒
+  - 岮
+  - 岤
+  - 岯
+  - 岟
+  - 岝
+  - 峐
+  - 峌
+  - 峞
+  - 峉
+  - 峊
+  - 峬
+  - 峮
+  - 峷
+  - 崝
+  - 崨
+  - 崥
+  - 崏
+  - 崰
+  - 崣
+  - 崷
+  - 嵃
+  - 嵑
+  - 崳
+  - 崺
+  - 嵂
+  - 嵱
+  - 嵣
+  - 嵥
+  - 嵞
+  - 嶀
+  - 嵽
+  - 嶆
+  - 嵺
+  - 嵷
+  - 嶊
+  - 嶉
+  - 嶈
+  - 嵾
+  - 嶕
+  - 嶜
+  - 嶡
+  - 嶚
+  - 嶞
+  - 嶱
+  - 嶩
+  - 嶵
+  - 嶭
+  - 巃
+  - 巏
+  - 巕
+  - 巟
+  - 巹
+  - 帊
+  - 帗
+  - 帟
+  - 帣
+  - 帠
+  - 帤
+  - 帩
+  - 帾
+  - 帴
+  - 幏
+  - 幎
+  - 幓
+  - 幩
+  - 幝
+  - 幠
+  - 幧
+  - 幨
+  - 幦
+  - 幭
+  - 幰
+  - 庂
+  - 庉
+  - 庌
+  - 庈
+  - 庰
+  - 庛
+  - 庣
+  - 庨
+  - 庮
+  - 庪
+  - 庬
+  - 庴
+  - 廅
+  - 廇
+  - 廘
+  - 廗
+  - 廎
+  - 廜
+  - 緳
+  - 廦
+  - 廥
+  - 廮
+  - 廯
+  - 蠯
+  - 廾
+  - 弚
+  - 弝
+  - 弣
+  - 弤
+  - 弮
+  - 弳
+  - 彃
+  - 彉
+  - 彋
+  - 彏
+  - 彯
+  - 彴
+  - 彸
+  - 彾
+  - 徦
+  - 徥
+  - 徯
+  - 徲
+  - 徾
+  - 徿
+  - 忀
+  - 忁
+  - 忔
+  - 忕
+  - 忨
+  - 忣
+  - 忷
+  - 忥
+  - 怭
+  - 怲
+  - 怋
+  - 怴
+  - 怗
+  - 怚
+  - 怞
+  - 怬
+  - 怢
+  - 怐
+  - 怮
+  - 怓
+  - 怷
+  - 怹
+  - 恲
+  - 恞
+  - 恅
+  - 恇
+  - 恉
+  - 恛
+  - 恌
+  - 恀
+  - 恟
+  - 悀
+  - 悁
+  - 悕
+  - 悗
+  - 悇
+  - 悊
+  - 悐
+  - 悾
+  - 悺
+  - 惓
+  - 惤
+  - 惈
+  - 悷
+  - 惉
+  - 悹
+  - 惌
+  - 惢
+  - 惄
+  - 愊
+  - 愖
+  - 愅
+  - 惵
+  - 愓
+  - 惸
+  - 惼
+  - 惾
+  - 慉
+  - 慅
+  - 愶
+  - 愲
+  - 愮
+  - 愯
+  - 愬
+  - 慁
+  - 慞
+  - 慱
+  - 慒
+  - 慓
+  - 慲
+  - 憀
+  - 慴
+  - 慔
+  - 慺
+  - 慛
+  - 憃
+  - 慹
+  - 憱
+  - 憰
+  - 憢
+  - 憉
+  - 憛
+  - 憯
+  - 憟
+  - 憪
+  - 憡
+  - 憝
+  - 憖
+  - 懅
+  - 憴
+  - 懆
+  - 懁
+  - 憿
+  - 憸
+  - 憵
+  - 憼
+  - 懧
+  - 懠
+  - 懥
+  - 懤
+  - 懘
+  - 懭
+  - 懱
+  - 懪
+  - 懰
+  - 懫
+  - 懻
+  - 戁
+  - 戃
+  - 戄
+  - 戉
+  - 戠
+  - 酨
+  - 戺
+  - 扐
+  - 扜
+  - 扤
+  - 扡
+  - 扢
+  - 抆
+  - 抌
+  - 抎
+  - 抏
+  - 扻
+  - 抭
+  - 抴
+  - 拑
+  - 抾
+  - 抪
+  - 抶
+  - 抮
+  - 挍
+  - 挋
+  - 挃
+  - 拫
+  - 拹
+  - 挏
+  - 挌
+  - 拸
+  - 挀
+  - 拲
+  - 捖
+  - 挬
+  - 挶
+  - 揤
+  - 捊
+  - 挼
+  - 挩
+  - 捁
+  - 挴
+  - 捘
+  - 捔
+  - 捥
+  - 掝
+  - 掗
+  - 掫
+  - 掯
+  - 捵
+  - 掜
+  - 捼
+  - 掤
+  - 掔
+  - 掱
+  - 揎
+  - 揥
+  - 揨
+  - 揯
+  - 揊
+  - 揲
+  - 揵
+  - 摡
+  - 揟
+  - 揝
+  - 揜
+  - 揘
+  - 揅
+  - 揱
+  - 搆
+  - 搟
+  - 搕
+  - 搘
+  - 搹
+  - 搷
+  - 搣
+  - 搰
+  - 搊
+  - 搚
+  - 摀
+  - 搧
+  - 搫
+  - 摍
+  - 摝
+  - 摲
+  - 摦
+  - 摎
+  - 摋
+  - 摓
+  - 摐
+  - 摿
+  - 摮
+  - 摰
+  - 撢
+  - 撠
+  - 撗
+  - 撜
+  - 撋
+  - 撊
+  - 撌
+  - 撟
+  - 擗
+  - 擖
+  - 擏
+  - 擉
+  - 撽
+  - 擩
+  - 擣
+  - 擫
+  - 擭
+  - 擨
+  - 擽
+  - 擸
+  - 攇
+  - 攐
+  - 攍
+  - 攌
+  - 攗
+  - 攕
+  - 攓
+  - 攡
+  - 攠
+  - 攦
+  - 攩
+  - 攭
+  - 攲
+  - 攳
+  - 敁
+  - 敊
+  - 敆
+  - 敓
+  - 敧
+  - 敪
+  - 敤
+  - 敜
+  - 敯
+  - 敳
+  - 敶
+  - 敺
+  - 敹
+  - 敿
+  - 斁
+  - 斀
+  - 斄
+  - 斒
+  - 斔
+  - 斞
+  - 斨
+  - 斪
+  - 斻
+  - 旍
+  - 旓
+  - 旚
+  - 旝
+  - 旟
+  - 昲
+  - 昦
+  - 昢
+  - 晇
+  - 晥
+  - 晜
+  - 晼
+  - 晬
+  - 暀
+  - 暆
+  - 暍
+  - 暋
+  - 暡
+  - 暰
+  - 暩
+  - 曀
+  - 曊
+  - 曋
+  - 曏
+  - 曒
+  - 曚
+  - 曣
+  - 曭
+  - 朁
+  - 朅
+  - 朄
+  - 朒
+  - 朘
+  - 朣
+  - 朾
+  - 朹
+  - 朻
+  - 朼
+  - 杅
+  - 杇
+  - 杝
+  - 杗
+  - 枎
+  - 杶
+  - 枆
+  - 枌
+  - 柲
+  - 枺
+  - 枻
+  - 柸
+  - 柀
+  - 柅
+  - 柫
+  - 柤
+  - 柍
+  - 柮
+  - 柣
+  - 柂
+  - 柧
+  - 栚
+  - 桋
+  - 桏
+  - 栱
+  - 栵
+  - 栫
+  - 栭
+  - 栯
+  - 栘
+  - 栔
+  - 梡
+  - 梇
+  - 梐
+  - 桭
+  - 梮
+  - 楖
+  - 梬
+  - 梩
+  - 桵
+  - 梒
+  - 椌
+  - 椄
+  - 棜
+  - 棷
+  - 棳
+  - 棌
+  - 椈
+  - 楰
+  - 棯
+  - 椔
+  - 棸
+  - 楟
+  - 楎
+  - 楱
+  - 楅
+  - 楺
+  - 楈
+  - 楛
+  - 楉
+  - 楬
+  - 椳
+  - 楀
+  - 楄
+  - 楶
+  - 楘
+  - 榶
+  - 槉
+  - 榠
+  - 榬
+  - 榼
+  - 榙
+  - 榩
+  - 榾
+  - 榯
+  - 槄
+  - 榽
+  - 榹
+  - 槥
+  - 槸
+  - 樕
+  - 樠
+  - 槬
+  - 槢
+  - 樛
+  - 樝
+  - 槾
+  - 樧
+  - 槮
+  - 樔
+  - 槷
+  - 橀
+  - 樴
+  - 橉
+  - 橧
+  - 樲
+  - 橨
+  - 橝
+  - 橭
+  - 橶
+  - 樿
+  - 橁
+  - 檍
+  - 檖
+  - 檁
+  - 檟
+  - 橾
+  - 檛
+  - 檓
+  - 檕
+  - 檃
+  - 櫅
+  - 檹
+  - 櫡
+  - 櫠
+  - 櫌
+  - 櫑
+  - 櫙
+  - 櫋
+  - 櫜
+  - 櫐
+  - 櫫
+  - 櫬
+  - 櫰
+  - 櫹
+  - 櫺
+  - 櫼
+  - 欃
+  - 欋
+  - 欈
+  - 欐
+  - 欑
+  - 欘
+  - 欨
+  - 欴
+  - 欯
+  - 欭
+  - 欱
+  - 欶
+  - 欳
+  - 欷
+  - 欿
+  - 歂
+  - 歈
+  - 歍
+  - 歋
+  - 歕
+  - 歔
+  - 歜
+  - 歠
+  - 歭
+  - 歾
+  - 肂
+  - 殈
+  - 殏
+  - 殔
+  - 殗
+  - 殙
+  - 殠
+  - 殥
+  - 殢
+  - 殦
+  - 殧
+  - 殰
+  - 殶
+  - 毃
+  - 毄
+  - 毈
+  - 毇
+  - 毊
+  - 毚
+  - 毞
+  - 毦
+  - 毤
+  - 毨
+  - 毣
+  - 毰
+  - 毲
+  - 毻
+  - 毼
+  - 毾
+  - 氁
+  - 氀
+  - 氄
+  - 氠
+  - 氶
+  - 汃
+  - 汒
+  - 汏
+  - 汍
+  - 汸
+  - 沋
+  - 汱
+  - 汯
+  - 沕
+  - 汦
+  - 汳
+  - 泬
+  - 沶
+  - 沬
+  - 泧
+  - 沷
+  - 泭
+  - 泲
+  - 泒
+  - 沴
+  - 洟
+  - 洊
+  - 洀
+  - 浺
+  - 浶
+  - 洍
+  - 涒
+  - 浘
+  - 浢
+  - 涊
+  - 涆
+  - 浧
+  - 涗
+  - 涳
+  - 涬
+  - 淢
+  - 涷
+  - 淔
+  - 渀
+  - 淈
+  - 涾
+  - 淊
+  - 涽
+  - 淭
+  - 湆
+  - 湇
+  - 湅
+  - 湢
+  - 渿
+  - 湁
+  - 渜
+  - 渳
+  - 湀
+  - 渻
+  - 渮
+  - 湨
+  - 湡
+  - 渱
+  - 渨
+  - 湠
+  - 湱
+  - 湩
+  - 渹
+  - 溛
+  - 滖
+  - 溓
+  - 溔
+  - 滒
+  - 溰
+  - 溾
+  - 滜
+  - 滵
+  - 滱
+  - 漃
+  - 漥
+  - 漮
+  - 潎
+  - 漙
+  - 漧
+  - 漘
+  - 漒
+  - 滭
+  - 漊
+  - 潳
+  - 滮
+  - 潀
+  - 漰
+  - 潃
+  - 漅
+  - 濆
+  - 澒
+  - 澅
+  - 潚
+  - 潠
+  - 澖
+  - 潶
+  - 潬
+  - 潒
+  - 潐
+  - 潗
+  - 澓
+  - 潝
+  - 濇
+  - 濎
+  - 濈
+  - 濄
+  - 澞
+  - 澨
+  - 瀄
+  - 濌
+  - 澩
+  - 濴
+  - 濔
+  - 濣
+  - 濭
+  - 濧
+  - 濦
+  - 瀇
+  - 瀎
+  - 濿
+  - 瀀
+  - 濻
+  - 瀙
+  - 瀖
+  - 瀫
+  - 瀡
+  - 瀢
+  - 瀩
+  - 瀯
+  - 瀷
+  - 灂
+  - 瀸
+  - 瀿
+  - 瀺
+  - 灄
+  - 灉
+  - 灖
+  - 灗
+  - 灛
+  - 灟
+  - 灨
+  - 灩
+  - 灪
+  - 炾
+  - 炰
+  - 烓
+  - 烑
+  - 缹
+  - 焍
+  - 烰
+  - 焠
+  - 焮
+  - 焣
+  - 煆
+  - 煣
+  - 煝
+  - 熐
+  - 熉
+  - 熀
+  - 熂
+  - 熚
+  - 燅
+  - 燂
+  - 熸
+  - 燀
+  - 燡
+  - 爁
+  - 爊
+  - 爂
+  - 爓
+  - 爞
+  - 爢
+  - 爣
+  - 牄
+  - 牉
+  - 牋
+  - 牏
+  - 牣
+  - 牬
+  - 牰
+  - 牸
+  - 牷
+  - 犈
+  - 犉
+  - 犆
+  - 犅
+  - 犌
+  - 犑
+  - 犐
+  - 犗
+  - 犕
+  - 犓
+  - 犘
+  - 犚
+  - 犝
+  - 犞
+  - 犥
+  - 犦
+  - 犤
+  - 犣
+  - 犩
+  - 犪
+  - 犮
+  - 犵
+  - 犿
+  - 狆
+  - 狖
+  - 狋
+  - 狘
+  - 狜
+  - 狔
+  - 狚
+  - 狌
+  - 狑
+  - 狊
+  - 狤
+  - 狫
+  - 狪
+  - 狣
+  - 猀
+  - 狾
+  - 猑
+  - 猘
+  - 猈
+  - 狿
+  - 猏
+  - 猋
+  - 猒
+  - 猧
+  - 猲
+  - 猭
+  - 猦
+  - 猣
+  - 猵
+  - 猼
+  - 獂
+  - 獀
+  - 獊
+  - 獑
+  - 獌
+  - 獘
+  - 獞
+  - 獟
+  - 獝
+  - 獛
+  - 獡
+  - 獩
+  - 獦
+  - 獥
+  - 獳
+  - 獶
+  - 獽
+  - 獿
+  - 玂
+  - 玁
+  - 玈
+  - 玊
+  - 玔
+  - 珓
+  - 珶
+  - 琖
+  - 瑵
+  - 璊
+  - 瑽
+  - 璅
+  - 瑿
+  - 璗
+  - 瓁
+  - 瓋
+  - 瓝
+  - 瓟
+  - 瓡
+  - 瓥
+  - 瓨
+  - 瓬
+  - 瓵
+  - 瓾
+  - 瓽
+  - 甀
+  - 甃
+  - 甈
+  - 甋
+  - 甐
+  - 甒
+  - 甔
+  - 甖
+  - 甝
+  - 甮
+  - 甿
+  - 畟
+  - 畣
+  - 畽
+  - 疀
+  - 疧
+  - 痁
+  - 疻
+  - 痀
+  - 痎
+  - 痏
+  - 痋
+  - 痌
+  - 痑
+  - 痚
+  - 痡
+  - 痝
+  - 痗
+  - 痯
+  - 瘏
+  - 痷
+  - 痸
+  - 痻
+  - 瘈
+  - 瘑
+  - 瘝
+  - 瘣
+  - 瘯
+  - 瘱
+  - 瘽
+  - 癈
+  - 癉
+  - 癙
+  - 癐
+  - 癓
+  - 癠
+  - 癵
+  - 癹
+  - 皊
+  - 皏
+  - 皫
+  - 皯
+  - 皵
+  - 皻
+  - 皽
+  - 皾
+  - 盄
+  - 盓
+  - 盝
+  - 盬
+  - 盭
+  - 盳
+  - 眃
+  - 眅
+  - 盻
+  - 眝
+  - 眐
+  - 眓
+  - 眒
+  - 眣
+  - 眑
+  - 眕
+  - 眹
+  - 眱
+  - 眲
+  - 眴
+  - 眳
+  - 眽
+  - 睆
+  - 睅
+  - 睊
+  - 睋
+  - 睌
+  - 睕
+  - 睟
+  - 睒
+  - 睖
+  - 睩
+  - 睧
+  - 睔
+  - 瞁
+  - 睼
+  - 瞂
+  - 睮
+  - 睯
+  - 瞏
+  - 瞉
+  - 瞚
+  - 瞝
+  - 瞡
+  - 瞛
+  - 瞲
+  - 瞷
+  - 瞶
+  - 瞴
+  - 矂
+  - 矉
+  - 矊
+  - 矌
+  - 矎
+  - 矏
+  - 矐
+  - 矔
+  - 矕
+  - 矘
+  - 矠
+  - 矱
+  - 矲
+  - 矹
+  - 矺
+  - 砅
+  - 砐
+  - 砏
+  - 砎
+  - 砨
+  - 硈
+  - 硉
+  - 硠
+  - 硥
+  - 硱
+  - 硰
+  - 硩
+  - 碔
+  - 碄
+  - 碅
+  - 碆
+  - 硾
+  - 碫
+  - 碞
+  - 磍
+  - 磌
+  - 磎
+  - 磈
+  - 磃
+  - 磝
+  - 磩
+  - 磥
+  - 磞
+  - 磛
+  - 磳
+  - 磼
+  - 磿
+  - 礔
+  - 礉
+  - 礝
+  - 礛
+  - 礜
+  - 礥
+  - 礣
+  - 礧
+  - 礨
+  - 礭
+  - 礿
+  - 祌
+  - 祅
+  - 祔
+  - 祒
+  - 祑
+  - 祤
+  - 祩
+  - 祪
+  - 祣
+  - 祫
+  - 祡
+  - 祴
+  - 祳
+  - 禂
+  - 禗
+  - 禜
+  - 禫
+  - 禭
+  - 禬
+  - 禴
+  - 禷
+  - 禸
+  - 歶
+  - 秅
+  - 秏
+  - 秖
+  - 秎
+  - 秮
+  - 秪
+  - 秺
+  - 秶
+  - 稊
+  - 稒
+  - 稫
+  - 穊
+  - 稰
+  - 稯
+  - 穋
+  - 穛
+  - 穖
+  - 穧
+  - 穨
+  - 穮
+  - 穬
+  - 穭
+  - 穱
+  - 穾
+  - 窆
+  - 窉
+  - 窌
+  - 窏
+  - 窔
+  - 窐
+  - 窙
+  - 窢
+  - 窞
+  - 窫
+  - 窲
+  - 窴
+  - 窱
+  - 窾
+  - 竀
+  - 竁
+  - 竷
+  - 笐
+  - 笓
+  - 笅
+  - 笵
+  - 笻
+  - 笴
+  - 笰
+  - 笢
+  - 笝
+  - 笲
+  - 筄
+  - 筡
+  - 箈
+  - 箊
+  - 箌
+  - 箛
+  - 箎
+  - 箘
+  - 箄
+  - 箷
+  - 箾
+  - 篎
+  - 箯
+  - 箹
+  - 篞
+  - 篣
+  - 篧
+  - 篕
+  - 篨
+  - 篹
+  - 簅
+  - 篲
+  - 篿
+  - 篻
+  - 簎
+  - 篴
+  - 簂
+  - 簁
+  - 篸
+  - 篽
+  - 簜
+  - 簩
+  - 簙
+  - 簭
+  - 簦
+  - 簨
+  - 簢
+  - 簥
+  - 簳
+  - 簼
+  - 簬
+  - 簻
+  - 籉
+  - 籈
+  - 籊
+  - 籔
+  - 籗
+  - 籧
+  - 籦
+  - 籯
+  - 籺
+  - 籸
+  - 籹
+  - 粊
+  - 粔
+  - 粻
+  - 糔
+  - 糪
+  - 糱
+  - 糷
+  - 紎
+  - 紟
+  - 紒
+  - 紽
+  - 紸
+  - 紶
+  - 紩
+  - 絇
+  - 紾
+  - 絘
+  - 絯
+  - 絓
+  - 絧
+  - 絏
+  - 絭
+  - 絫
+  - 綀
+  - 綍
+  - 絿
+  - 綅
+  - 絻
+  - 絼
+  - 綔
+  - 綷
+  - 緂
+  - 綪
+  - 緀
+  - 緅
+  - 緎
+  - 緆
+  - 緌
+  - 綯
+  - 綼
+  - 緷
+  - 緛
+  - 緪
+  - 緧
+  - 縃
+  - 緺
+  - 緶
+  - 緰
+  - 縗
+  - 縌
+  - 縓
+  - 縎
+  - 縜
+  - 縚
+  - 縏
+  - 縼
+  - 繂
+  - 縳
+  - 顈
+  - 繈
+  - 縸
+  - 縪
+  - 繉
+  - 繀
+  - 縩
+  - 緵
+  - 縰
+  - 縿
+  - 縶
+  - 繜
+  - 繐
+  - 繣
+  - 繘
+  - 繢
+  - 繟
+  - 繑
+  - 繠
+  - 繶
+  - 繵
+  - 繸
+  - 繷
+  - 繺
+  - 繲
+  - 繴
+  - 纀
+  - 纇
+  - 纋
+  - 纆
+  - 纑
+  - 纗
+  - 纚
+  - 缿
+  - 罊
+  - 罏
+  - 罜
+  - 罞
+  - 罝
+  - 罛
+  - 罣
+  - 罥
+  - 罦
+  - 罭
+  - 罫
+  - 罬
+  - 罻
+  - 罼
+  - 罺
+  - 罿
+  - 羃
+  - 羉
+  - 羍
+  - 羒
+  - 羜
+  - 羛
+  - 羢
+  - 羠
+  - 羦
+  - 羬
+  - 羭
+  - 羵
+  - 羳
+  - 羷
+  - 羺
+  - 羾
+  - 翋
+  - 翍
+  - 翐
+  - 翑
+  - 翇
+  - 翢
+  - 翣
+  - 翭
+  - 翪
+  - 翨
+  - 翴
+  - 翲
+  - 翽
+  - 翿
+  - 耟
+  - 耞
+  - 耡
+  - 耴
+  - 耾
+  - 耹
+  - 聇
+  - 聈
+  - 聑
+  - 聏
+  - 聝
+  - 肕
+  - 肙
+  - 肒
+  - 肣
+  - 肵
+  - 胘
+  - 胑
+  - 胐
+  - 胕
+  - 胉
+  - 胏
+  - 胹
+  - 胵
+  - 脁
+  - 胻
+  - 脀
+  - 胾
+  - 胔
+  - 脰
+  - 脥
+  - 脤
+  - 脙
+  - 脡
+  - 脕
+  - 脧
+  - 腃
+  - 腏
+  - 腄
+  - 腇
+  - 脽
+  - 腍
+  - 腤
+  - 腷
+  - 腜
+  - 腛
+  - 腢
+  - 腲
+  - 朡
+  - 腞
+  - 腶
+  - 膉
+  - 膆
+  - 膃
+  - 膇
+  - 膍
+  - 膌
+  - 膋
+  - 膟
+  - 膕
+  - 膢
+  - 膱
+  - 膹
+  - 膫
+  - 膰
+  - 膬
+  - 膴
+  - 膲
+  - 臇
+  - 膷
+  - 臄
+  - 臅
+  - 臒
+  - 臐
+  - 臗
+  - 臛
+  - 臡
+  - 臦
+  - 臩
+  - 臮
+  - 臲
+  - 臷
+  - 臸
+  - 臿
+  - 舋
+  - 舑
+  - 舕
+  - 舝
+  - 舡
+  - 舼
+  - 舽
+  - 艀
+  - 艂
+  - 艓
+  - 艒
+  - 艐
+  - 艑
+  - 艕
+  - 艛
+  - 艵
+  - 艼
+  - 芀
+  - 芐
+  - 芅
+  - 芓
+  - 芔
+  - 苀
+  - 芚
+  - 芵
+  - 芧
+  - 芞
+  - 芺
+  - 苙
+  - 苨
+  - 苖
+  - 苬
+  - 苲
+  - 苵
+  - 苶
+  - 茙
+  - 茥
+  - 茿
+  - 茦
+  - 茢
+  - 荂
+  - 茪
+  - 荍
+  - 茖
+  - 茤
+  - 茠
+  - 茩
+  - 茻
+  - 莐
+  - 莣
+  - 莍
+  - 荺
+  - 莤
+  - 荴
+  - 莏
+  - 莁
+  - 荵
+  - 莔
+  - 莃
+  - 莌
+  - 莋
+  - 荾
+  - 莥
+  - 菨
+  - 萒
+  - 菧
+  - 菤
+  - 菆
+  - 菣
+  - 菿
+  - 菋
+  - 菎
+  - 菵
+  - 萉
+  - 菞
+  - 菳
+  - 菕
+  - 蓱
+  - 萿
+  - 葹
+  - 葥
+  - 葀
+  - 葧
+  - 萰
+  - 葍
+  - 葽
+  - 蔇
+  - 葞
+  - 萷
+  - 萺
+  - 萴
+  - 葅
+  - 菙
+  - 葋
+  - 萯
+  - 葂
+  - 葟
+  - 葌
+  - 蓎
+  - 蒬
+  - 蒮
+  - 蒫
+  - 蒪
+  - 蒚
+  - 蒝
+  - 蓌
+  - 蒛
+  - 蒩
+  - 蒘
+  - 蒶
+  - 蒠
+  - 蔤
+  - 蔏
+  - 蔩
+  - 蔉
+  - 蔍
+  - 蔧
+  - 蔜
+  - 蓻
+  - 蓺
+  - 蓴
+  - 蔪
+  - 蓲
+  - 蓷
+  - 蓫
+  - 蔒
+  - 蓩
+  - 蔖
+  - 蓾
+  - 蔨
+  - 蔮
+  - 蔂
+  - 蓶
+  - 蔱
+  - 蓹
+  - 蔠
+  - 蔰
+  - 蕫
+  - 蕍
+  - 蕀
+  - 蕆
+  - 蕄
+  - 蕇
+  - 蕣
+  - 蕛
+  - 蕱
+  - 蕵
+  - 蕮
+  - 蕧
+  - 蕠
+  - 蕦
+  - 蕝
+  - 薃
+  - 薧
+  - 薕
+  - 薠
+  - 薋
+  - 薣
+  - 薚
+  - 蕼
+  - 薉
+  - 蕸
+  - 薎
+  - 薖
+  - 薍
+  - 薝
+  - 薂
+  - 藆
+  - 藀
+  - 藃
+  - 藂
+  - 薵
+  - 薽
+  - 藇
+  - 藄
+  - 藋
+  - 藈
+  - 藅
+  - 薱
+  - 薶
+  - 藒
+  - 藫
+  - 藱
+  - 藙
+  - 藡
+  - 藚
+  - 藗
+  - 藲
+  - 藬
+  - 藘
+  - 藣
+  - 藑
+  - 藰
+  - 蘁
+  - 藾
+  - 蘛
+  - 蘉
+  - 蘌
+  - 蘪
+  - 蘦
+  - 蘟
+  - 蘣
+  - 蘜
+  - 蘙
+  - 蘮
+  - 蘡
+  - 蘠
+  - 蘥
+  - 蘴
+  - 蘳
+  - 蘬
+  - 虀
+  - 蘹
+  - 蘱
+  - 蘻
+  - 蘾
+  - 虃
+  - 虆
+  - 虇
+  - 虈
+  - 虌
+  - 虋
+  - 虙
+  - 虡
+  - 虣
+  - 虩
+  - 虪
+  - 虰
+  - 虭
+  - 虴
+  - 蚑
+  - 蚞
+  - 蚇
+  - 蚗
+  - 蚚
+  - 蚅
+  - 蚥
+  - 蚙
+  - 蚿
+  - 蚷
+  - 蛂
+  - 蛁
+  - 蛅
+  - 蛈
+  - 蚹
+  - 蚳
+  - 蚸
+  - 蛌
+  - 蚻
+  - 蛢
+  - 蛦
+  - 蛓
+  - 蛣
+  - 蛚
+  - 蛪
+  - 蛝
+  - 蛫
+  - 蛜
+  - 蛬
+  - 蛗
+  - 蜄
+  - 蛷
+  - 蜌
+  - 蛖
+  - 蛵
+  - 蜁
+  - 蛶
+  - 蜳
+  - 蝫
+  - 蜙
+  - 蝃
+  - 蜬
+  - 蝁
+  - 蝆
+  - 蜠
+  - 蜲
+  - 蜪
+  - 蜭
+  - 蜼
+  - 蜵
+  - 蝂
+  - 蜦
+  - 蜧
+  - 蜸
+  - 蜤
+  - 蜰
+  - 蝖
+  - 蝷
+  - 蟡
+  - 蝳
+  - 蝔
+  - 蝛
+  - 蝒
+  - 蝑
+  - 蝞
+  - 蝭
+  - 蝪
+  - 蝐
+  - 蝝
+  - 蝬
+  - 蝺
+  - 蝜
+  - 螛
+  - 螏
+  - 螓
+  - 螒
+  - 螁
+  - 螖
+  - 螘
+  - 蝹
+  - 螇
+  - 螑
+  - 螝
+  - 螜
+  - 螚
+  - 螪
+  - 螰
+  - 螹
+  - 螼
+  - 螮
+  - 蟉
+  - 蟃
+  - 蟂
+  - 螷
+  - 螴
+  - 螿
+  - 螸
+  - 蟞
+  - 蟧
+  - 蟦
+  - 蟢
+  - 蟟
+  - 蟤
+  - 蟔
+  - 蟓
+  - 蟭
+  - 蟘
+  - 螤
+  - 蟗
+  - 蟙
+  - 蠁
+  - 蟨
+  - 蠀
+  - 蟺
+  - 蠉
+  - 蠌
+  - 蟼
+  - 蠈
+  - 蟿
+  - 蠗
+  - 蠩
+  - 蠝
+  - 蠛
+  - 蠠
+  - 蠤
+  - 蠜
+  - 蠫
+  - 蠬
+  - 蠨
+  - 蠦
+  - 蠪
+  - 蠥
+  - 蠰
+  - 蠮
+  - 蠳
+  - 蠸
+  - 蠾
+  - 蠽
+  - 蠿
+  - 衁
+  - 衈
+  - 衋
+  - 衧
+  - 衪
+  - 衭
+  - 衶
+  - 袀
+  - 衱
+  - 衯
+  - 袃
+  - 袉
+  - 袕
+  - 袨
+  - 袚
+  - 袑
+  - 袡
+  - 袘
+  - 袧
+  - 袬
+  - 袌
+  - 袺
+  - 裗
+  - 袹
+  - 袸
+  - 裀
+  - 袶
+  - 袽
+  - 袲
+  - 裋
+  - 裍
+  - 裞
+  - 裚
+  - 裷
+  - 裧
+  - 裺
+  - 裮
+  - 裶
+  - 裯
+  - 裻
+  - 褁
+  - 褅
+  - 褋
+  - 褗
+  - 褆
+  - 褖
+  - 褑
+  - 褦
+  - 褮
+  - 褱
+  - 褢
+  - 褩
+  - 褵
+  - 褼
+  - 褾
+  - 襒
+  - 褷
+  - 襂
+  - 褽
+  - 襓
+  - 襋
+  - 襆
+  - 襐
+  - 襛
+  - 襗
+  - 襡
+  - 襘
+  - 襝
+  - 襣
+  - 襭
+  - 襩
+  - 襮
+  - 襳
+  - 襹
+  - 襺
+  - 覂
+  - 覅
+  - 覕
+  - 覛
+  - 覝
+  - 覢
+  - 覤
+  - 覣
+  - 覭
+  - 覮
+  - 覶
+  - 觓
+  - 觤
+  - 觡
+  - 觠
+  - 觢
+  - 觩
+  - 觰
+  - 觬
+  - 觲
+  - 觷
+  - 觺
+  - 觻
+  - 觼
+  - 觾
+  - 訑
+  - 訰
+  - 訧
+  - 訬
+  - 訞
+  - 詍
+  - 訹
+  - 詙
+  - 詀
+  - 詄
+  - 詅
+  - 訿
+  - 誂
+  - 詻
+  - 誃
+  - 誫
+  - 誙
+  - 誋
+  - 諆
+  - 誸
+  - 諔
+  - 諕
+  - 誻
+  - 諀
+  - 諅
+  - 諵
+  - 諝
+  - 諰
+  - 諈
+  - 謞
+  - 謘
+  - 謑
+  - 謋
+  - 謒
+  - 謕
+  - 謍
+  - 謈
+  - 謪
+  - 謧
+  - 謣
+  - 謰
+  - 謵
+  - 譇
+  - 謯
+  - 謱
+  - 謥
+  - 謷
+  - 謦
+  - 譐
+  - 譈
+  - 譊
+  - 譀
+  - 譋
+  - 譕
+  - 譑
+  - 譠
+  - 譪
+  - 譝
+  - 譨
+  - 譣
+  - 譥
+  - 譹
+  - 譸
+  - 譅
+  - 譺
+  - 譻
+  - 譾
+  - 讄
+  - 讂
+  - 讆
+  - 讋
+  - 讔
+  - 讘
+  - 讟
+  - 谹
+  - 谻
+  - 谽
+  - 谾
+  - 豃
+  - 豋
+  - 豍
+  - 豏
+  - 豗
+  - 豜
+  - 豝
+  - 豟
+  - 豥
+  - 豤
+  - 豦
+  - 豭
+  - 豰
+  - 豲
+  - 豱
+  - 豯
+  - 豵
+  - 豷
+  - 豶
+  - 豻
+  - 豽
+  - 貁
+  - 貀
+  - 貄
+  - 貏
+  - 貑
+  - 貕
+  - 貙
+  - 貗
+  - 貜
+  - 貣
+  - 貾
+  - 賌
+  - 賥
+  - 賟
+  - 賙
+  - 賵
+  - 賮
+  - 贆
+  - 贕
+  - 贙
+  - 赨
+  - 赩
+  - 赮
+  - 赸
+  - 趀
+  - 趌
+  - 趎
+  - 趏
+  - 趍
+  - 趓
+  - 趠
+  - 趜
+  - 趡
+  - 趥
+  - 趧
+  - 趬
+  - 趪
+  - 趭
+  - 趫
+  - 趮
+  - 趷
+  - 趹
+  - 跘
+  - 跓
+  - 跍
+  - 跇
+  - 跜
+  - 跕
+  - 跙
+  - 跈
+  - 跰
+  - 跠
+  - 跮
+  - 跦
+  - 跢
+  - 跧
+  - 跲
+  - 跫
+  - 踂
+  - 跿
+  - 踍
+  - 踃
+  - 踇
+  - 踆
+  - 跾
+  - 踠
+  - 踥
+  - 踤
+  - 踡
+  - 踕
+  - 踛
+  - 踖
+  - 踑
+  - 踙
+  - 踧
+  - 踘
+  - 踓
+  - 踳
+  - 踾
+  - 踸
+  - 踼
+  - 蹎
+  - 蹍
+  - 蹓
+  - 蹗
+  - 蹖
+  - 蹞
+  - 蹥
+  - 蹛
+  - 蹡
+  - 蹝
+  - 蹔
+  - 蹸
+  - 蹳
+  - 蹪
+  - 躆
+  - 躈
+  - 躖
+  - 躗
+  - 躟
+  - 躠
+  - 躤
+  - 躣
+  - 躩
+  - 躨
+  - 躽
+  - 軓
+  - 軘
+  - 軞
+  - 軯
+  - 軷
+  - 軦
+  - 軮
+  - 軥
+  - 軵
+  - 軧
+  - 軨
+  - 軶
+  - 軱
+  - 軬
+  - 輆
+  - 軿
+  - 輁
+  - 輀
+  - 輂
+  - 輐
+  - 輑
+  - 輤
+  - 輘
+  - 輚
+  - 輠
+  - 輣
+  - 輖
+  - 輗
+  - 輮
+  - 輵
+  - 輲
+  - 輹
+  - 輷
+  - 輴
+  - 轃
+  - 轇
+  - 轈
+  - 轒
+  - 轑
+  - 轏
+  - 轐
+  - 轓
+  - 轙
+  - 轖
+  - 轗
+  - 轕
+  - 轚
+  - 轞
+  - 轛
+  - 轠
+  - 辴
+  - 迉
+  - 迒
+  - 迋
+  - 迍
+  - 迖
+  - 迣
+  - 迡
+  - 迾
+  - 迿
+  - 逜
+  - 逿
+  - 遝
+  - 遳
+  - 遰
+  - 遻
+  - 邆
+  - 邅
+  - 遾
+  - 邍
+  - 邔
+  - 邟
+  - 邥
+  - 邞
+  - 邧
+  - 郱
+  - 郕
+  - 郖
+  - 郠
+  - 郙
+  - 郣
+  - 郥
+  - 郘
+  - 郰
+  - 郲
+  - 郔
+  - 鄬
+  - 郼
+  - 鄈
+  - 郹
+  - 郻
+  - 鄁
+  - 鄇
+  - 郺
+  - 鄐
+  - 鄍
+  - 鄏
+  - 鄎
+  - 鄟
+  - 鄝
+  - 鄡
+  - 鄛
+  - 鄨
+  - 鄪
+  - 鄦
+  - 鄮
+  - 鄵
+  - 鄸
+  - 鄻
+  - 鄾
+  - 酀
+  - 酁
+  - 酄
+  - 酇
+  - 酖
+  - 酘
+  - 酓
+  - 酟
+  - 酳
+  - 醆
+  - 醊
+  - 醓
+  - 醙
+  - 醟
+  - 醥
+  - 醧
+  - 醰
+  - 醱
+  - 醷
+  - 醲
+  - 醳
+  - 醹
+  - 醽
+  - 釂
+  - 釃
+  - 釢
+  - 釱
+  - 釳
+  - 釸
+  - 鈚
+  - 鈌
+  - 鈒
+  - 釽
+  - 鈆
+  - 鉒
+  - 鉠
+  - 鉯
+  - 鈶
+  - 鉼
+  - 銤
+  - 銛
+  - 銔
+  - 鉹
+  - 銗
+  - 鋄
+  - 鋀
+  - 鋟
+  - 鋘
+  - 鋩
+  - 鋝
+  - 鋂
+  - 鋊
+  - 錧
+  - 錼
+  - 錭
+  - 錎
+  - 鋋
+  - 鎡
+  - 鎃
+  - 鎯
+  - 鍖
+  - 鍜
+  - 鍐
+  - 鍭
+  - 鍌
+  - 鎒
+  - 鎷
+  - 鎝
+  - 鎉
+  - 鎎
+  - 鎞
+  - 鏏
+  - 鏂
+  - 鏚
+  - 鏬
+  - 鏙
+  - 鐋
+  - 鐏
+  - 鏾
+  - 鐕
+  - 鐨
+  - 鐍
+  - 鐀
+  - 鐎
+  - 鐖
+  - 鐻
+  - 鐶
+  - 鑐
+  - 鑋
+  - 鑕
+  - 鑮
+  - 鑯
+  - 钂
+  - 钀
+  - 钁
+  - 钃
+  - 镺
+  - 镻
+  - 镼
+  - 镽
+  - 閈
+  - 閍
+  - 閺
+  - 閵
+  - 闀
+  - 闉
+  - 闅
+  - 閷
+  - 闒
+  - 闑
+  - 闚
+  - 闛
+  - 闠
+  - 闟
+  - 闤
+  - 阞
+  - 阢
+  - 阤
+  - 阠
+  - 阰
+  - 阹
+  - 阸
+  - 阺
+  - 陏
+  - 陓
+  - 陊
+  - 陼
+  - 陭
+  - 陫
+  - 隇
+  - 陾
+  - 隉
+  - 隒
+  - 隓
+  - 隞
+  - 隤
+  - 隿
+  - 雂
+  - 雈
+  - 雓
+  - 雔
+  - 雗
+  - 雚
+  - 雟
+  - 雘
+  - 雺
+  - 雽
+  - 雿
+  - 霂
+  - 霋
+  - 霒
+  - 霐
+  - 霠
+  - 霣
+  - 霢
+  - 霩
+  - 霫
+  - 霬
+  - 霮
+  - 霵
+  - 霿
+  - 靆
+  - 靃
+  - 靪
+  - 靮
+  - 靷
+  - 靲
+  - 靾
+  - 鞃
+  - 鞀
+  - 鞂
+  - 靻
+  - 鞊
+  - 鞎
+  - 鞈
+  - 鞙
+  - 鞗
+  - 鞚
+  - 鞜
+  - 鞤
+  - 鞪
+  - 鞷
+  - 鞶
+  - 鞹
+  - 鞻
+  - 鞿
+  - 韄
+  - 韅
+  - 韇
+  - 韎
+  - 韐
+  - 韏
+  - 韕
+  - 韔
+  - 韗
+  - 韝
+  - 韟
+  - 韣
+  - 韥
+  - 韰
+  - 韱
+  - 韹
+  - 韽
+  - 頄
+  - 頖
+  - 頞
+  - 頝
+  - 頩
+  - 頨
+  - 頯
+  - 頲
+  - 顁
+  - 顄
+  - 顊
+  - 顉
+  - 顅
+  - 顐
+  - 顑
+  - 顜
+  - 顝
+  - 顠
+  - 顣
+  - 顟
+  - 顤
+  - 顪
+  - 顩
+  - 顲
+  - 颬
+  - 颲
+  - 颸
+  - 颽
+  - 颻
+  - 颾
+  - 飁
+  - 飂
+  - 飉
+  - 飋
+  - 飌
+  - 飣
+  - 飶
+  - 餂
+  - 餀
+  - 飺
+  - 餔
+  - 餖
+  - 餕
+  - 餤
+  - 餟
+  - 餥
+  - 餫
+  - 餪
+  - 餲
+  - 餯
+  - 餭
+  - 餱
+  - 餰
+  - 饁
+  - 饇
+  - 饐
+  - 饎
+  - 饙
+  - 饘
+  - 饛
+  - 饡
+  - 馣
+  - 馲
+  - 馰
+  - 馵
+  - 馻
+  - 馺
+  - 駂
+  - 馽
+  - 駜
+  - 駍
+  - 駏
+  - 駎
+  - 駖
+  - 駮
+  - 駬
+  - 駥
+  - 駤
+  - 駣
+  - 駩
+  - 駺
+  - 駴
+  - 駷
+  - 駹
+  - 駶
+  - 駻
+  - 駽
+  - 駾
+  - 騃
+  - 騉
+  - 騑
+  - 騊
+  - 騇
+  - 騚
+  - 騕
+  - 騥
+  - 騝
+  - 騛
+  - 騢
+  - 騠
+  - 騧
+  - 騞
+  - 騜
+  - 騵
+  - 騲
+  - 騴
+  - 騱
+  - 騬
+  - 騪
+  - 騩
+  - 騹
+  - 騽
+  - 驆
+  - 騺
+  - 驓
+  - 驔
+  - 驈
+  - 驉
+  - 驖
+  - 驞
+  - 驠
+  - 驦
+  - 驨
+  - 骭
+  - 骫
+  - 骹
+  - 骿
+  - 骴
+  - 骾
+  - 髇
+  - 髊
+  - 髆
+  - 髍
+  - 髐
+  - 髟
+  - 髧
+  - 髬
+  - 髳
+  - 髶
+  - 髺
+  - 髾
+  - 鬁
+  - 髼
+  - 鬋
+  - 鬊
+  - 鬎
+  - 鬌
+  - 鬐
+  - 鬕
+  - 鬗
+  - 鬖
+  - 鬙
+  - 鬞
+  - 鬠
+  - 鬤
+  - 鬫
+  - 鬳
+  - 鬵
+  - 鬺
+  - 鬾
+  - 鬿
+  - 魊
+  - 魌
+  - 魖
+  - 魠
+  - 魡
+  - 魧
+  - 魱
+  - 魦
+  - 魶
+  - 魵
+  - 鮅
+  - 鮇
+  - 魼
+  - 魾
+  - 魻
+  - 鮂
+  - 鮚
+  - 鮞
+  - 鮛
+  - 鮦
+  - 鮥
+  - 鮤
+  - 鮆
+  - 鯆
+  - 鮿
+  - 鮵
+  - 鯈
+  - 鯫
+  - 鯠
+  - 鯞
+  - 鯦
+  - 鯬
+  - 鰌
+  - 鰋
+  - 鰅
+  - 鯸
+  - 鰫
+  - 鰝
+  - 鰬
+  - 鱆
+  - 鰿
+  - 鱄
+  - 鱁
+  - 鰴
+  - 鱐
+  - 鱍
+  - 鱋
+  - 鱕
+  - 鱦
+  - 鱢
+  - 鱞
+  - 鱴
+  - 鱳
+  - 鱹
+  - 鳦
+  - 鳪
+  - 鳭
+  - 鳱
+  - 鳵
+  - 鳼
+  - 鳺
+  - 鳿
+  - 鳷
+  - 鴀
+  - 鳹
+  - 鳻
+  - 鴅
+  - 鴃
+  - 鴥
+  - 鴠
+  - 鴔
+  - 鴩
+  - 鴘
+  - 鴢
+  - 鴐
+  - 鴳
+  - 鵁
+  - 鵧
+  - 鴶
+  - 鴮
+  - 鴱
+  - 鴸
+  - 鵅
+  - 鵃
+  - 鴾
+  - 鵀
+  - 鴽
+  - 鵏
+  - 鵊
+  - 鵛
+  - 鵋
+  - 鵖
+  - 鵌
+  - 鵗
+  - 鵔
+  - 鵷
+  - 鶁
+  - 鶊
+  - 鶄
+  - 鶈
+  - 鵱
+  - 鶀
+  - 鵸
+  - 鶋
+  - 鶌
+  - 鵽
+  - 鵫
+  - 鵴
+  - 鵩
+  - 鶅
+  - 鵳
+  - 鵻
+  - 鶂
+  - 鵹
+  - 鶟
+  - 鶙
+  - 鶤
+  - 鶝
+  - 鶐
+  - 鶛
+  - 鶠
+  - 鶔
+  - 鶜
+  - 鶪
+  - 鶗
+  - 鶢
+  - 鶨
+  - 鶞
+  - 鶣
+  - 鶖
+  - 鶷
+  - 鶶
+  - 鷁
+  - 鷇
+  - 鷊
+  - 鷏
+  - 鶾
+  - 鷅
+  - 鷃
+  - 鶵
+  - 鷈
+  - 鶱
+  - 鶭
+  - 鷛
+  - 鷒
+  - 鷞
+  - 鷋
+  - 鷐
+  - 鷜
+  - 鷑
+  - 鷩
+  - 鷘
+  - 鷖
+  - 鷵
+  - 鷕
+  - 鷻
+  - 鷷
+  - 鷣
+  - 鷤
+  - 鷶
+  - 鷡
+  - 鷮
+  - 鷢
+  - 鸂
+  - 鷾
+  - 鸇
+  - 鸃
+  - 鸆
+  - 鸅
+  - 鸀
+  - 鸁
+  - 鸉
+  - 鷿
+  - 鷽
+  - 鸄
+  - 鸋
+  - 鸍
+  - 鸏
+  - 鸒
+  - 鸔
+  - 鸓
+  - 鸗
+  - 鸙
+  - 鹺
+  - 麃
+  - 麆
+  - 麉
+  - 麎
+  - 麌
+  - 麔
+  - 麙
+  - 麛
+  - 麚
+  - 麜
+  - 麠
+  - 麡
+  - 麧
+  - 麮
+  - 麰
+  - 麶
+  - 麷
+  - 黀
+  - 黂
+  - 黈
+  - 黓
+  - 黕
+  - 黖
+  - 黚
+  - 黤
+  - 黫
+  - 黮
+  - 黭
+  - 黰
+  - 黳
+  - 黵
+  - 黺
+  - 鼁
+  - 鼀
+  - 鼆
+  - 鼊
+  - 鼏
+  - 鼖
+  - 鼛
+  - 鼘
+  - 鼜
+  - 鼤
+  - 鼣
+  - 鼥
+  - 鼪
+  - 鼨
+  - 鼭
+  - 鼰
+  - 鼮
+  - 鼵
+  - 鼳
+  - 鼲
+  - 鼸
+  - 鼶
+  - 齀
+  - 齂
+  - 齃
+  - 齌
+  - 齍
+  - 齎
+  - 齖
+  - 齗
+  - 齘
+  - 齛
+  - 齠
+  - 齞
+  - 齝
+  - 齥
+  - 齤
+  - 齫
+  - 齱
+  - 齰
+  - 齮
+  - 齯
+  - 齴
+  - 齵
+  - 齸
+  - 齻
+  - 齺
+  - 齹
+  - 齾
+  - 龒
+  - 龤
+  - 堔
+  - 礂
+  - 蒏
+  - 蒆
+  - 兙
+  - 兛
+  - 兞
+  - 兝
+  - 兡
+  - 兣
+  - 嗧
+  - 瓩
+  - 忼
+  - 擡
+  - 氊
+  - 穇
+  - 擧
+  - 譌
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - °
+  - ²
+  - ´
+  - ½
+  - Á
+  - Ä
+  - Å
+  - Ç
+  - È
+  - É
+  - Í
+  - Ó
+  - Ö
+  - ×
+  - Ü
+  - ß
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - í
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ú
+  - û
+  - ü
+  - ý
+  - ā
+  - ă
+  - ą
+  - ć
+  - Č
+  - č
+  - đ
+  - ē
+  - ė
+  - ę
+  - ğ
+  - ī
+  - ı
+  - Ł
+  - ł
+  - ń
+  - ň
+  - ō
+  - ř
+  - Ş
+  - ş
+  - Š
+  - š
+  - ţ
+  - ū
+  - ż
+  - Ž
+  - ž
+  - Ș
+  - ș
+  - ț
+  - Δ
+  - α
+  - λ
+  - μ
+  - φ
+  - Г
+  - О
+  - а
+  - в
+  - л
+  - о
+  - р
+  - с
+  - т
+  - я
+  - ồ
+  - —
+  - ―
+  - ’
+  - “
+  - ”
+  - …
+  - ℃
+  - →
+  - ∇
+  - −
+  - ■
+  - ☆
+  - 、
+  - 。
+  - 々
+  - 〆
+  - 〈
+  - 〉
+  - 「
+  - 」
+  - 『
+  - 』
+  - 〔
+  - 〕
+  - 〜
+  - ！
+  - ＃
+  - ％
+  - ＆
+  - （
+  - ）
+  - ＋
+  - ，
+  - －
+  - ．
+  - ／
+  - ０
+  - １
+  - ２
+  - ３
+  - ４
+  - ５
+  - ６
+  - ７
+  - ８
+  - ９
+  - ：
+  - ；
+  - ＝
+  - ？
+  - ＠
+  - Ａ
+  - Ｂ
+  - Ｃ
+  - Ｄ
+  - Ｅ
+  - Ｆ
+  - Ｇ
+  - Ｈ
+  - Ｉ
+  - Ｊ
+  - Ｋ
+  - Ｌ
+  - Ｍ
+  - Ｎ
+  - Ｏ
+  - Ｐ
+  - Ｒ
+  - Ｓ
+  - Ｔ
+  - Ｕ
+  - Ｖ
+  - Ｗ
+  - Ｘ
+  - Ｚ
+  - ａ
+  - ｂ
+  - ｃ
+  - ｄ
+  - ｅ
+  - ｆ
+  - ｇ
+  - ｈ
+  - ｉ
+  - ｊ
+  - ｋ
+  - ｌ
+  - ｍ
+  - ｎ
+  - ｏ
+  - ｐ
+  - ｑ
+  - ｒ
+  - ｓ
+  - ｔ
+  - ｕ
+  - ｖ
+  - ｗ
+  - ｘ
+  - ｙ
+  - ｚ
+  - ～
+  - ･
+  - ǎ
+  - ǒ
+  - ě
+  - ǐ
+  - ì
+  - ǔ
+  - ù
+  - ǖ
+  - ǘ
+  - ǚ
+  - ǜ
+  - 【
+  - 】
+  - 《
+  - 》
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ⊕
+  - ⊖
+  - ⊗
+  - ⊘
+  - ⊙
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ⊎
+  - ⊓
+  - ⊔
+  - ≠
+  - ≈
+  - ≡
+  - ≤
+  - ≥
+  - ≪
+  - ≫
+  - ≲
+  - ≳
+  - ≶
+  - ≷
+  - ≺
+  - ≻
+  - ≼
+  - ≽
+  - ∈
+  - ∉
+  - ⊂
+  - ⊃
+  - ⊆
+  - ⊇
+  - ⊄
+  - ⊅
+  - ∅
+  - ∖
+  - ∁
+  - ∆
+  - ∧
+  - ∨
+  - ¬
+  - ⊻
+  - ⊼
+  - ⊽
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ≄
+  - ≅
+  - ≃
+  - ≦
+  - ≧
+  - ⊈
+  - ⊉
+  - ⊢
+  - ⊤
+  - ⊨
+  - ⊧
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ￥
+  - ₿
+  - ↑
+  - ↓
+  - ↕
+  - ↖
+  - ↗
+  - ↘
+  - ↙
+  - ↺
+  - ↻
+  - ↼
+  - ↽
+  - ↾
+  - ↿
+  - ⇀
+  - ⇁
+  - ⇂
+  - ⇃
+  - ⇋
+  - ⇌
+  - ª
+  - º
+  - ⁰
+  - ¹
+  - ³
+  - ⁴
+  - ⁵
+  - ⁶
+  - ⁷
+  - ⁸
+  - ⁹
+  - ⁺
+  - ⁻
+  - ⁼
+  - ⁽
+  - ⁾
+  - ⁿ
+  - ₀
+  - ₁
+  - ₂
+  - ₃
+  - ₄
+  - ₅
+  - ₆
+  - ₇
+  - ₈
+  - ₉
+  - ₊
+  - ₋
+  - ₌
+  - ₍
+  - ₎
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ☰
+  - ☱
+  - ☲
+  - ☳
+  - ☴
+  - ☵
+  - ☶
+  - ☷
+  - ♀
+  - ♂
+  - ♳
+  - ♴
+  - ♵
+  - ♶
+  - ♷
+  - ♸
+  - ♹
+  - ♺
+  - ♩
+  - ♪
+  - ♫
+  - ♬
+  - ⚪
+  - ⚫
+  - ⚬
+  - ✶
+  - ✷
+  - ✸
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ⏀
+  - ⏁
+  - ⏂
+  - ⏃
+  - ⏄
+  - ⏅
+  - ⏆
+  - ⏇
+  - ⏈
+  - ⏉
+  - ⏊
+  - ⏋
+  - ⏌
+  - ⏚
+  - ⏴
+  - ⏵
+  - ⏶
+  - ⏷
+  - ⏸
+  - ⏹
+  - ⏺
+  - ⏻
+  - ⏼
+  - Α
+  - Β
+  - Γ
+  - Ε
+  - Ζ
+  - Η
+  - Θ
+  - Ι
+  - Κ
+  - Λ
+  - Μ
+  - Ν
+  - Ξ
+  - Ο
+  - Π
+  - Ρ
+  - Σ
+  - Τ
+  - Υ
+  - Φ
+  - Χ
+  - Ψ
+  - β
+  - γ
+  - δ
+  - ε
+  - ζ
+  - η
+  - θ
+  - ι
+  - κ
+  - ν
+  - ξ
+  - ο
+  - π
+  - ρ
+  - σ
+  - τ
+  - υ
+  - χ
+  - ψ
+  - ω
+  - ϐ
+  - ϑ
+  - ϒ
+  - ϕ
+  - █
+  - ϖ
+  - ϰ
+  - ϱ
+  - ϴ
+  - ϵ
+  - ϝ
+  - Ϟ
+  - ϟ
+  - Ϡ
+  - ϡ
+  - Ϣ
+  - ϣ
+  - Ϥ
+  - ϥ
+  - Ϧ
+  - ϧ
+  - Ϩ
+  - ϩ
+  - Ϫ
+  - ϫ
+  - Ϭ
+  - ϭ
+  - Ϯ
+  - ϯ
+  - ∸
+  - ∹
+  - ∺
+  - ∻
+  - ∽
+  - ∾
+  - ∿
+  - ≀
+  - ≁
+  - ≂
+  - ≆
+  - ≇
+  - ≉
+  - ≊
+  - ≋
+  - ≌
+  - ≍
+  - ≎
+  - ≏
+  - ≐
+  - ≑
+  - ≒
+  - ≓
+  - ≔
+  - ≕
+  - ≖
+  - ≗
+  - ≘
+  - ≙
+  - ≚
+  - ≛
+  - ≜
+  - ≝
+  - ≞
+  - ≟
+  - ≢
+  - ≣
+  - ≨
+  - ≩
+  - ≬
+  - ≭
+  - ≮
+  - ≯
+  - ≰
+  - ≱
+  - ≴
+  - ≵
+  - ≸
+  - ≹
+  - ≾
+  - ≿
+  - ⊀
+  - ⊁
+  - ⊊
+  - ⊋
+  - ⊌
+  - ⊍
+  - ⊏
+  - ⊐
+  - ⊑
+  - ⊒
+  - ⊚
+  - ⊛
+  - ⊜
+  - ⊝
+  - ⊞
+  - ⊟
+  - ⊠
+  - ⊡
+  - ⊣
+  - ⊦
+  - ⊩
+  - ⊪
+  - ⊫
+  - ⊬
+  - ⊭
+  - ⊮
+  - ⊯
+  - ⊰
+  - ⊱
+  - ⊲
+  - ⊳
+  - ⊴
+  - ⊵
+  - ⊶
+  - ⊷
+  - ⊸
+  - ⊹
+  - ⊺
+  - ℎ
+  - ℘
+  - ℜ
+  - ℑ
+  - ℵ
+  - ℶ
+  - ℷ
+  - ℸ
+  - ⌬
+  - ⌭
+  - ⌮
+  - ⌯
+  - ⎔
+  - ¤
+  - ₠
+  - ₡
+  - ₢
+  - ₣
+  - ₤
+  - ₥
+  - ₦
+  - ₧
+  - ₨
+  - ₩
+  - ₪
+  - ₫
+  - ₭
+  - ₮
+  - ₯
+  - ₰
+  - ₱
+  - ₲
+  - ₳
+  - ₴
+  - ₵
+  - ₶
+  - ₷
+  - ₸
+  - ₹
+  - ₺
+  - ₻
+  - ₼
+  - ₽
+  - ₾
+  - ↚
+  - ↛
+  - ↜
+  - ↝
+  - ↞
+  - ↟
+  - ↠
+  - ↡
+  - ↢
+  - ↣
+  - ↤
+  - ↥
+  - ↦
+  - ↧
+  - ↨
+  - ↩
+  - ↪
+  - ↫
+  - ↬
+  - ↭
+  - ↮
+  - ↯
+  - ↰
+  - ↱
+  - ↲
+  - ↳
+  - ↴
+  - ↵
+  - ↶
+  - ↷
+  - ↸
+  - ↹
+  - ⇄
+  - ⇅
+  - ⇆
+  - ⇇
+  - ⇈
+  - ⇉
+  - ⇊
+  - ⇍
+  - ⇎
+  - ⇏
+  - ⇑
+  - ⇓
+  - ⇕
+  - ⇖
+  - ⇗
+  - ⇘
+  - ⇙
+  - ⇚
+  - ⇛
+  - ⇜
+  - ⇝
+  - ⇞
+  - ⇟
+  - ⇠
+  - ⇡
+  - ⇢
+  - ⇣
+  - ⇤
+  - ⇥
+  - ⇦
+  - ⇧
+  - ⇨
+  - ⇩
+  - ⇪
+  - ⇫
+  - ⇬
+  - ⇭
+  - ⇮
+  - ⇯
+  - ⇰
+  - ⇱
+  - ⇲
+  - ⇳
+  - ⇴
+  - ⇵
+  - ⇶
+  - ⇷
+  - ⇸
+  - ⇹
+  - ⇺
+  - ⇻
+  - ⇼
+  - ⇽
+  - ⇾
+  - ⇿
+  - ↀ
+  - ↁ
+  - ↂ
+  - ☀
+  - ☁
+  - ☂
+  - ☃
+  - ☄
+  - ★
+  - ☇
+  - ☈
+  - ☉
+  - ☊
+  - ☋
+  - ☌
+  - ☍
+  - ☎
+  - ☏
+  - ☐
+  - ☑
+  - ☒
+  - ☓
+  - ☔
+  - ☕
+  - ☖
+  - ☗
+  - ☘
+  - ☙
+  - ☚
+  - ☛
+  - ☜
+  - ☝
+  - ☞
+  - ☟
+  - ☠
+  - ☡
+  - ☢
+  - ☣
+  - ☤
+  - ☥
+  - ☦
+  - ☧
+  - ☨
+  - ☩
+  - ☪
+  - ☫
+  - ☬
+  - ☭
+  - ☮
+  - ☯
+  - ☸
+  - ☹
+  - ☺
+  - ☻
+  - ☼
+  - ☽
+  - ☾
+  - ☿
+  - ♁
+  - ♃
+  - ♄
+  - ♅
+  - ♆
+  - ♇
+  - ♔
+  - ♕
+  - ♖
+  - ♗
+  - ♘
+  - ♙
+  - ♚
+  - ♛
+  - ♜
+  - ♝
+  - ♞
+  - ♟
+  - ♠
+  - ♡
+  - ♢
+  - ♣
+  - ♤
+  - ♥
+  - ♦
+  - ♧
+  - ♨
+  - ♭
+  - ♮
+  - ♯
+  - ♰
+  - ♱
+  - ♲
+  - ♻
+  - ♼
+  - ♽
+  - ♾
+  - ⚀
+  - ⚁
+  - ⚂
+  - ⚃
+  - ⚄
+  - ⚅
+  - ⚆
+  - ⚇
+  - ⚈
+  - ⚉
+  - ⚊
+  - ⚋
+  - ⚌
+  - ⚍
+  - ⚎
+  - ⚏
+  - ⚐
+  - ⚑
+  - ⚒
+  - ⚓
+  - ⚔
+  - ⚕
+  - ⚖
+  - ⚗
+  - ⚘
+  - ⚙
+  - ⚚
+  - ⚛
+  - ⚜
+  - ⚝
+  - ⚞
+  - ⚟
+  - ⚠
+  - ⚡
+  - ⚢
+  - ⚣
+  - ⚤
+  - ⚥
+  - ⚦
+  - ⚧
+  - ⚨
+  - ⚩
+  - ⚭
+  - ⚮
+  - ⚯
+  - ⚰
+  - ⚱
+  - ⚲
+  - ⚳
+  - ⚴
+  - ⚵
+  - ⚶
+  - ⚷
+  - ⚸
+  - ⚹
+  - ⚺
+  - ⚻
+  - ⚼
+  - ⚿
+  - ⛀
+  - ⛁
+  - ⛂
+  - ⛃
+  - ⛆
+  - ⛇
+  - ⛈
+  - ⛉
+  - ⛊
+  - ⛋
+  - ⛌
+  - ⛍
+  - ⛏
+  - ⛐
+  - ⛑
+  - ⛒
+  - ⛓
+  - ⛕
+  - ⛖
+  - ⛗
+  - ⛘
+  - ⛙
+  - ⛚
+  - ⛛
+  - ⛜
+  - ⛝
+  - ⛞
+  - ⛠
+  - ⛡
+  - ⛢
+  - ⛣
+  - ⛤
+  - ⛥
+  - ⛦
+  - ⛧
+  - ⛨
+  - ⛩
+  - ⛪
+  - ⛫
+  - ⛬
+  - ⛭
+  - ⛮
+  - ⛯
+  - ⛶
+  - ⛾
+  - ⛿
+  - ✆
+  - ✇
+  - ✈
+  - ✉
+  - ✌
+  - ✍
+  - ✎
+  - ✏
+  - ✐
+  - ✑
+  - ✒
+  - ✓
+  - ✔
+  - ✕
+  - ✙
+  - ✚
+  - ✛
+  - ✜
+  - ✝
+  - ✞
+  - ✟
+  - ✠
+  - ✡
+  - ✢
+  - ✣
+  - ✤
+  - ✥
+  - ✦
+  - ✧
+  - ✩
+  - ✪
+  - ✫
+  - ✬
+  - ✭
+  - ✮
+  - ✯
+  - ✰
+  - ✱
+  - ✲
+  - ✳
+  - ✴
+  - ✵
+  - ✹
+  - ✺
+  - ✻
+  - ✼
+  - ✽
+  - ✾
+  - ✿
+  - ❀
+  - ❁
+  - ❂
+  - ❃
+  - ❄
+  - ❅
+  - ❆
+  - ❇
+  - ❈
+  - ❉
+  - ❊
+  - ❋
+  - ❍
+  - ❏
+  - ❐
+  - ❑
+  - ❒
+  - ❖
+  - ❘
+  - ❙
+  - ❚
+  - ❛
+  - ❜
+  - ❝
+  - ❞
+  - ❡
+  - ❢
+  - ❣
+  - ❤
+  - ❥
+  - ❦
+  - ❧
+  - ❨
+  - ❩
+  - ❪
+  - ❫
+  - ❬
+  - ❭
+  - ❮
+  - ❯
+  - ❰
+  - ❱
+  - ❲
+  - ❳
+  - ❴
+  - ❵
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ➔
+  - ➕
+  - ➖
+  - ➗
+  - ➘
+  - ➙
+  - ➚
+  - ➛
+  - ➜
+  - ➝
+  - ➞
+  - ➟
+  - ➠
+  - ➡
+  - ➢
+  - ➣
+  - ➤
+  - ➥
+  - ➦
+  - ➧
+  - ➨
+  - ➩
+  - ➪
+  - ➫
+  - ➬
+  - ➭
+  - ➮
+  - ➯
+  - ➰
+  - ➱
+  - ➲
+  - ➳
+  - ➴
+  - ➵
+  - ➶
+  - ➷
+  - ➸
+  - ➹
+  - ➺
+  - ➻
+  - ➼
+  - ➽
+  - ➾
+  - ➿
+  - ⌘
+  - ⌥
+  - ⌃
+  - ⎋
+  - ⌫
+  - ⌦
+  - ⏏
+  - ⌤
+  - ⌧
+  - ⌨
+  - ⎆
+  - ⎇
+  - ⎈
+  - ⎉
+  - ⎊
+  - ⎌
+  - ⎍
+  - ⎎
+  - ⎏
+  - ⎐
+  - ⎑
+  - ⎒
+  - ⎓
+  - ⎕
+  - ⎖
+  - ⎗
+  - ⎘
+  - ⎙
+  - ⎚
+  - ⎛
+  - ⎜
+  - ⎝
+  - ⎞
+  - ⎟
+  - ⎠
+  - ⎡
+  - ⎢
+  - ⎣
+  - ⎤
+  - ⎥
+  - ⎦
+  - ⎧
+  - ⎨
+  - ⎩
+  - ⎪
+  - ⎫
+  - ⎬
+  - ⎭
+  - ⎮
+  - ⎯
+  - ⎰
+  - ⎱
+  - ⎲
+  - ⎳
+  - ⎴
+  - ⎵
+  - ⎶
+  - ⎷
+  - ⎸
+  - ⎹
+  - ⎺
+  - ⎻
+  - ⎼
+  - ⎽
+  - ⎾
+  - ⎿
+  - ⏍
+  - ⏎
+  - ⏐
+  - ⏑
+  - ⏒
+  - ⏓
+  - ⏔
+  - ⏕
+  - ⏖
+  - ⏗
+  - ⏘
+  - ⏙
+  - ⏛
+  - ⏜
+  - ⏝
+  - ⏞
+  - ⏟
+  - ⏠
+  - ⏡
+  - ⏢
+  - ⏣
+  - ⏤
+  - ⏥
+  - ⏦
+  - ⏧
+  - ⏨
+  - ⏭
+  - ⏮
+  - ⏯
+  - ⏱
+  - ⏲
+  - ▲
+  - ▽
+  - ◐
+  - ⏽
+  - ⏾
+  - ⏿
+  - ɐ
+  - ɑ
+  - ɒ
+  - ɓ
+  - ɔ
+  - ɕ
+  - ɖ
+  - ɗ
+  - ɘ
+  - ə
+  - ɚ
+  - ɛ
+  - ɜ
+  - ɝ
+  - ɞ
+  - ɟ
+  - ɠ
+  - ɡ
+  - ɢ
+  - ɣ
+  - ɤ
+  - ɥ
+  - ɦ
+  - ɧ
+  - ɨ
+  - ɩ
+  - ɪ
+  - ɫ
+  - ɬ
+  - ɭ
+  - ɮ
+  - ɯ
+  - ɰ
+  - ɱ
+  - ɲ
+  - ɳ
+  - ɴ
+  - ɵ
+  - ɶ
+  - ɷ
+  - ɸ
+  - ɹ
+  - ɺ
+  - ɻ
+  - ɼ
+  - ɽ
+  - ɾ
+  - ɿ
+  - ʀ
+  - ʁ
+  - ʂ
+  - ʃ
+  - ʄ
+  - ʅ
+  - ʆ
+  - ʇ
+  - ʈ
+  - ʉ
+  - ʊ
+  - ʋ
+  - ʌ
+  - ʍ
+  - ʎ
+  - ʏ
+  - ʐ
+  - ʑ
+  - ʒ
+  - ʓ
+  - ʔ
+  - ʕ
+  - ʖ
+  - ʗ
+  - ʘ
+  - ʙ
+  - ʚ
+  - ʛ
+  - ʜ
+  - ʝ
+  - ʞ
+  - ʟ
+  - ʠ
+  - ʡ
+  - ʢ
+  - ʣ
+  - ʤ
+  - ʥ
+  - ʦ
+  - ʧ
+  - ʨ
+  - ʩ
+  - ʪ
+  - ʫ
+  - ʬ
+  - ʭ
+  - ʮ
+  - ʯ
+  - ━
+  - Ǝ
+  - Ã
+  - ●
+  - ▶
+  - ｜
+  - 𝑢
+  - 〖
+  - 〗
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ✘
+  - Е
+  - ◉
+  - 〒
+  - 𝒱
+  - 𝜆
+  - ⟹
+  - ﹪
+  - ◊
+  - ╆
+  - 오
+  - ˂
+  - 〉
+  - 𝝎
+  - ▪
+  - △
+  - ▁
+  - ◼
+  - 〇
+  - ▷
+  - ▬
+  - 𝒮
+  - †
+  - ₒ
+  - ⼁
+  - 〵
+  - ⭐
+  - ╳
+  - ⟶
+  - 으
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - 丄
+  - ︾
+  - ◥
+  - ‖
+  - 𝜌
+  - ⅼ
+  - ▼
+  - ⁎
+  - ﹏
+  - 😁
+  - 😂
+  - 😃
+  - 😄
+  - 😅
+  - 😆
+  - 😉
+  - 😊
+  - 😋
+  - 😌
+  - 😍
+  - 😏
+  - 😒
+  - 😓
+  - 😔
+  - 😖
+  - 😘
+  - 😚
+  - 😜
+  - 😝
+  - 😞
+  - 😠
+  - 😡
+  - 😢
+  - 😣
+  - 😤
+  - 😥
+  - 😨
+  - 😩
+  - 😪
+  - 😫
+  - 😭
+  - 😰
+  - 😱
+  - 😲
+  - 😳
+  - 😵
+  - 😷
+  - 😸
+  - 😹
+  - 😺
+  - 😻
+  - 😼
+  - 😽
+  - 😾
+  - 😿
+  - 🙀
+  - 🙅
+  - 🙆
+  - 🙇
+  - 🙈
+  - 🙉
+  - 🙊
+  - 🙋
+  - 🙌
+  - 🙍
+  - 🙎
+  - 🙏
+  - ✂
+  - ✅
+  - ✊
+  - ✋
+  - ✖
+  - ✨
+  - ❌
+  - ❎
+  - ❓
+  - ❔
+  - ❕
+  - ❗
+  - 🚀
+  - 🚃
+  - 🚄
+  - 🚅
+  - 🚇
+  - 🚉
+  - 🚌
+  - 🚏
+  - 🚑
+  - 🚒
+  - 🚓
+  - 🚕
+  - 🚗
+  - 🚙
+  - 🚚
+  - 🚢
+  - 🚤
+  - 🚥
+  - 🚧
+  - 🚨
+  - 🚩
+  - 🚪
+  - 🚫
+  - 🚬
+  - 🚭
+  - 🚲
+  - 🚶
+  - 🚹
+  - 🚺
+  - 🚻
+  - 🚼
+  - 🚽
+  - 🚾
+  - 🛀
+  - Ⓜ
+  - 🅰
+  - 🅱
+  - 🅾
+  - 🅿
+  - 🆎
+  - 🆑
+  - 🆒
+  - 🆓
+  - 🆔
+  - 🆕
+  - 🆖
+  - 🆗
+  - 🆘
+  - 🆙
+  - 🆚
+  - 🇩🇪
+  - 🇬🇧
+  - 🇨🇳
+  - 🇯🇵
+  - 🇫🇷
+  - 🇰🇷
+  - 🇪🇸
+  - 🇮🇹
+  - 🇷🇺
+  - 🇺🇸
+  - 🈁
+  - ℹ
+  - ⌚
+  - ⌛
+  - ⏩
+  - ⏪
+  - ⏫
+  - ⏬
+  - ⏰
+  - ⏳
+  - ◻
+  - ◽
+  - ◾
+  - ♈
+  - ♉
+  - ♊
+  - ♋
+  - ♌
+  - ♍
+  - ♎
+  - ♏
+  - ♐
+  - ♑
+  - ♒
+  - ♓
+  - ♿
+  - ⚽
+  - ⚾
+  - ⛄
+  - ⛅
+  - ⛎
+  - ⛔
+  - ⛲
+  - ⛳
+  - ⛵
+  - ⛺
+  - ⛽
+  - ⤴
+  - ⤵
+  - ⬅
+  - ⬇
+  - ⬛
+  - ⬜
+  - ⭕
+  - 〰
+  - 〽
+  - ㊗
+  - ㊙
+  - 🀄
+  - 🃏
+  - 🌀
+  - 🌁
+  - 🌂
+  - 🌃
+  - 🌄
+  - 🌅
+  - 🌆
+  - 🌇
+  - 🌈
+  - 🌉
+  - 🌊
+  - 🌋
+  - 🌌
+  - 🌏
+  - 🌑
+  - 🌓
+  - 🌔
+  - 🌕
+  - 🌙
+  - 🌛
+  - 🌟
+  - 🌠
+  - 🌰
+  - 🌱
+  - 🌴
+  - 🌵
+  - 🌷
+  - 🌸
+  - 🌹
+  - 🌺
+  - 🌻
+  - 🌼
+  - 🌽
+  - 🌾
+  - 🌿
+  - 🍀
+  - 🍁
+  - 🍂
+  - 🍃
+  - 🍄
+  - 🍅
+  - 🍆
+  - 🍇
+  - 🍈
+  - 🍉
+  - 🍊
+  - 🍌
+  - 🍍
+  - 🍎
+  - 🍏
+  - 🍑
+  - 🍒
+  - 🍓
+  - 🍔
+  - 🍕
+  - 🍖
+  - 🍗
+  - 🍘
+  - 🍙
+  - 🍚
+  - 🍛
+  - 🍜
+  - 🍝
+  - 🍞
+  - 🍟
+  - 🍠
+  - 🍡
+  - 🍢
+  - 🍣
+  - 🍤
+  - 🍥
+  - 🍦
+  - 🍧
+  - 🍨
+  - 🍩
+  - 🍪
+  - 🍫
+  - 🍬
+  - 🍭
+  - 🍮
+  - 🍯
+  - 🍰
+  - 🍱
+  - 🍲
+  - 🍳
+  - 🍴
+  - 🍵
+  - 🍶
+  - 🍷
+  - 🍸
+  - 🍹
+  - 🍺
+  - 🍻
+  - 🎀
+  - 🎁
+  - 🎂
+  - 🎃
+  - 🎄
+  - 🎅
+  - 🎆
+  - 🎇
+  - 🎈
+  - 🎉
+  - 🎊
+  - 🎋
+  - 🎌
+  - 🎍
+  - 🎎
+  - 🎏
+  - 🎐
+  - 🎑
+  - 🎒
+  - 🎓
+  - 🎠
+  - 🎡
+  - 🎢
+  - 🎣
+  - 🎤
+  - 🎥
+  - 🎦
+  - 🎧
+  - 🎨
+  - 🎩
+  - 🎪
+  - 🎫
+  - 🎬
+  - 🎭
+  - 🎮
+  - 🎯
+  - 🎰
+  - 🎱
+  - 🎲
+  - 🎳
+  - 🎴
+  - 🎵
+  - 🎶
+  - 🎷
+  - 🎸
+  - 🎹
+  - 🎺
+  - 🎻
+  - 🎼
+  - 🎽
+  - 🎾
+  - 🎿
+  - 🏀
+  - 🏁
+  - 🏂
+  - 🏃
+  - 🏄
+  - 🏆
+  - 🏈
+  - 🏊
+  - 🏠
+  - 🏡
+  - 🏢
+  - 🏣
+  - 🏥
+  - 🏦
+  - 🏧
+  - 🏨
+  - 🏩
+  - 🏪
+  - 🏫
+  - 🏬
+  - 🏭
+  - 🏮
+  - 🏯
+  - 🏰
+  - 🐌
+  - 🐍
+  - 🐎
+  - 🐑
+  - 🐒
+  - 🐔
+  - 🐗
+  - 🐘
+  - 🐙
+  - 🐚
+  - 🐛
+  - 🐜
+  - 🐝
+  - 🐞
+  - 🐟
+  - 🐠
+  - 🐡
+  - 🐢
+  - 🐣
+  - 🐤
+  - 🐥
+  - 🐦
+  - 🐧
+  - 🐨
+  - 🐩
+  - 🐫
+  - 🐬
+  - 🐭
+  - 🐮
+  - 🐯
+  - 🐰
+  - 🐱
+  - 🐲
+  - 🐳
+  - 🐴
+  - 🐵
+  - 🐶
+  - 🐷
+  - 🐸
+  - 🐹
+  - 🐺
+  - 🐻
+  - 🐼
+  - 🐽
+  - 🐾
+  - 👀
+  - 👂
+  - 👃
+  - 👄
+  - 👅
+  - 👆
+  - 👇
+  - 👈
+  - 👉
+  - 👊
+  - 👋
+  - 👌
+  - 👍
+  - 👎
+  - 👏
+  - 👐
+  - 👑
+  - 👒
+  - 👓
+  - 👔
+  - 👕
+  - 👖
+  - 👗
+  - 👘
+  - 👙
+  - 👚
+  - 👛
+  - 👜
+  - 👝
+  - 👞
+  - 👟
+  - 👠
+  - 👡
+  - 👢
+  - 👣
+  - 👤
+  - 👦
+  - 👧
+  - 👨
+  - 👩
+  - 👪
+  - 👫
+  - 👮
+  - 👯
+  - 👰
+  - 👱
+  - 👲
+  - 👳
+  - 👴
+  - 👵
+  - 👶
+  - 👷
+  - 👸
+  - 👹
+  - 👺
+  - 👻
+  - 👼
+  - 👽
+  - 👾
+  - 👿
+  - 💀
+  - 💁
+  - 💂
+  - 💃
+  - 💄
+  - 💅
+  - 💆
+  - 💇
+  - 💈
+  - 💉
+  - 💊
+  - 💋
+  - 💌
+  - 💍
+  - 💎
+  - 💏
+  - 💐
+  - 💑
+  - 💒
+  - 💓
+  - 💔
+  - 💕
+  - 💖
+  - 💗
+  - 💘
+  - 💙
+  - 💚
+  - 💛
+  - 💜
+  - 💝
+  - 💞
+  - 💟
+  - 💠
+  - 💡
+  - 💢
+  - 💣
+  - 💤
+  - 💥
+  - 💦
+  - 💧
+  - 💨
+  - 💩
+  - 💪
+  - 💫
+  - 💬
+  - 💮
+  - 💯
+  - 💰
+  - 💲
+  - 💳
+  - 💴
+  - 💵
+  - 💸
+  - 💹
+  - 💺
+  - 💻
+  - 💼
+  - 💽
+  - 💾
+  - 💿
+  - 📀
+  - 📁
+  - 📂
+  - 📃
+  - 📄
+  - 📅
+  - 📆
+  - 📇
+  - 📈
+  - 📉
+  - 📊
+  - 📋
+  - 📌
+  - 📍
+  - 📎
+  - 📏
+  - 📐
+  - 📑
+  - 📒
+  - 📓
+  - 📔
+  - 📕
+  - 📖
+  - 📗
+  - 📘
+  - 📙
+  - 📚
+  - 📛
+  - 📜
+  - 📝
+  - 📞
+  - 📟
+  - 📠
+  - 📡
+  - 📢
+  - 📣
+  - 📤
+  - 📥
+  - 📦
+  - 📧
+  - 📨
+  - 📩
+  - 📪
+  - 📫
+  - 📮
+  - 📰
+  - 📱
+  - 📲
+  - 📳
+  - 📴
+  - 📶
+  - 📷
+  - 📹
+  - 📺
+  - 📻
+  - 📼
+  - 🔃
+  - 🔊
+  - 🔋
+  - 🔌
+  - 🔍
+  - 🔎
+  - 🔏
+  - 🔐
+  - 🔑
+  - 🔒
+  - 🔓
+  - 🔔
+  - 🔖
+  - 🔗
+  - 🔘
+  - 🔙
+  - 🔚
+  - 🔛
+  - 🔜
+  - 🔝
+  - 🔞
+  - 🔟
+  - 🔠
+  - 🔡
+  - 🔢
+  - 🔣
+  - 🔤
+  - 🔥
+  - 🔦
+  - 🔧
+  - 🔨
+  - 🔩
+  - 🔪
+  - 🔫
+  - 🔮
+  - 🔯
+  - 🔰
+  - 🔱
+  - 🔲
+  - 🔳
+  - 🔴
+  - 🔵
+  - 🔶
+  - 🔷
+  - 🔸
+  - 🔹
+  - 🔺
+  - 🔻
+  - 🔼
+  - 🔽
+  - 🕐
+  - 🕑
+  - 🕒
+  - 🕓
+  - 🕔
+  - 🕕
+  - 🕖
+  - 🕗
+  - 🕘
+  - 🕙
+  - 🕚
+  - 🕛
+  - 🗻
+  - 🗼
+  - 🗽
+  - 🗾
+  - 🗿
+  - 😀
+  - 😇
+  - 😈
+  - 😎
+  - 😐
+  - 😑
+  - 😕
+  - 😗
+  - 😙
+  - 😛
+  - 😟
+  - 😦
+  - 😧
+  - 😬
+  - 😮
+  - 😯
+  - 😴
+  - 😶
+  - 🚁
+  - 🚂
+  - 🚆
+  - 🚈
+  - 🚊
+  - 🚍
+  - 🚎
+  - 🚐
+  - 🚔
+  - 🚖
+  - 🚘
+  - 🚛
+  - 🚜
+  - 🚝
+  - 🚞
+  - 🚟
+  - 🚠
+  - 🚡
+  - 🚣
+  - 🚦
+  - 🚮
+  - 🚯
+  - 🚰
+  - 🚱
+  - 🚳
+  - 🚴
+  - 🚵
+  - 🚷
+  - 🚸
+  - 🚿
+  - 🛁
+  - 🛂
+  - 🛃
+  - 🛄
+  - 🛅
+  - 🌍
+  - 🌎
+  - 🌐
+  - 🌒
+  - 🌖
+  - 🌗
+  - 🌘
+  - 🌚
+  - 🌜
+  - 🌝
+  - 🌞
+  - 🌲
+  - 🌳
+  - 🍋
+  - 🍐
+  - 🍼
+  - 🏇
+  - 🏉
+  - 🏤
+  - 🐀
+  - 🐁
+  - 🐂
+  - 🐃
+  - 🐄
+  - 🐅
+  - 🐆
+  - 🐇
+  - 🐈
+  - 🐉
+  - 🐊
+  - 🐋
+  - 🐏
+  - 🐐
+  - 🐓
+  - 🐕
+  - 🐖
+  - 🐪
+  - 👥
+  - 👬
+  - 👭
+  - 💭
+  - 💶
+  - 💷
+  - 📬
+  - 📭
+  - 📯
+  - 📵
+  - 🔀
+  - 🔁
+  - 🔂
+  - 🔄
+  - 🔅
+  - 🔆
+  - 🔇
+  - 🔉
+  - 🔕
+  - 🔬
+  - 🔭
+  - 🕜
+  - 🕝
+  - 🕞
+  - 🕟
+  - 🕠
+  - 🕡
+  - 🕢
+  - 🕣
+  - 🕤
+  - 🕥
+  - 🕦
+  - 🕧
diff --git a/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..5857100
--- /dev/null
+++ b/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[749],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,749],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,749],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,749],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,749],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,749],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..fb30f2f
Binary files /dev/null and b/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..bfc972d
--- /dev/null
+++ b/backend/models/V5/arabic_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,790 @@
+Global:
+  model_name: arabic_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ₿
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ●
+  - ▶
+  - 𝑢
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - ︾
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - ¡
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - ₤
+  - ₡
+  - ₹
+  - −
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ™
+  - Ω
+  - ℮
+  - ∆
+  - ✓
+  - ✗
+  - ✘
+  - ▪
+  - ◼
+  - ✔
+  - ✕
+  - ☑
+  - ☒
+  - №
+  - ₽
+  - ₴
+  - Α
+  - α
+  - Β
+  - β
+  - Γ
+  - γ
+  - Δ
+  - δ
+  - Ε
+  - ε
+  - Ζ
+  - ζ
+  - Η
+  - η
+  - Θ
+  - θ
+  - Ι
+  - ι
+  - Κ
+  - κ
+  - Λ
+  - λ
+  - Μ
+  - μ
+  - Ν
+  - ν
+  - Ξ
+  - ξ
+  - Ο
+  - ο
+  - Π
+  - π
+  - Ρ
+  - ρ
+  - Σ
+  - σ
+  - ς
+  - Τ
+  - τ
+  - Υ
+  - υ
+  - Φ
+  - φ
+  - Χ
+  - χ
+  - Ψ
+  - ψ
+  - ω
+  - ـ
+  - ،
+  - ؍
+  - ؎
+  - ؏
+  - ؐ
+  - ؑ
+  - ؒ
+  - ؓ
+  - ؔ
+  - ؕ
+  - ؖ
+  - ؗ
+  - ؘ
+  - ؙ
+  - ؚ
+  - ؛
+  - ؞
+  - ؟
+  - ء
+  - آ
+  - أ
+  - ؤ
+  - إ
+  - ئ
+  - ا
+  - ب
+  - ة
+  - ت
+  - ث
+  - ج
+  - ح
+  - خ
+  - د
+  - ذ
+  - ر
+  - ز
+  - س
+  - ش
+  - ص
+  - ض
+  - ط
+  - ظ
+  - ع
+  - غ
+  - ف
+  - ق
+  - ك
+  - ل
+  - م
+  - ن
+  - ه
+  - و
+  - ى
+  - ي
+  - ً
+  - ٌ
+  - ٍ
+  - َ
+  - ُ
+  - ِ
+  - ّ
+  - ْ
+  - ٓ
+  - ٔ
+  - ٕ
+  - ٖ
+  - ٗ
+  - ٚ
+  - ٛ
+  - ٜ
+  - ٝ
+  - ٞ
+  - ٟ
+  - ٰ
+  - ٱ
+  - ٲ
+  - ٳ
+  - ٴ
+  - ٵ
+  - ٶ
+  - ٷ
+  - ٸ
+  - ٹ
+  - ٺ
+  - ٻ
+  - ټ
+  - ٽ
+  - پ
+  - ٿ
+  - ڀ
+  - ځ
+  - ڂ
+  - ڃ
+  - ڄ
+  - څ
+  - چ
+  - ڇ
+  - ڈ
+  - ډ
+  - ڊ
+  - ڋ
+  - ڌ
+  - ڍ
+  - ڎ
+  - ڏ
+  - ڐ
+  - ڑ
+  - ڒ
+  - ړ
+  - ڔ
+  - ڕ
+  - ږ
+  - ڗ
+  - ژ
+  - ڙ
+  - ښ
+  - ڛ
+  - ڜ
+  - ڝ
+  - ڞ
+  - ڟ
+  - ڠ
+  - ڡ
+  - ڢ
+  - ڣ
+  - ڤ
+  - ڥ
+  - ڦ
+  - ڧ
+  - ڨ
+  - ک
+  - ڪ
+  - ګ
+  - ڬ
+  - ڭ
+  - ڮ
+  - گ
+  - ڰ
+  - ڱ
+  - ڲ
+  - ڳ
+  - ڴ
+  - ڵ
+  - ڶ
+  - ڷ
+  - ڸ
+  - ڹ
+  - ں
+  - ڻ
+  - ڼ
+  - ڽ
+  - ھ
+  - ڿ
+  - ۀ
+  - ہ
+  - ۂ
+  - ۃ
+  - ۄ
+  - ۅ
+  - ۆ
+  - ۇ
+  - ۈ
+  - ۉ
+  - ۊ
+  - ۋ
+  - ی
+  - ۍ
+  - ێ
+  - ۏ
+  - ې
+  - ۑ
+  - ے
+  - ۓ
+  - ۔
+  - ە
+  - ۖ
+  - ۗ
+  - ۘ
+  - ۙ
+  - ۚ
+  - ۛ
+  - ۜ
+  - ۞
+  - ۡ
+  - ۢ
+  - ۣ
+  - ۤ
+  - ۥ
+  - ۦ
+  - ۧ
+  - ۨ
+  - ۩
+  - ۭ
+  - ۮ
+  - ۯ
+  - ݐ
+  - ݑ
+  - ݒ
+  - ݓ
+  - ݔ
+  - ݕ
+  - ݖ
+  - ݗ
+  - ݘ
+  - ݙ
+  - ݚ
+  - ݛ
+  - ݜ
+  - ݝ
+  - ݞ
+  - ݟ
+  - ݠ
+  - ݡ
+  - ݢ
+  - ݣ
+  - ݤ
+  - ݥ
+  - ݦ
+  - ݧ
+  - ݨ
+  - ݩ
+  - ݪ
+  - ݫ
+  - ݬ
+  - ݭ
+  - ݮ
+  - ݯ
+  - ݰ
+  - ݱ
+  - ݲ
+  - ݳ
+  - ݴ
+  - ݵ
+  - ݶ
+  - ݷ
+  - ݸ
+  - ݹ
+  - ݺ
+  - ݻ
+  - ݼ
+  - ݽ
+  - ݾ
+  - ݿ
+  - ٠
+  - ١
+  - ٢
+  - ٣
+  - ٤
+  - ٥
+  - ٦
+  - ٧
+  - ٨
+  - ٩
+  - ٪
+  - ٫
+  - ٬
+  - ۰
+  - ۱
+  - ۲
+  - ۳
+  - ۴
+  - ۵
+  - ۶
+  - ۷
+  - ۸
+  - ۹
+  - ﭙ
+  - ﭚ
+  - ﭪ
+  - ﭭ
+  - ﭺ
+  - ﭽ
+  - ﷲ
+  - ﷼
+  - ٠
+  - ١
+  - ٢
+  - ٣
+  - ٤
+  - ٥
+  - ٦
+  - ٧
+  - ٨
+  - ٩
+  - ٪
+  - ٫
+  - ٬
+  - ۰
+  - ۱
+  - ۲
+  - ۳
+  - ۴
+  - ۵
+  - ۶
+  - ۷
+  - ۸
+  - ۹
+  - ﭙ
+  - ﭚ
+  - ﭪ
+  - ﭭ
+  - ﭺ
+  - ﭽ
+  - ﷲ
+  - ﷼
diff --git a/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..ca91c89
--- /dev/null
+++ b/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[852],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,852],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,852],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,852],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,852],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,852],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..91da745
Binary files /dev/null and b/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..6de7a2d
--- /dev/null
+++ b/backend/models/V5/cyrillic_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,893 @@
+Global:
+  model_name: cyrillic_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ₿
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ●
+  - ▶
+  - 𝑢
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - ︾
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - ¡
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - ₤
+  - ₡
+  - ₹
+  - −
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ™
+  - Ω
+  - ℮
+  - ∆
+  - ✓
+  - ✗
+  - ✘
+  - ▪
+  - ◼
+  - ✔
+  - ✕
+  - ☑
+  - ☒
+  - №
+  - ₽
+  - ₴
+  - Α
+  - α
+  - Β
+  - β
+  - Γ
+  - γ
+  - Δ
+  - δ
+  - Ε
+  - ε
+  - Ζ
+  - ζ
+  - Η
+  - η
+  - Θ
+  - θ
+  - Ι
+  - ι
+  - Κ
+  - κ
+  - Λ
+  - λ
+  - Μ
+  - μ
+  - Ν
+  - ν
+  - Ξ
+  - ξ
+  - Ο
+  - ο
+  - Π
+  - π
+  - Ρ
+  - ρ
+  - Σ
+  - σ
+  - ς
+  - Τ
+  - τ
+  - Υ
+  - υ
+  - Φ
+  - φ
+  - Χ
+  - χ
+  - Ψ
+  - ψ
+  - ω
+  - Ѐ
+  - Ё
+  - Ђ
+  - Ѓ
+  - Є
+  - Ѕ
+  - І
+  - Ї
+  - Ј
+  - Љ
+  - Њ
+  - Ћ
+  - Ќ
+  - Ѝ
+  - Ў
+  - Џ
+  - А
+  - Б
+  - В
+  - Г
+  - Д
+  - Е
+  - Ж
+  - З
+  - И
+  - Й
+  - К
+  - Л
+  - М
+  - Н
+  - О
+  - П
+  - Р
+  - С
+  - Т
+  - У
+  - Ф
+  - Х
+  - Ц
+  - Ч
+  - Ш
+  - Щ
+  - Ъ
+  - Ы
+  - Ь
+  - Э
+  - Ю
+  - Я
+  - а
+  - б
+  - в
+  - г
+  - д
+  - е
+  - ж
+  - з
+  - и
+  - й
+  - к
+  - л
+  - м
+  - н
+  - о
+  - п
+  - р
+  - с
+  - т
+  - у
+  - ф
+  - х
+  - ц
+  - ч
+  - ш
+  - щ
+  - ъ
+  - ы
+  - ь
+  - э
+  - ю
+  - я
+  - ѐ
+  - ё
+  - ђ
+  - ѓ
+  - є
+  - ѕ
+  - і
+  - ї
+  - ј
+  - љ
+  - њ
+  - ћ
+  - ќ
+  - ѝ
+  - ў
+  - џ
+  - Ѡ
+  - ѡ
+  - Ѣ
+  - ѣ
+  - Ѥ
+  - ѥ
+  - Ѧ
+  - ѧ
+  - Ѩ
+  - ѩ
+  - Ѫ
+  - ѫ
+  - Ѭ
+  - ѭ
+  - Ѯ
+  - ѯ
+  - Ѱ
+  - ѱ
+  - Ѳ
+  - ѳ
+  - Ѵ
+  - ѵ
+  - Ѷ
+  - ѷ
+  - Ѹ
+  - ѹ
+  - Ѻ
+  - ѻ
+  - Ѽ
+  - ѽ
+  - Ѿ
+  - ѿ
+  - Ҁ
+  - ҁ
+  - Ҋ
+  - ҋ
+  - Ҍ
+  - ҍ
+  - Ҏ
+  - ҏ
+  - Ґ
+  - ґ
+  - Ғ
+  - ғ
+  - Ҕ
+  - ҕ
+  - Җ
+  - җ
+  - Ҙ
+  - ҙ
+  - Қ
+  - қ
+  - Ҝ
+  - ҝ
+  - Ҟ
+  - ҟ
+  - Ҡ
+  - ҡ
+  - Ң
+  - ң
+  - Ҧ
+  - ҧ
+  - Ҩ
+  - ҩ
+  - Ҫ
+  - ҫ
+  - Ҭ
+  - ҭ
+  - Ү
+  - ү
+  - Ұ
+  - ұ
+  - Ҳ
+  - ҳ
+  - Ҷ
+  - ҷ
+  - Ҹ
+  - ҹ
+  - Һ
+  - һ
+  - Ҽ
+  - ҽ
+  - Ҿ
+  - ҿ
+  - Ӏ
+  - Ӂ
+  - ӂ
+  - Ӄ
+  - ӄ
+  - Ӆ
+  - ӆ
+  - Ӈ
+  - ӈ
+  - Ӊ
+  - ӊ
+  - Ӌ
+  - ӌ
+  - Ӎ
+  - ӎ
+  - ӏ
+  - Ӑ
+  - ӑ
+  - Ӓ
+  - ӓ
+  - Ӗ
+  - ӗ
+  - Ә
+  - ә
+  - Ӛ
+  - ӛ
+  - Ӝ
+  - ӝ
+  - Ӟ
+  - ӟ
+  - Ӡ
+  - ӡ
+  - Ӣ
+  - ӣ
+  - Ӥ
+  - ӥ
+  - Ӧ
+  - ӧ
+  - Ө
+  - ө
+  - Ӫ
+  - ӫ
+  - Ӭ
+  - ӭ
+  - Ӯ
+  - ӯ
+  - Ӱ
+  - ӱ
+  - Ӳ
+  - ӳ
+  - Ӵ
+  - ӵ
+  - Ӷ
+  - ӷ
+  - Ӹ
+  - ӹ
+  - Ӻ
+  - ӻ
+  - Ӽ
+  - ӽ
+  - Ӿ
+  - ӿ
+  - Ԁ
+  - ԁ
+  - Ԃ
+  - ԃ
+  - Ԅ
+  - ԅ
+  - Ԇ
+  - ԇ
+  - Ԉ
+  - ԉ
+  - Ԋ
+  - ԋ
+  - Ԍ
+  - ԍ
+  - Ԏ
+  - ԏ
+  - Ԑ
+  - ԑ
+  - Ԓ
+  - ԓ
+  - Ԕ
+  - ԕ
+  - Ԗ
+  - ԗ
+  - Ԙ
+  - ԙ
+  - Ԛ
+  - ԛ
+  - Ԝ
+  - ԝ
+  - Ԟ
+  - ԟ
+  - Ԡ
+  - ԡ
+  - Ԣ
+  - ԣ
+  - Ԥ
+  - ԥ
+  - Ԧ
+  - ԧ
+  - Ԩ
+  - ԩ
+  - Ԫ
+  - ԫ
+  - Ԭ
+  - ԭ
+  - Ԯ
+  - ԯ
+  - ⷠ
+  - ⷡ
+  - ⷢ
+  - ⷣ
+  - ⷤ
+  - ⷥ
+  - ⷦ
+  - ⷧ
+  - ⷨ
+  - ⷩ
+  - ⷪ
+  - ⷫ
+  - ⷬ
+  - ⷭ
+  - ⷮ
+  - ⷯ
+  - ⷰ
+  - ⷱ
+  - ⷲ
+  - ⷳ
+  - ⷴ
+  - ⷵ
+  - ⷶ
+  - ⷷ
+  - ⷸ
+  - ⷹ
+  - ⷺ
+  - ⷻ
+  - ⷼ
+  - ⷽ
+  - ⷾ
+  - ⷿ
+  - Ꙁ
+  - ꙁ
+  - Ꙃ
+  - ꙃ
+  - Ꙅ
+  - ꙅ
+  - Ꙇ
+  - ꙇ
+  - Ꙉ
+  - ꙉ
+  - Ꙋ
+  - ꙋ
+  - Ꙍ
+  - ꙍ
+  - Ꙏ
+  - ꙏ
+  - Ꙑ
+  - ꙑ
+  - Ꙓ
+  - ꙓ
+  - Ꙕ
+  - ꙕ
+  - Ꙗ
+  - ꙗ
+  - Ꙙ
+  - ꙙ
+  - Ꙛ
+  - ꙛ
+  - Ꙝ
+  - ꙝ
+  - Ꙟ
+  - ꙟ
+  - Ꙡ
+  - ꙡ
+  - Ꙣ
+  - ꙣ
+  - Ꙥ
+  - ꙥ
+  - Ꙧ
+  - ꙧ
+  - Ꙩ
+  - ꙩ
+  - Ꙫ
+  - ꙫ
+  - Ꙭ
+  - ꙭ
+  - ꙮ
+  - ꙴ
+  - ꙵ
+  - ꙶ
+  - ꙷ
+  - ꙸ
+  - ꙹ
+  - ꙺ
+  - ꙻ
+  - Ꚁ
+  - ꚁ
+  - Ꚃ
+  - ꚃ
+  - Ꚅ
+  - ꚅ
+  - Ꚇ
+  - ꚇ
+  - Ꚉ
+  - ꚉ
+  - Ꚋ
+  - ꚋ
+  - Ꚍ
+  - ꚍ
+  - Ꚏ
+  - ꚏ
+  - Ꚑ
+  - ꚑ
+  - Ꚓ
+  - ꚓ
+  - Ꚕ
+  - ꚕ
+  - Ꚗ
+  - ꚗ
+  - Ꚙ
+  - ꚙ
+  - Ꚛ
+  - ꚛ
+  - ꚜ
+  - ꚝ
+  - ꚞ
+  - ꚟ
diff --git a/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/export_result.json b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/export_result.json
new file mode 100644
index 0000000..94d6f57
--- /dev/null
+++ b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/export_result.json
@@ -0,0 +1,5 @@
+{
+  "done_flag": false,
+  "err_type": "<class 'AssertionError'>",
+  "err_msg": "only support yaml files for now"
+}
\ No newline at end of file
diff --git a/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..c8074e0
--- /dev/null
+++ b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[570],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,570],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..279b505
Binary files /dev/null and b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..777c300
--- /dev/null
+++ b/backend/models/V5/devanagari_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,611 @@
+Global:
+  model_name: devanagari_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ₿
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ●
+  - ▶
+  - 𝑢
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - ︾
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - ¡
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - ₤
+  - ₡
+  - ₹
+  - −
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ™
+  - Ω
+  - ℮
+  - ∆
+  - ✓
+  - ✗
+  - ✘
+  - ▪
+  - ◼
+  - ✔
+  - ✕
+  - ☑
+  - ☒
+  - №
+  - ₽
+  - ₴
+  - Α
+  - α
+  - Β
+  - β
+  - Γ
+  - γ
+  - Δ
+  - δ
+  - Ε
+  - ε
+  - Ζ
+  - ζ
+  - Η
+  - η
+  - Θ
+  - θ
+  - Ι
+  - ι
+  - Κ
+  - κ
+  - Λ
+  - λ
+  - Μ
+  - μ
+  - Ν
+  - ν
+  - Ξ
+  - ξ
+  - Ο
+  - ο
+  - Π
+  - π
+  - Ρ
+  - ρ
+  - Σ
+  - σ
+  - ς
+  - Τ
+  - τ
+  - Υ
+  - υ
+  - Φ
+  - φ
+  - Χ
+  - χ
+  - Ψ
+  - ψ
+  - ω
+  - ऀ
+  - ँ
+  - ं
+  - ः
+  - ऄ
+  - अ
+  - आ
+  - इ
+  - ई
+  - उ
+  - ऊ
+  - ऋ
+  - ऌ
+  - ऍ
+  - ऎ
+  - ए
+  - ऐ
+  - ऑ
+  - ऒ
+  - ओ
+  - औ
+  - क
+  - ख
+  - ग
+  - घ
+  - ङ
+  - च
+  - छ
+  - ज
+  - झ
+  - ञ
+  - ट
+  - ठ
+  - ड
+  - ढ
+  - ण
+  - त
+  - थ
+  - द
+  - ध
+  - न
+  - ऩ
+  - प
+  - फ
+  - ब
+  - भ
+  - म
+  - य
+  - र
+  - ऱ
+  - ल
+  - ळ
+  - ऴ
+  - व
+  - श
+  - ष
+  - स
+  - ह
+  - ऺ
+  - ऻ
+  - ़
+  - ऽ
+  - ा
+  - ि
+  - ी
+  - ु
+  - ू
+  - ृ
+  - ॄ
+  - ॅ
+  - ॆ
+  - े
+  - ै
+  - ॉ
+  - ॊ
+  - ो
+  - ौ
+  - ्
+  - ॎ
+  - ॏ
+  - ॐ
+  - ॑
+  - ॒
+  - ॓
+  - ॔
+  - ॕ
+  - ॖ
+  - ॗ
+  - क़
+  - ख़
+  - ग़
+  - ज़
+  - ड़
+  - ढ़
+  - फ़
+  - य़
+  - ॠ
+  - ॡ
+  - ॢ
+  - ॣ
+  - ।
+  - ॥
+  - ०
+  - १
+  - २
+  - ३
+  - ४
+  - ५
+  - ६
+  - ७
+  - ८
+  - ९
+  - ॰
+  - ॱ
+  - ॲ
+  - ॳ
+  - ॴ
+  - ॵ
+  - ॶ
+  - ॷ
+  - ॸ
+  - ॹ
+  - ॺ
+  - ॻ
+  - ॼ
+  - ॽ
+  - ॾ
+  - ॿ
diff --git a/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..a3c91c3
--- /dev/null
+++ b/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[356],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,356],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,356],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,356],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,356],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,356],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..9d1abf0
Binary files /dev/null and b/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..ac31797
--- /dev/null
+++ b/backend/models/V5/el_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,397 @@
+Global:
+  model_name: el_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - '@'
+  - '['
+  - ']'
+  - _
+  - '`'
+  - ^
+  - '~'
+  - ©
+  - ®
+  - ™
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ·
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ÷
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - †
+  - ‡
+  - …
+  - ‰
+  - ′
+  - ″
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‹
+  - ›
+  - ‼
+  - ‽
+  - ‾
+  - €
+  - £
+  - ¥
+  - ¢
+  - ₤
+  - ₡
+  - ₽
+  - ₴
+  - ₹
+  - ₿
+  - ±
+  - ∓
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ∑
+  - ∏
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - √
+  - ∛
+  - ∜
+  - ∝
+  - ∞
+  - ∂
+  - ∇
+  - ∴
+  - ∵
+  - ∷
+  - ∠
+  - ∡
+  - ∢
+  - ∟
+  - ∦
+  - ∩
+  - ∪
+  - ∗
+  - ∖
+  - ∥
+  - ∧
+  - ∨
+  - ⊂
+  - ⊃
+  - ⊥
+  - ∈
+  - ∋
+  - ∉
+  - ∅
+  - ↑
+  - →
+  - ↓
+  - ↔
+  - ↕
+  - ←
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - Α
+  - Β
+  - Γ
+  - Δ
+  - Ε
+  - Ζ
+  - Η
+  - Θ
+  - Ι
+  - Κ
+  - Λ
+  - Μ
+  - Ν
+  - Ξ
+  - Ο
+  - Π
+  - Ρ
+  - Σ
+  - Τ
+  - Υ
+  - Φ
+  - Χ
+  - Ψ
+  - Ω
+  - ά
+  - έ
+  - ή
+  - ί
+  - ό
+  - ύ
+  - ώ
+  - Ϊ
+  - Ϋ
+  - Ά
+  - Έ
+  - Ή
+  - Ί
+  - Ό
+  - Ύ
+  - Ώ
+  - ϊ
+  - ΐ
+  - ϋ
+  - ΰ
+  - α
+  - β
+  - γ
+  - δ
+  - ε
+  - ζ
+  - η
+  - θ
+  - ι
+  - κ
+  - λ
+  - μ
+  - ν
+  - ξ
+  - ο
+  - π
+  - ρ
+  - ς
+  - σ
+  - τ
+  - υ
+  - φ
+  - χ
+  - ψ
+  - ω
+  - ϐ
+  - ϑ
+  - ϒ
+  - ϓ
+  - ϔ
+  - ϕ
+  - ϖ
+  - Ϛ
+  - ϛ
+  - Ϝ
+  - ϝ
+  - Ϟ
+  - ϟ
+  - Ϡ
+  - ϡ
+  - Ϣ
+  - ϣ
+  - Ϥ
+  - ϥ
+  - Ϧ
+  - ϧ
+  - Ϩ
+  - ϩ
+  - Ϫ
+  - ϫ
+  - Ϭ
+  - ϭ
+  - Ϯ
+  - ϯ
+  - ϰ
+  - ϱ
+  - ϲ
+  - ϳ
+  - ϴ
+  - ϵ
+  - ϶
+  - Ϸ
+  - ϸ
+  - Ϲ
+  - Ϻ
+  - ϻ
diff --git a/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/.gitattributes b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/.gitattributes
new file mode 100644
index 0000000..c48a31d
--- /dev/null
+++ b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/.gitattributes
@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+inference.pdiparams filter=lfs diff=lfs merge=lfs -text
diff --git a/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..68150a7
--- /dev/null
+++ b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[519],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,519],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,519],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,519],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,519],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,519],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..0eaaeb3
--- /dev/null
+++ b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.pdiparams
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f11057b05d8517868bca505271278973d706600d9dcc184cbcf5c4512091c32b
+size 7811519
diff --git a/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..0015bad
--- /dev/null
+++ b/backend/models/V5/eslav_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,560 @@
+Global:
+  model_name: eslav_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ₿
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ●
+  - ▶
+  - 𝑢
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - ︾
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - ¡
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - ₤
+  - ₡
+  - ₹
+  - −
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ™
+  - Ω
+  - ℮
+  - ∆
+  - ✓
+  - ✗
+  - ✘
+  - ▪
+  - ◼
+  - ✔
+  - ✕
+  - ☑
+  - ☒
+  - №
+  - ₽
+  - ₴
+  - Α
+  - α
+  - Β
+  - β
+  - Γ
+  - γ
+  - Δ
+  - δ
+  - Ε
+  - ε
+  - Ζ
+  - ζ
+  - Η
+  - η
+  - Θ
+  - θ
+  - Ι
+  - ι
+  - Κ
+  - κ
+  - Λ
+  - λ
+  - Μ
+  - μ
+  - Ν
+  - ν
+  - Ξ
+  - ξ
+  - Ο
+  - ο
+  - Π
+  - π
+  - Ρ
+  - ρ
+  - Σ
+  - σ
+  - ς
+  - Τ
+  - τ
+  - Υ
+  - υ
+  - Φ
+  - φ
+  - Χ
+  - χ
+  - Ψ
+  - ψ
+  - ω
+  - А
+  - Б
+  - В
+  - Г
+  - Ґ
+  - Д
+  - Е
+  - Ё
+  - Є
+  - Ж
+  - З
+  - И
+  - І
+  - Ї
+  - Й
+  - К
+  - Л
+  - М
+  - Н
+  - О
+  - П
+  - Р
+  - С
+  - Т
+  - У
+  - Ў
+  - Ф
+  - Х
+  - Ц
+  - Ч
+  - Ш
+  - Щ
+  - Ъ
+  - Ы
+  - Ь
+  - Э
+  - Ю
+  - Я
+  - а
+  - б
+  - в
+  - г
+  - ґ
+  - д
+  - е
+  - ё
+  - є
+  - ж
+  - з
+  - и
+  - і
+  - ї
+  - й
+  - к
+  - л
+  - м
+  - н
+  - о
+  - п
+  - р
+  - с
+  - т
+  - у
+  - ў
+  - ф
+  - х
+  - ц
+  - ч
+  - ш
+  - щ
+  - ъ
+  - ы
+  - ь
+  - э
+  - ю
+  - я
diff --git a/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/.gitattributes b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/.gitattributes
new file mode 100644
index 0000000..c48a31d
--- /dev/null
+++ b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/.gitattributes
@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+inference.pdiparams filter=lfs diff=lfs merge=lfs -text
diff --git a/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..7507436
--- /dev/null
+++ b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[11947],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,11947],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,11947],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,11947],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,11947],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,11947],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..005af2b
--- /dev/null
+++ b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.pdiparams
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cac3e5f12cf04aaa77f6a5bc704e4e736ef2908476551891d84b41b4e9090462
+size 13342671
diff --git a/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..ba8f60f
--- /dev/null
+++ b/backend/models/V5/korean_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,11988 @@
+Global:
+  model_name: korean_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - ᄀ
+  - ᄁ
+  - ᄂ
+  - ᄃ
+  - ᄄ
+  - ᄅ
+  - ᄆ
+  - ᄇ
+  - ᄈ
+  - ᄉ
+  - ᄊ
+  - ᄋ
+  - ᄌ
+  - ᄍ
+  - ᄎ
+  - ᄏ
+  - ᄐ
+  - ᄑ
+  - ᄒ
+  - ᄓ
+  - ᄔ
+  - ᄕ
+  - ᄖ
+  - ᄗ
+  - ᄘ
+  - ᄙ
+  - ᄚ
+  - ᄛ
+  - ᄜ
+  - ᄝ
+  - ᄞ
+  - ᄟ
+  - ᄠ
+  - ᄡ
+  - ᄢ
+  - ᄣ
+  - ᄤ
+  - ᄥ
+  - ᄦ
+  - ᄧ
+  - ᄨ
+  - ᄩ
+  - ᄪ
+  - ᄫ
+  - ᄬ
+  - ᄭ
+  - ᄮ
+  - ᄯ
+  - ᄰ
+  - ᄱ
+  - ᄲ
+  - ᄳ
+  - ᄴ
+  - ᄵ
+  - ᄶ
+  - ᄷ
+  - ᄸ
+  - ᄹ
+  - ᄺ
+  - ᄻ
+  - ᄼ
+  - ᄽ
+  - ᄾ
+  - ᄿ
+  - ᅀ
+  - ᅁ
+  - ᅂ
+  - ᅃ
+  - ᅄ
+  - ᅅ
+  - ᅆ
+  - ᅇ
+  - ᅈ
+  - ᅉ
+  - ᅊ
+  - ᅋ
+  - ᅌ
+  - ᅍ
+  - ᅎ
+  - ᅏ
+  - ᅐ
+  - ᅑ
+  - ᅒ
+  - ᅓ
+  - ᅔ
+  - ᅕ
+  - ᅖ
+  - ᅗ
+  - ᅘ
+  - ᅙ
+  - ᅡ
+  - ᅢ
+  - ᅣ
+  - ᅤ
+  - ᅥ
+  - ᅦ
+  - ᅧ
+  - ᅨ
+  - ᅩ
+  - ᅪ
+  - ᅫ
+  - ᅬ
+  - ᅭ
+  - ᅮ
+  - ᅯ
+  - ᅰ
+  - ᅱ
+  - ᅲ
+  - ᅳ
+  - ᅴ
+  - ᅵ
+  - ᅶ
+  - ᅷ
+  - ᅸ
+  - ᅹ
+  - ᅺ
+  - ᅻ
+  - ᅼ
+  - ᅽ
+  - ᅾ
+  - ᅿ
+  - ᆀ
+  - ᆁ
+  - ᆂ
+  - ᆃ
+  - ᆄ
+  - ᆅ
+  - ᆆ
+  - ᆇ
+  - ᆈ
+  - ᆉ
+  - ᆊ
+  - ᆋ
+  - ᆌ
+  - ᆍ
+  - ᆎ
+  - ᆏ
+  - ᆐ
+  - ᆑ
+  - ᆒ
+  - ᆓ
+  - ᆔ
+  - ᆕ
+  - ᆖ
+  - ᆗ
+  - ᆘ
+  - ᆙ
+  - ᆚ
+  - ᆛ
+  - ᆜ
+  - ᆝ
+  - ᆞ
+  - ᆟ
+  - ᆠ
+  - ᆡ
+  - ᆢ
+  - ᆨ
+  - ᆩ
+  - ᆪ
+  - ᆫ
+  - ᆬ
+  - ᆭ
+  - ᆮ
+  - ᆯ
+  - ᆰ
+  - ᆱ
+  - ᆲ
+  - ᆳ
+  - ᆴ
+  - ᆵ
+  - ᆶ
+  - ᆷ
+  - ᆸ
+  - ᆹ
+  - ᆺ
+  - ᆻ
+  - ᆼ
+  - ᆽ
+  - ᆾ
+  - ᆿ
+  - ᇀ
+  - ᇁ
+  - ᇂ
+  - ᇃ
+  - ᇄ
+  - ᇅ
+  - ᇆ
+  - ᇇ
+  - ᇈ
+  - ᇉ
+  - ᇊ
+  - ᇋ
+  - ᇌ
+  - ᇍ
+  - ᇎ
+  - ᇏ
+  - ᇐ
+  - ᇑ
+  - ᇒ
+  - ᇓ
+  - ᇔ
+  - ᇕ
+  - ᇖ
+  - ᇗ
+  - ᇘ
+  - ᇙ
+  - ᇚ
+  - ᇛ
+  - ᇜ
+  - ᇝ
+  - ᇞ
+  - ᇟ
+  - ᇠ
+  - ᇡ
+  - ᇢ
+  - ᇣ
+  - ᇤ
+  - ᇥ
+  - ᇦ
+  - ᇧ
+  - ᇨ
+  - ᇩ
+  - ᇪ
+  - ᇫ
+  - ᇬ
+  - ᇭ
+  - ᇮ
+  - ᇯ
+  - ᇰ
+  - ᇱ
+  - ᇲ
+  - ᇳ
+  - ᇴ
+  - ᇵ
+  - ᇶ
+  - ᇷ
+  - ᇸ
+  - ᇹ
+  - ㄱ
+  - ㄲ
+  - ㄳ
+  - ㄴ
+  - ㄵ
+  - ㄶ
+  - ㄷ
+  - ㄸ
+  - ㄹ
+  - ㄺ
+  - ㄻ
+  - ㄼ
+  - ㄽ
+  - ㄾ
+  - ㄿ
+  - ㅀ
+  - ㅁ
+  - ㅂ
+  - ㅃ
+  - ㅄ
+  - ㅅ
+  - ㅆ
+  - ㅇ
+  - ㅈ
+  - ㅉ
+  - ㅊ
+  - ㅋ
+  - ㅌ
+  - ㅍ
+  - ㅎ
+  - ㅏ
+  - ㅐ
+  - ㅑ
+  - ㅒ
+  - ㅓ
+  - ㅔ
+  - ㅕ
+  - ㅖ
+  - ㅗ
+  - ㅘ
+  - ㅙ
+  - ㅚ
+  - ㅛ
+  - ㅜ
+  - ㅝ
+  - ㅞ
+  - ㅟ
+  - ㅠ
+  - ㅡ
+  - ㅢ
+  - ㅣ
+  - ㅤ
+  - ㅥ
+  - ㅦ
+  - ㅧ
+  - ㅨ
+  - ㅩ
+  - ㅪ
+  - ㅫ
+  - ㅬ
+  - ㅭ
+  - ㅮ
+  - ㅯ
+  - ㅰ
+  - ㅱ
+  - ㅲ
+  - ㅳ
+  - ㅴ
+  - ㅵ
+  - ㅶ
+  - ㅷ
+  - ㅸ
+  - ㅹ
+  - ㅺ
+  - ㅻ
+  - ㅼ
+  - ㅽ
+  - ㅾ
+  - ㅿ
+  - ㆀ
+  - ㆁ
+  - ㆂ
+  - ㆃ
+  - ㆄ
+  - ㆅ
+  - ㆆ
+  - ㆇ
+  - ㆈ
+  - ㆉ
+  - ㆊ
+  - ㆋ
+  - ㆌ
+  - ㆍ
+  - ㆎ
+  - 가
+  - 각
+  - 갂
+  - 갃
+  - 간
+  - 갅
+  - 갆
+  - 갇
+  - 갈
+  - 갉
+  - 갊
+  - 갋
+  - 갌
+  - 갍
+  - 갎
+  - 갏
+  - 감
+  - 갑
+  - 값
+  - 갓
+  - 갔
+  - 강
+  - 갖
+  - 갗
+  - 갘
+  - 같
+  - 갚
+  - 갛
+  - 개
+  - 객
+  - 갞
+  - 갟
+  - 갠
+  - 갡
+  - 갢
+  - 갣
+  - 갤
+  - 갥
+  - 갦
+  - 갧
+  - 갨
+  - 갩
+  - 갪
+  - 갫
+  - 갬
+  - 갭
+  - 갮
+  - 갯
+  - 갰
+  - 갱
+  - 갲
+  - 갳
+  - 갴
+  - 갵
+  - 갶
+  - 갷
+  - 갸
+  - 갹
+  - 갺
+  - 갻
+  - 갼
+  - 갽
+  - 갾
+  - 갿
+  - 걀
+  - 걁
+  - 걂
+  - 걃
+  - 걄
+  - 걅
+  - 걆
+  - 걇
+  - 걈
+  - 걉
+  - 걊
+  - 걋
+  - 걌
+  - 걍
+  - 걎
+  - 걏
+  - 걐
+  - 걑
+  - 걒
+  - 걓
+  - 걔
+  - 걕
+  - 걖
+  - 걗
+  - 걘
+  - 걙
+  - 걚
+  - 걛
+  - 걜
+  - 걝
+  - 걞
+  - 걟
+  - 걠
+  - 걡
+  - 걢
+  - 걣
+  - 걤
+  - 걥
+  - 걦
+  - 걧
+  - 걨
+  - 걩
+  - 걪
+  - 걫
+  - 걬
+  - 걭
+  - 걮
+  - 걯
+  - 거
+  - 걱
+  - 걲
+  - 걳
+  - 건
+  - 걵
+  - 걶
+  - 걷
+  - 걸
+  - 걹
+  - 걺
+  - 걻
+  - 걼
+  - 걽
+  - 걾
+  - 걿
+  - 검
+  - 겁
+  - 겂
+  - 것
+  - 겄
+  - 겅
+  - 겆
+  - 겇
+  - 겈
+  - 겉
+  - 겊
+  - 겋
+  - 게
+  - 겍
+  - 겎
+  - 겏
+  - 겐
+  - 겑
+  - 겒
+  - 겓
+  - 겔
+  - 겕
+  - 겖
+  - 겗
+  - 겘
+  - 겙
+  - 겚
+  - 겛
+  - 겜
+  - 겝
+  - 겞
+  - 겟
+  - 겠
+  - 겡
+  - 겢
+  - 겣
+  - 겤
+  - 겥
+  - 겦
+  - 겧
+  - 겨
+  - 격
+  - 겪
+  - 겫
+  - 견
+  - 겭
+  - 겮
+  - 겯
+  - 결
+  - 겱
+  - 겲
+  - 겳
+  - 겴
+  - 겵
+  - 겶
+  - 겷
+  - 겸
+  - 겹
+  - 겺
+  - 겻
+  - 겼
+  - 경
+  - 겾
+  - 겿
+  - 곀
+  - 곁
+  - 곂
+  - 곃
+  - 계
+  - 곅
+  - 곆
+  - 곇
+  - 곈
+  - 곉
+  - 곊
+  - 곋
+  - 곌
+  - 곍
+  - 곎
+  - 곏
+  - 곐
+  - 곑
+  - 곒
+  - 곓
+  - 곔
+  - 곕
+  - 곖
+  - 곗
+  - 곘
+  - 곙
+  - 곚
+  - 곛
+  - 곜
+  - 곝
+  - 곞
+  - 곟
+  - 고
+  - 곡
+  - 곢
+  - 곣
+  - 곤
+  - 곥
+  - 곦
+  - 곧
+  - 골
+  - 곩
+  - 곪
+  - 곫
+  - 곬
+  - 곭
+  - 곮
+  - 곯
+  - 곰
+  - 곱
+  - 곲
+  - 곳
+  - 곴
+  - 공
+  - 곶
+  - 곷
+  - 곸
+  - 곹
+  - 곺
+  - 곻
+  - 과
+  - 곽
+  - 곾
+  - 곿
+  - 관
+  - 괁
+  - 괂
+  - 괃
+  - 괄
+  - 괅
+  - 괆
+  - 괇
+  - 괈
+  - 괉
+  - 괊
+  - 괋
+  - 괌
+  - 괍
+  - 괎
+  - 괏
+  - 괐
+  - 광
+  - 괒
+  - 괓
+  - 괔
+  - 괕
+  - 괖
+  - 괗
+  - 괘
+  - 괙
+  - 괚
+  - 괛
+  - 괜
+  - 괝
+  - 괞
+  - 괟
+  - 괠
+  - 괡
+  - 괢
+  - 괣
+  - 괤
+  - 괥
+  - 괦
+  - 괧
+  - 괨
+  - 괩
+  - 괪
+  - 괫
+  - 괬
+  - 괭
+  - 괮
+  - 괯
+  - 괰
+  - 괱
+  - 괲
+  - 괳
+  - 괴
+  - 괵
+  - 괶
+  - 괷
+  - 괸
+  - 괹
+  - 괺
+  - 괻
+  - 괼
+  - 괽
+  - 괾
+  - 괿
+  - 굀
+  - 굁
+  - 굂
+  - 굃
+  - 굄
+  - 굅
+  - 굆
+  - 굇
+  - 굈
+  - 굉
+  - 굊
+  - 굋
+  - 굌
+  - 굍
+  - 굎
+  - 굏
+  - 교
+  - 굑
+  - 굒
+  - 굓
+  - 굔
+  - 굕
+  - 굖
+  - 굗
+  - 굘
+  - 굙
+  - 굚
+  - 굛
+  - 굜
+  - 굝
+  - 굞
+  - 굟
+  - 굠
+  - 굡
+  - 굢
+  - 굣
+  - 굤
+  - 굥
+  - 굦
+  - 굧
+  - 굨
+  - 굩
+  - 굪
+  - 굫
+  - 구
+  - 국
+  - 굮
+  - 굯
+  - 군
+  - 굱
+  - 굲
+  - 굳
+  - 굴
+  - 굵
+  - 굶
+  - 굷
+  - 굸
+  - 굹
+  - 굺
+  - 굻
+  - 굼
+  - 굽
+  - 굾
+  - 굿
+  - 궀
+  - 궁
+  - 궂
+  - 궃
+  - 궄
+  - 궅
+  - 궆
+  - 궇
+  - 궈
+  - 궉
+  - 궊
+  - 궋
+  - 권
+  - 궍
+  - 궎
+  - 궏
+  - 궐
+  - 궑
+  - 궒
+  - 궓
+  - 궔
+  - 궕
+  - 궖
+  - 궗
+  - 궘
+  - 궙
+  - 궚
+  - 궛
+  - 궜
+  - 궝
+  - 궞
+  - 궟
+  - 궠
+  - 궡
+  - 궢
+  - 궣
+  - 궤
+  - 궥
+  - 궦
+  - 궧
+  - 궨
+  - 궩
+  - 궪
+  - 궫
+  - 궬
+  - 궭
+  - 궮
+  - 궯
+  - 궰
+  - 궱
+  - 궲
+  - 궳
+  - 궴
+  - 궵
+  - 궶
+  - 궷
+  - 궸
+  - 궹
+  - 궺
+  - 궻
+  - 궼
+  - 궽
+  - 궾
+  - 궿
+  - 귀
+  - 귁
+  - 귂
+  - 귃
+  - 귄
+  - 귅
+  - 귆
+  - 귇
+  - 귈
+  - 귉
+  - 귊
+  - 귋
+  - 귌
+  - 귍
+  - 귎
+  - 귏
+  - 귐
+  - 귑
+  - 귒
+  - 귓
+  - 귔
+  - 귕
+  - 귖
+  - 귗
+  - 귘
+  - 귙
+  - 귚
+  - 귛
+  - 규
+  - 귝
+  - 귞
+  - 귟
+  - 균
+  - 귡
+  - 귢
+  - 귣
+  - 귤
+  - 귥
+  - 귦
+  - 귧
+  - 귨
+  - 귩
+  - 귪
+  - 귫
+  - 귬
+  - 귭
+  - 귮
+  - 귯
+  - 귰
+  - 귱
+  - 귲
+  - 귳
+  - 귴
+  - 귵
+  - 귶
+  - 귷
+  - 그
+  - 극
+  - 귺
+  - 귻
+  - 근
+  - 귽
+  - 귾
+  - 귿
+  - 글
+  - 긁
+  - 긂
+  - 긃
+  - 긄
+  - 긅
+  - 긆
+  - 긇
+  - 금
+  - 급
+  - 긊
+  - 긋
+  - 긌
+  - 긍
+  - 긎
+  - 긏
+  - 긐
+  - 긑
+  - 긒
+  - 긓
+  - 긔
+  - 긕
+  - 긖
+  - 긗
+  - 긘
+  - 긙
+  - 긚
+  - 긛
+  - 긜
+  - 긝
+  - 긞
+  - 긟
+  - 긠
+  - 긡
+  - 긢
+  - 긣
+  - 긤
+  - 긥
+  - 긦
+  - 긧
+  - 긨
+  - 긩
+  - 긪
+  - 긫
+  - 긬
+  - 긭
+  - 긮
+  - 긯
+  - 기
+  - 긱
+  - 긲
+  - 긳
+  - 긴
+  - 긵
+  - 긶
+  - 긷
+  - 길
+  - 긹
+  - 긺
+  - 긻
+  - 긼
+  - 긽
+  - 긾
+  - 긿
+  - 김
+  - 깁
+  - 깂
+  - 깃
+  - 깄
+  - 깅
+  - 깆
+  - 깇
+  - 깈
+  - 깉
+  - 깊
+  - 깋
+  - 까
+  - 깍
+  - 깎
+  - 깏
+  - 깐
+  - 깑
+  - 깒
+  - 깓
+  - 깔
+  - 깕
+  - 깖
+  - 깗
+  - 깘
+  - 깙
+  - 깚
+  - 깛
+  - 깜
+  - 깝
+  - 깞
+  - 깟
+  - 깠
+  - 깡
+  - 깢
+  - 깣
+  - 깤
+  - 깥
+  - 깦
+  - 깧
+  - 깨
+  - 깩
+  - 깪
+  - 깫
+  - 깬
+  - 깭
+  - 깮
+  - 깯
+  - 깰
+  - 깱
+  - 깲
+  - 깳
+  - 깴
+  - 깵
+  - 깶
+  - 깷
+  - 깸
+  - 깹
+  - 깺
+  - 깻
+  - 깼
+  - 깽
+  - 깾
+  - 깿
+  - 꺀
+  - 꺁
+  - 꺂
+  - 꺃
+  - 꺄
+  - 꺅
+  - 꺆
+  - 꺇
+  - 꺈
+  - 꺉
+  - 꺊
+  - 꺋
+  - 꺌
+  - 꺍
+  - 꺎
+  - 꺏
+  - 꺐
+  - 꺑
+  - 꺒
+  - 꺓
+  - 꺔
+  - 꺕
+  - 꺖
+  - 꺗
+  - 꺘
+  - 꺙
+  - 꺚
+  - 꺛
+  - 꺜
+  - 꺝
+  - 꺞
+  - 꺟
+  - 꺠
+  - 꺡
+  - 꺢
+  - 꺣
+  - 꺤
+  - 꺥
+  - 꺦
+  - 꺧
+  - 꺨
+  - 꺩
+  - 꺪
+  - 꺫
+  - 꺬
+  - 꺭
+  - 꺮
+  - 꺯
+  - 꺰
+  - 꺱
+  - 꺲
+  - 꺳
+  - 꺴
+  - 꺵
+  - 꺶
+  - 꺷
+  - 꺸
+  - 꺹
+  - 꺺
+  - 꺻
+  - 꺼
+  - 꺽
+  - 꺾
+  - 꺿
+  - 껀
+  - 껁
+  - 껂
+  - 껃
+  - 껄
+  - 껅
+  - 껆
+  - 껇
+  - 껈
+  - 껉
+  - 껊
+  - 껋
+  - 껌
+  - 껍
+  - 껎
+  - 껏
+  - 껐
+  - 껑
+  - 껒
+  - 껓
+  - 껔
+  - 껕
+  - 껖
+  - 껗
+  - 께
+  - 껙
+  - 껚
+  - 껛
+  - 껜
+  - 껝
+  - 껞
+  - 껟
+  - 껠
+  - 껡
+  - 껢
+  - 껣
+  - 껤
+  - 껥
+  - 껦
+  - 껧
+  - 껨
+  - 껩
+  - 껪
+  - 껫
+  - 껬
+  - 껭
+  - 껮
+  - 껯
+  - 껰
+  - 껱
+  - 껲
+  - 껳
+  - 껴
+  - 껵
+  - 껶
+  - 껷
+  - 껸
+  - 껹
+  - 껺
+  - 껻
+  - 껼
+  - 껽
+  - 껾
+  - 껿
+  - 꼀
+  - 꼁
+  - 꼂
+  - 꼃
+  - 꼄
+  - 꼅
+  - 꼆
+  - 꼇
+  - 꼈
+  - 꼉
+  - 꼊
+  - 꼋
+  - 꼌
+  - 꼍
+  - 꼎
+  - 꼏
+  - 꼐
+  - 꼑
+  - 꼒
+  - 꼓
+  - 꼔
+  - 꼕
+  - 꼖
+  - 꼗
+  - 꼘
+  - 꼙
+  - 꼚
+  - 꼛
+  - 꼜
+  - 꼝
+  - 꼞
+  - 꼟
+  - 꼠
+  - 꼡
+  - 꼢
+  - 꼣
+  - 꼤
+  - 꼥
+  - 꼦
+  - 꼧
+  - 꼨
+  - 꼩
+  - 꼪
+  - 꼫
+  - 꼬
+  - 꼭
+  - 꼮
+  - 꼯
+  - 꼰
+  - 꼱
+  - 꼲
+  - 꼳
+  - 꼴
+  - 꼵
+  - 꼶
+  - 꼷
+  - 꼸
+  - 꼹
+  - 꼺
+  - 꼻
+  - 꼼
+  - 꼽
+  - 꼾
+  - 꼿
+  - 꽀
+  - 꽁
+  - 꽂
+  - 꽃
+  - 꽄
+  - 꽅
+  - 꽆
+  - 꽇
+  - 꽈
+  - 꽉
+  - 꽊
+  - 꽋
+  - 꽌
+  - 꽍
+  - 꽎
+  - 꽏
+  - 꽐
+  - 꽑
+  - 꽒
+  - 꽓
+  - 꽔
+  - 꽕
+  - 꽖
+  - 꽗
+  - 꽘
+  - 꽙
+  - 꽚
+  - 꽛
+  - 꽜
+  - 꽝
+  - 꽞
+  - 꽟
+  - 꽠
+  - 꽡
+  - 꽢
+  - 꽣
+  - 꽤
+  - 꽥
+  - 꽦
+  - 꽧
+  - 꽨
+  - 꽩
+  - 꽪
+  - 꽫
+  - 꽬
+  - 꽭
+  - 꽮
+  - 꽯
+  - 꽰
+  - 꽱
+  - 꽲
+  - 꽳
+  - 꽴
+  - 꽵
+  - 꽶
+  - 꽷
+  - 꽸
+  - 꽹
+  - 꽺
+  - 꽻
+  - 꽼
+  - 꽽
+  - 꽾
+  - 꽿
+  - 꾀
+  - 꾁
+  - 꾂
+  - 꾃
+  - 꾄
+  - 꾅
+  - 꾆
+  - 꾇
+  - 꾈
+  - 꾉
+  - 꾊
+  - 꾋
+  - 꾌
+  - 꾍
+  - 꾎
+  - 꾏
+  - 꾐
+  - 꾑
+  - 꾒
+  - 꾓
+  - 꾔
+  - 꾕
+  - 꾖
+  - 꾗
+  - 꾘
+  - 꾙
+  - 꾚
+  - 꾛
+  - 꾜
+  - 꾝
+  - 꾞
+  - 꾟
+  - 꾠
+  - 꾡
+  - 꾢
+  - 꾣
+  - 꾤
+  - 꾥
+  - 꾦
+  - 꾧
+  - 꾨
+  - 꾩
+  - 꾪
+  - 꾫
+  - 꾬
+  - 꾭
+  - 꾮
+  - 꾯
+  - 꾰
+  - 꾱
+  - 꾲
+  - 꾳
+  - 꾴
+  - 꾵
+  - 꾶
+  - 꾷
+  - 꾸
+  - 꾹
+  - 꾺
+  - 꾻
+  - 꾼
+  - 꾽
+  - 꾾
+  - 꾿
+  - 꿀
+  - 꿁
+  - 꿂
+  - 꿃
+  - 꿄
+  - 꿅
+  - 꿆
+  - 꿇
+  - 꿈
+  - 꿉
+  - 꿊
+  - 꿋
+  - 꿌
+  - 꿍
+  - 꿎
+  - 꿏
+  - 꿐
+  - 꿑
+  - 꿒
+  - 꿓
+  - 꿔
+  - 꿕
+  - 꿖
+  - 꿗
+  - 꿘
+  - 꿙
+  - 꿚
+  - 꿛
+  - 꿜
+  - 꿝
+  - 꿞
+  - 꿟
+  - 꿠
+  - 꿡
+  - 꿢
+  - 꿣
+  - 꿤
+  - 꿥
+  - 꿦
+  - 꿧
+  - 꿨
+  - 꿩
+  - 꿪
+  - 꿫
+  - 꿬
+  - 꿭
+  - 꿮
+  - 꿯
+  - 꿰
+  - 꿱
+  - 꿲
+  - 꿳
+  - 꿴
+  - 꿵
+  - 꿶
+  - 꿷
+  - 꿸
+  - 꿹
+  - 꿺
+  - 꿻
+  - 꿼
+  - 꿽
+  - 꿾
+  - 꿿
+  - 뀀
+  - 뀁
+  - 뀂
+  - 뀃
+  - 뀄
+  - 뀅
+  - 뀆
+  - 뀇
+  - 뀈
+  - 뀉
+  - 뀊
+  - 뀋
+  - 뀌
+  - 뀍
+  - 뀎
+  - 뀏
+  - 뀐
+  - 뀑
+  - 뀒
+  - 뀓
+  - 뀔
+  - 뀕
+  - 뀖
+  - 뀗
+  - 뀘
+  - 뀙
+  - 뀚
+  - 뀛
+  - 뀜
+  - 뀝
+  - 뀞
+  - 뀟
+  - 뀠
+  - 뀡
+  - 뀢
+  - 뀣
+  - 뀤
+  - 뀥
+  - 뀦
+  - 뀧
+  - 뀨
+  - 뀩
+  - 뀪
+  - 뀫
+  - 뀬
+  - 뀭
+  - 뀮
+  - 뀯
+  - 뀰
+  - 뀱
+  - 뀲
+  - 뀳
+  - 뀴
+  - 뀵
+  - 뀶
+  - 뀷
+  - 뀸
+  - 뀹
+  - 뀺
+  - 뀻
+  - 뀼
+  - 뀽
+  - 뀾
+  - 뀿
+  - 끀
+  - 끁
+  - 끂
+  - 끃
+  - 끄
+  - 끅
+  - 끆
+  - 끇
+  - 끈
+  - 끉
+  - 끊
+  - 끋
+  - 끌
+  - 끍
+  - 끎
+  - 끏
+  - 끐
+  - 끑
+  - 끒
+  - 끓
+  - 끔
+  - 끕
+  - 끖
+  - 끗
+  - 끘
+  - 끙
+  - 끚
+  - 끛
+  - 끜
+  - 끝
+  - 끞
+  - 끟
+  - 끠
+  - 끡
+  - 끢
+  - 끣
+  - 끤
+  - 끥
+  - 끦
+  - 끧
+  - 끨
+  - 끩
+  - 끪
+  - 끫
+  - 끬
+  - 끭
+  - 끮
+  - 끯
+  - 끰
+  - 끱
+  - 끲
+  - 끳
+  - 끴
+  - 끵
+  - 끶
+  - 끷
+  - 끸
+  - 끹
+  - 끺
+  - 끻
+  - 끼
+  - 끽
+  - 끾
+  - 끿
+  - 낀
+  - 낁
+  - 낂
+  - 낃
+  - 낄
+  - 낅
+  - 낆
+  - 낇
+  - 낈
+  - 낉
+  - 낊
+  - 낋
+  - 낌
+  - 낍
+  - 낎
+  - 낏
+  - 낐
+  - 낑
+  - 낒
+  - 낓
+  - 낔
+  - 낕
+  - 낖
+  - 낗
+  - 나
+  - 낙
+  - 낚
+  - 낛
+  - 난
+  - 낝
+  - 낞
+  - 낟
+  - 날
+  - 낡
+  - 낢
+  - 낣
+  - 낤
+  - 낥
+  - 낦
+  - 낧
+  - 남
+  - 납
+  - 낪
+  - 낫
+  - 났
+  - 낭
+  - 낮
+  - 낯
+  - 낰
+  - 낱
+  - 낲
+  - 낳
+  - 내
+  - 낵
+  - 낶
+  - 낷
+  - 낸
+  - 낹
+  - 낺
+  - 낻
+  - 낼
+  - 낽
+  - 낾
+  - 낿
+  - 냀
+  - 냁
+  - 냂
+  - 냃
+  - 냄
+  - 냅
+  - 냆
+  - 냇
+  - 냈
+  - 냉
+  - 냊
+  - 냋
+  - 냌
+  - 냍
+  - 냎
+  - 냏
+  - 냐
+  - 냑
+  - 냒
+  - 냓
+  - 냔
+  - 냕
+  - 냖
+  - 냗
+  - 냘
+  - 냙
+  - 냚
+  - 냛
+  - 냜
+  - 냝
+  - 냞
+  - 냟
+  - 냠
+  - 냡
+  - 냢
+  - 냣
+  - 냤
+  - 냥
+  - 냦
+  - 냧
+  - 냨
+  - 냩
+  - 냪
+  - 냫
+  - 냬
+  - 냭
+  - 냮
+  - 냯
+  - 냰
+  - 냱
+  - 냲
+  - 냳
+  - 냴
+  - 냵
+  - 냶
+  - 냷
+  - 냸
+  - 냹
+  - 냺
+  - 냻
+  - 냼
+  - 냽
+  - 냾
+  - 냿
+  - 넀
+  - 넁
+  - 넂
+  - 넃
+  - 넄
+  - 넅
+  - 넆
+  - 넇
+  - 너
+  - 넉
+  - 넊
+  - 넋
+  - 넌
+  - 넍
+  - 넎
+  - 넏
+  - 널
+  - 넑
+  - 넒
+  - 넓
+  - 넔
+  - 넕
+  - 넖
+  - 넗
+  - 넘
+  - 넙
+  - 넚
+  - 넛
+  - 넜
+  - 넝
+  - 넞
+  - 넟
+  - 넠
+  - 넡
+  - 넢
+  - 넣
+  - 네
+  - 넥
+  - 넦
+  - 넧
+  - 넨
+  - 넩
+  - 넪
+  - 넫
+  - 넬
+  - 넭
+  - 넮
+  - 넯
+  - 넰
+  - 넱
+  - 넲
+  - 넳
+  - 넴
+  - 넵
+  - 넶
+  - 넷
+  - 넸
+  - 넹
+  - 넺
+  - 넻
+  - 넼
+  - 넽
+  - 넾
+  - 넿
+  - 녀
+  - 녁
+  - 녂
+  - 녃
+  - 년
+  - 녅
+  - 녆
+  - 녇
+  - 녈
+  - 녉
+  - 녊
+  - 녋
+  - 녌
+  - 녍
+  - 녎
+  - 녏
+  - 념
+  - 녑
+  - 녒
+  - 녓
+  - 녔
+  - 녕
+  - 녖
+  - 녗
+  - 녘
+  - 녙
+  - 녚
+  - 녛
+  - 녜
+  - 녝
+  - 녞
+  - 녟
+  - 녠
+  - 녡
+  - 녢
+  - 녣
+  - 녤
+  - 녥
+  - 녦
+  - 녧
+  - 녨
+  - 녩
+  - 녪
+  - 녫
+  - 녬
+  - 녭
+  - 녮
+  - 녯
+  - 녰
+  - 녱
+  - 녲
+  - 녳
+  - 녴
+  - 녵
+  - 녶
+  - 녷
+  - 노
+  - 녹
+  - 녺
+  - 녻
+  - 논
+  - 녽
+  - 녾
+  - 녿
+  - 놀
+  - 놁
+  - 놂
+  - 놃
+  - 놄
+  - 놅
+  - 놆
+  - 놇
+  - 놈
+  - 놉
+  - 놊
+  - 놋
+  - 놌
+  - 농
+  - 놎
+  - 놏
+  - 놐
+  - 놑
+  - 높
+  - 놓
+  - 놔
+  - 놕
+  - 놖
+  - 놗
+  - 놘
+  - 놙
+  - 놚
+  - 놛
+  - 놜
+  - 놝
+  - 놞
+  - 놟
+  - 놠
+  - 놡
+  - 놢
+  - 놣
+  - 놤
+  - 놥
+  - 놦
+  - 놧
+  - 놨
+  - 놩
+  - 놪
+  - 놫
+  - 놬
+  - 놭
+  - 놮
+  - 놯
+  - 놰
+  - 놱
+  - 놲
+  - 놳
+  - 놴
+  - 놵
+  - 놶
+  - 놷
+  - 놸
+  - 놹
+  - 놺
+  - 놻
+  - 놼
+  - 놽
+  - 놾
+  - 놿
+  - 뇀
+  - 뇁
+  - 뇂
+  - 뇃
+  - 뇄
+  - 뇅
+  - 뇆
+  - 뇇
+  - 뇈
+  - 뇉
+  - 뇊
+  - 뇋
+  - 뇌
+  - 뇍
+  - 뇎
+  - 뇏
+  - 뇐
+  - 뇑
+  - 뇒
+  - 뇓
+  - 뇔
+  - 뇕
+  - 뇖
+  - 뇗
+  - 뇘
+  - 뇙
+  - 뇚
+  - 뇛
+  - 뇜
+  - 뇝
+  - 뇞
+  - 뇟
+  - 뇠
+  - 뇡
+  - 뇢
+  - 뇣
+  - 뇤
+  - 뇥
+  - 뇦
+  - 뇧
+  - 뇨
+  - 뇩
+  - 뇪
+  - 뇫
+  - 뇬
+  - 뇭
+  - 뇮
+  - 뇯
+  - 뇰
+  - 뇱
+  - 뇲
+  - 뇳
+  - 뇴
+  - 뇵
+  - 뇶
+  - 뇷
+  - 뇸
+  - 뇹
+  - 뇺
+  - 뇻
+  - 뇼
+  - 뇽
+  - 뇾
+  - 뇿
+  - 눀
+  - 눁
+  - 눂
+  - 눃
+  - 누
+  - 눅
+  - 눆
+  - 눇
+  - 눈
+  - 눉
+  - 눊
+  - 눋
+  - 눌
+  - 눍
+  - 눎
+  - 눏
+  - 눐
+  - 눑
+  - 눒
+  - 눓
+  - 눔
+  - 눕
+  - 눖
+  - 눗
+  - 눘
+  - 눙
+  - 눚
+  - 눛
+  - 눜
+  - 눝
+  - 눞
+  - 눟
+  - 눠
+  - 눡
+  - 눢
+  - 눣
+  - 눤
+  - 눥
+  - 눦
+  - 눧
+  - 눨
+  - 눩
+  - 눪
+  - 눫
+  - 눬
+  - 눭
+  - 눮
+  - 눯
+  - 눰
+  - 눱
+  - 눲
+  - 눳
+  - 눴
+  - 눵
+  - 눶
+  - 눷
+  - 눸
+  - 눹
+  - 눺
+  - 눻
+  - 눼
+  - 눽
+  - 눾
+  - 눿
+  - 뉀
+  - 뉁
+  - 뉂
+  - 뉃
+  - 뉄
+  - 뉅
+  - 뉆
+  - 뉇
+  - 뉈
+  - 뉉
+  - 뉊
+  - 뉋
+  - 뉌
+  - 뉍
+  - 뉎
+  - 뉏
+  - 뉐
+  - 뉑
+  - 뉒
+  - 뉓
+  - 뉔
+  - 뉕
+  - 뉖
+  - 뉗
+  - 뉘
+  - 뉙
+  - 뉚
+  - 뉛
+  - 뉜
+  - 뉝
+  - 뉞
+  - 뉟
+  - 뉠
+  - 뉡
+  - 뉢
+  - 뉣
+  - 뉤
+  - 뉥
+  - 뉦
+  - 뉧
+  - 뉨
+  - 뉩
+  - 뉪
+  - 뉫
+  - 뉬
+  - 뉭
+  - 뉮
+  - 뉯
+  - 뉰
+  - 뉱
+  - 뉲
+  - 뉳
+  - 뉴
+  - 뉵
+  - 뉶
+  - 뉷
+  - 뉸
+  - 뉹
+  - 뉺
+  - 뉻
+  - 뉼
+  - 뉽
+  - 뉾
+  - 뉿
+  - 늀
+  - 늁
+  - 늂
+  - 늃
+  - 늄
+  - 늅
+  - 늆
+  - 늇
+  - 늈
+  - 늉
+  - 늊
+  - 늋
+  - 늌
+  - 늍
+  - 늎
+  - 늏
+  - 느
+  - 늑
+  - 늒
+  - 늓
+  - 는
+  - 늕
+  - 늖
+  - 늗
+  - 늘
+  - 늙
+  - 늚
+  - 늛
+  - 늜
+  - 늝
+  - 늞
+  - 늟
+  - 늠
+  - 늡
+  - 늢
+  - 늣
+  - 늤
+  - 능
+  - 늦
+  - 늧
+  - 늨
+  - 늩
+  - 늪
+  - 늫
+  - 늬
+  - 늭
+  - 늮
+  - 늯
+  - 늰
+  - 늱
+  - 늲
+  - 늳
+  - 늴
+  - 늵
+  - 늶
+  - 늷
+  - 늸
+  - 늹
+  - 늺
+  - 늻
+  - 늼
+  - 늽
+  - 늾
+  - 늿
+  - 닀
+  - 닁
+  - 닂
+  - 닃
+  - 닄
+  - 닅
+  - 닆
+  - 닇
+  - 니
+  - 닉
+  - 닊
+  - 닋
+  - 닌
+  - 닍
+  - 닎
+  - 닏
+  - 닐
+  - 닑
+  - 닒
+  - 닓
+  - 닔
+  - 닕
+  - 닖
+  - 닗
+  - 님
+  - 닙
+  - 닚
+  - 닛
+  - 닜
+  - 닝
+  - 닞
+  - 닟
+  - 닠
+  - 닡
+  - 닢
+  - 닣
+  - 다
+  - 닥
+  - 닦
+  - 닧
+  - 단
+  - 닩
+  - 닪
+  - 닫
+  - 달
+  - 닭
+  - 닮
+  - 닯
+  - 닰
+  - 닱
+  - 닲
+  - 닳
+  - 담
+  - 답
+  - 닶
+  - 닷
+  - 닸
+  - 당
+  - 닺
+  - 닻
+  - 닼
+  - 닽
+  - 닾
+  - 닿
+  - 대
+  - 댁
+  - 댂
+  - 댃
+  - 댄
+  - 댅
+  - 댆
+  - 댇
+  - 댈
+  - 댉
+  - 댊
+  - 댋
+  - 댌
+  - 댍
+  - 댎
+  - 댏
+  - 댐
+  - 댑
+  - 댒
+  - 댓
+  - 댔
+  - 댕
+  - 댖
+  - 댗
+  - 댘
+  - 댙
+  - 댚
+  - 댛
+  - 댜
+  - 댝
+  - 댞
+  - 댟
+  - 댠
+  - 댡
+  - 댢
+  - 댣
+  - 댤
+  - 댥
+  - 댦
+  - 댧
+  - 댨
+  - 댩
+  - 댪
+  - 댫
+  - 댬
+  - 댭
+  - 댮
+  - 댯
+  - 댰
+  - 댱
+  - 댲
+  - 댳
+  - 댴
+  - 댵
+  - 댶
+  - 댷
+  - 댸
+  - 댹
+  - 댺
+  - 댻
+  - 댼
+  - 댽
+  - 댾
+  - 댿
+  - 덀
+  - 덁
+  - 덂
+  - 덃
+  - 덄
+  - 덅
+  - 덆
+  - 덇
+  - 덈
+  - 덉
+  - 덊
+  - 덋
+  - 덌
+  - 덍
+  - 덎
+  - 덏
+  - 덐
+  - 덑
+  - 덒
+  - 덓
+  - 더
+  - 덕
+  - 덖
+  - 덗
+  - 던
+  - 덙
+  - 덚
+  - 덛
+  - 덜
+  - 덝
+  - 덞
+  - 덟
+  - 덠
+  - 덡
+  - 덢
+  - 덣
+  - 덤
+  - 덥
+  - 덦
+  - 덧
+  - 덨
+  - 덩
+  - 덪
+  - 덫
+  - 덬
+  - 덭
+  - 덮
+  - 덯
+  - 데
+  - 덱
+  - 덲
+  - 덳
+  - 덴
+  - 덵
+  - 덶
+  - 덷
+  - 델
+  - 덹
+  - 덺
+  - 덻
+  - 덼
+  - 덽
+  - 덾
+  - 덿
+  - 뎀
+  - 뎁
+  - 뎂
+  - 뎃
+  - 뎄
+  - 뎅
+  - 뎆
+  - 뎇
+  - 뎈
+  - 뎉
+  - 뎊
+  - 뎋
+  - 뎌
+  - 뎍
+  - 뎎
+  - 뎏
+  - 뎐
+  - 뎑
+  - 뎒
+  - 뎓
+  - 뎔
+  - 뎕
+  - 뎖
+  - 뎗
+  - 뎘
+  - 뎙
+  - 뎚
+  - 뎛
+  - 뎜
+  - 뎝
+  - 뎞
+  - 뎟
+  - 뎠
+  - 뎡
+  - 뎢
+  - 뎣
+  - 뎤
+  - 뎥
+  - 뎦
+  - 뎧
+  - 뎨
+  - 뎩
+  - 뎪
+  - 뎫
+  - 뎬
+  - 뎭
+  - 뎮
+  - 뎯
+  - 뎰
+  - 뎱
+  - 뎲
+  - 뎳
+  - 뎴
+  - 뎵
+  - 뎶
+  - 뎷
+  - 뎸
+  - 뎹
+  - 뎺
+  - 뎻
+  - 뎼
+  - 뎽
+  - 뎾
+  - 뎿
+  - 돀
+  - 돁
+  - 돂
+  - 돃
+  - 도
+  - 독
+  - 돆
+  - 돇
+  - 돈
+  - 돉
+  - 돊
+  - 돋
+  - 돌
+  - 돍
+  - 돎
+  - 돏
+  - 돐
+  - 돑
+  - 돒
+  - 돓
+  - 돔
+  - 돕
+  - 돖
+  - 돗
+  - 돘
+  - 동
+  - 돚
+  - 돛
+  - 돜
+  - 돝
+  - 돞
+  - 돟
+  - 돠
+  - 돡
+  - 돢
+  - 돣
+  - 돤
+  - 돥
+  - 돦
+  - 돧
+  - 돨
+  - 돩
+  - 돪
+  - 돫
+  - 돬
+  - 돭
+  - 돮
+  - 돯
+  - 돰
+  - 돱
+  - 돲
+  - 돳
+  - 돴
+  - 돵
+  - 돶
+  - 돷
+  - 돸
+  - 돹
+  - 돺
+  - 돻
+  - 돼
+  - 돽
+  - 돾
+  - 돿
+  - 됀
+  - 됁
+  - 됂
+  - 됃
+  - 됄
+  - 됅
+  - 됆
+  - 됇
+  - 됈
+  - 됉
+  - 됊
+  - 됋
+  - 됌
+  - 됍
+  - 됎
+  - 됏
+  - 됐
+  - 됑
+  - 됒
+  - 됓
+  - 됔
+  - 됕
+  - 됖
+  - 됗
+  - 되
+  - 됙
+  - 됚
+  - 됛
+  - 된
+  - 됝
+  - 됞
+  - 됟
+  - 될
+  - 됡
+  - 됢
+  - 됣
+  - 됤
+  - 됥
+  - 됦
+  - 됧
+  - 됨
+  - 됩
+  - 됪
+  - 됫
+  - 됬
+  - 됭
+  - 됮
+  - 됯
+  - 됰
+  - 됱
+  - 됲
+  - 됳
+  - 됴
+  - 됵
+  - 됶
+  - 됷
+  - 됸
+  - 됹
+  - 됺
+  - 됻
+  - 됼
+  - 됽
+  - 됾
+  - 됿
+  - 둀
+  - 둁
+  - 둂
+  - 둃
+  - 둄
+  - 둅
+  - 둆
+  - 둇
+  - 둈
+  - 둉
+  - 둊
+  - 둋
+  - 둌
+  - 둍
+  - 둎
+  - 둏
+  - 두
+  - 둑
+  - 둒
+  - 둓
+  - 둔
+  - 둕
+  - 둖
+  - 둗
+  - 둘
+  - 둙
+  - 둚
+  - 둛
+  - 둜
+  - 둝
+  - 둞
+  - 둟
+  - 둠
+  - 둡
+  - 둢
+  - 둣
+  - 둤
+  - 둥
+  - 둦
+  - 둧
+  - 둨
+  - 둩
+  - 둪
+  - 둫
+  - 둬
+  - 둭
+  - 둮
+  - 둯
+  - 둰
+  - 둱
+  - 둲
+  - 둳
+  - 둴
+  - 둵
+  - 둶
+  - 둷
+  - 둸
+  - 둹
+  - 둺
+  - 둻
+  - 둼
+  - 둽
+  - 둾
+  - 둿
+  - 뒀
+  - 뒁
+  - 뒂
+  - 뒃
+  - 뒄
+  - 뒅
+  - 뒆
+  - 뒇
+  - 뒈
+  - 뒉
+  - 뒊
+  - 뒋
+  - 뒌
+  - 뒍
+  - 뒎
+  - 뒏
+  - 뒐
+  - 뒑
+  - 뒒
+  - 뒓
+  - 뒔
+  - 뒕
+  - 뒖
+  - 뒗
+  - 뒘
+  - 뒙
+  - 뒚
+  - 뒛
+  - 뒜
+  - 뒝
+  - 뒞
+  - 뒟
+  - 뒠
+  - 뒡
+  - 뒢
+  - 뒣
+  - 뒤
+  - 뒥
+  - 뒦
+  - 뒧
+  - 뒨
+  - 뒩
+  - 뒪
+  - 뒫
+  - 뒬
+  - 뒭
+  - 뒮
+  - 뒯
+  - 뒰
+  - 뒱
+  - 뒲
+  - 뒳
+  - 뒴
+  - 뒵
+  - 뒶
+  - 뒷
+  - 뒸
+  - 뒹
+  - 뒺
+  - 뒻
+  - 뒼
+  - 뒽
+  - 뒾
+  - 뒿
+  - 듀
+  - 듁
+  - 듂
+  - 듃
+  - 듄
+  - 듅
+  - 듆
+  - 듇
+  - 듈
+  - 듉
+  - 듊
+  - 듋
+  - 듌
+  - 듍
+  - 듎
+  - 듏
+  - 듐
+  - 듑
+  - 듒
+  - 듓
+  - 듔
+  - 듕
+  - 듖
+  - 듗
+  - 듘
+  - 듙
+  - 듚
+  - 듛
+  - 드
+  - 득
+  - 듞
+  - 듟
+  - 든
+  - 듡
+  - 듢
+  - 듣
+  - 들
+  - 듥
+  - 듦
+  - 듧
+  - 듨
+  - 듩
+  - 듪
+  - 듫
+  - 듬
+  - 듭
+  - 듮
+  - 듯
+  - 듰
+  - 등
+  - 듲
+  - 듳
+  - 듴
+  - 듵
+  - 듶
+  - 듷
+  - 듸
+  - 듹
+  - 듺
+  - 듻
+  - 듼
+  - 듽
+  - 듾
+  - 듿
+  - 딀
+  - 딁
+  - 딂
+  - 딃
+  - 딄
+  - 딅
+  - 딆
+  - 딇
+  - 딈
+  - 딉
+  - 딊
+  - 딋
+  - 딌
+  - 딍
+  - 딎
+  - 딏
+  - 딐
+  - 딑
+  - 딒
+  - 딓
+  - 디
+  - 딕
+  - 딖
+  - 딗
+  - 딘
+  - 딙
+  - 딚
+  - 딛
+  - 딜
+  - 딝
+  - 딞
+  - 딟
+  - 딠
+  - 딡
+  - 딢
+  - 딣
+  - 딤
+  - 딥
+  - 딦
+  - 딧
+  - 딨
+  - 딩
+  - 딪
+  - 딫
+  - 딬
+  - 딭
+  - 딮
+  - 딯
+  - 따
+  - 딱
+  - 딲
+  - 딳
+  - 딴
+  - 딵
+  - 딶
+  - 딷
+  - 딸
+  - 딹
+  - 딺
+  - 딻
+  - 딼
+  - 딽
+  - 딾
+  - 딿
+  - 땀
+  - 땁
+  - 땂
+  - 땃
+  - 땄
+  - 땅
+  - 땆
+  - 땇
+  - 땈
+  - 땉
+  - 땊
+  - 땋
+  - 때
+  - 땍
+  - 땎
+  - 땏
+  - 땐
+  - 땑
+  - 땒
+  - 땓
+  - 땔
+  - 땕
+  - 땖
+  - 땗
+  - 땘
+  - 땙
+  - 땚
+  - 땛
+  - 땜
+  - 땝
+  - 땞
+  - 땟
+  - 땠
+  - 땡
+  - 땢
+  - 땣
+  - 땤
+  - 땥
+  - 땦
+  - 땧
+  - 땨
+  - 땩
+  - 땪
+  - 땫
+  - 땬
+  - 땭
+  - 땮
+  - 땯
+  - 땰
+  - 땱
+  - 땲
+  - 땳
+  - 땴
+  - 땵
+  - 땶
+  - 땷
+  - 땸
+  - 땹
+  - 땺
+  - 땻
+  - 땼
+  - 땽
+  - 땾
+  - 땿
+  - 떀
+  - 떁
+  - 떂
+  - 떃
+  - 떄
+  - 떅
+  - 떆
+  - 떇
+  - 떈
+  - 떉
+  - 떊
+  - 떋
+  - 떌
+  - 떍
+  - 떎
+  - 떏
+  - 떐
+  - 떑
+  - 떒
+  - 떓
+  - 떔
+  - 떕
+  - 떖
+  - 떗
+  - 떘
+  - 떙
+  - 떚
+  - 떛
+  - 떜
+  - 떝
+  - 떞
+  - 떟
+  - 떠
+  - 떡
+  - 떢
+  - 떣
+  - 떤
+  - 떥
+  - 떦
+  - 떧
+  - 떨
+  - 떩
+  - 떪
+  - 떫
+  - 떬
+  - 떭
+  - 떮
+  - 떯
+  - 떰
+  - 떱
+  - 떲
+  - 떳
+  - 떴
+  - 떵
+  - 떶
+  - 떷
+  - 떸
+  - 떹
+  - 떺
+  - 떻
+  - 떼
+  - 떽
+  - 떾
+  - 떿
+  - 뗀
+  - 뗁
+  - 뗂
+  - 뗃
+  - 뗄
+  - 뗅
+  - 뗆
+  - 뗇
+  - 뗈
+  - 뗉
+  - 뗊
+  - 뗋
+  - 뗌
+  - 뗍
+  - 뗎
+  - 뗏
+  - 뗐
+  - 뗑
+  - 뗒
+  - 뗓
+  - 뗔
+  - 뗕
+  - 뗖
+  - 뗗
+  - 뗘
+  - 뗙
+  - 뗚
+  - 뗛
+  - 뗜
+  - 뗝
+  - 뗞
+  - 뗟
+  - 뗠
+  - 뗡
+  - 뗢
+  - 뗣
+  - 뗤
+  - 뗥
+  - 뗦
+  - 뗧
+  - 뗨
+  - 뗩
+  - 뗪
+  - 뗫
+  - 뗬
+  - 뗭
+  - 뗮
+  - 뗯
+  - 뗰
+  - 뗱
+  - 뗲
+  - 뗳
+  - 뗴
+  - 뗵
+  - 뗶
+  - 뗷
+  - 뗸
+  - 뗹
+  - 뗺
+  - 뗻
+  - 뗼
+  - 뗽
+  - 뗾
+  - 뗿
+  - 똀
+  - 똁
+  - 똂
+  - 똃
+  - 똄
+  - 똅
+  - 똆
+  - 똇
+  - 똈
+  - 똉
+  - 똊
+  - 똋
+  - 똌
+  - 똍
+  - 똎
+  - 똏
+  - 또
+  - 똑
+  - 똒
+  - 똓
+  - 똔
+  - 똕
+  - 똖
+  - 똗
+  - 똘
+  - 똙
+  - 똚
+  - 똛
+  - 똜
+  - 똝
+  - 똞
+  - 똟
+  - 똠
+  - 똡
+  - 똢
+  - 똣
+  - 똤
+  - 똥
+  - 똦
+  - 똧
+  - 똨
+  - 똩
+  - 똪
+  - 똫
+  - 똬
+  - 똭
+  - 똮
+  - 똯
+  - 똰
+  - 똱
+  - 똲
+  - 똳
+  - 똴
+  - 똵
+  - 똶
+  - 똷
+  - 똸
+  - 똹
+  - 똺
+  - 똻
+  - 똼
+  - 똽
+  - 똾
+  - 똿
+  - 뙀
+  - 뙁
+  - 뙂
+  - 뙃
+  - 뙄
+  - 뙅
+  - 뙆
+  - 뙇
+  - 뙈
+  - 뙉
+  - 뙊
+  - 뙋
+  - 뙌
+  - 뙍
+  - 뙎
+  - 뙏
+  - 뙐
+  - 뙑
+  - 뙒
+  - 뙓
+  - 뙔
+  - 뙕
+  - 뙖
+  - 뙗
+  - 뙘
+  - 뙙
+  - 뙚
+  - 뙛
+  - 뙜
+  - 뙝
+  - 뙞
+  - 뙟
+  - 뙠
+  - 뙡
+  - 뙢
+  - 뙣
+  - 뙤
+  - 뙥
+  - 뙦
+  - 뙧
+  - 뙨
+  - 뙩
+  - 뙪
+  - 뙫
+  - 뙬
+  - 뙭
+  - 뙮
+  - 뙯
+  - 뙰
+  - 뙱
+  - 뙲
+  - 뙳
+  - 뙴
+  - 뙵
+  - 뙶
+  - 뙷
+  - 뙸
+  - 뙹
+  - 뙺
+  - 뙻
+  - 뙼
+  - 뙽
+  - 뙾
+  - 뙿
+  - 뚀
+  - 뚁
+  - 뚂
+  - 뚃
+  - 뚄
+  - 뚅
+  - 뚆
+  - 뚇
+  - 뚈
+  - 뚉
+  - 뚊
+  - 뚋
+  - 뚌
+  - 뚍
+  - 뚎
+  - 뚏
+  - 뚐
+  - 뚑
+  - 뚒
+  - 뚓
+  - 뚔
+  - 뚕
+  - 뚖
+  - 뚗
+  - 뚘
+  - 뚙
+  - 뚚
+  - 뚛
+  - 뚜
+  - 뚝
+  - 뚞
+  - 뚟
+  - 뚠
+  - 뚡
+  - 뚢
+  - 뚣
+  - 뚤
+  - 뚥
+  - 뚦
+  - 뚧
+  - 뚨
+  - 뚩
+  - 뚪
+  - 뚫
+  - 뚬
+  - 뚭
+  - 뚮
+  - 뚯
+  - 뚰
+  - 뚱
+  - 뚲
+  - 뚳
+  - 뚴
+  - 뚵
+  - 뚶
+  - 뚷
+  - 뚸
+  - 뚹
+  - 뚺
+  - 뚻
+  - 뚼
+  - 뚽
+  - 뚾
+  - 뚿
+  - 뛀
+  - 뛁
+  - 뛂
+  - 뛃
+  - 뛄
+  - 뛅
+  - 뛆
+  - 뛇
+  - 뛈
+  - 뛉
+  - 뛊
+  - 뛋
+  - 뛌
+  - 뛍
+  - 뛎
+  - 뛏
+  - 뛐
+  - 뛑
+  - 뛒
+  - 뛓
+  - 뛔
+  - 뛕
+  - 뛖
+  - 뛗
+  - 뛘
+  - 뛙
+  - 뛚
+  - 뛛
+  - 뛜
+  - 뛝
+  - 뛞
+  - 뛟
+  - 뛠
+  - 뛡
+  - 뛢
+  - 뛣
+  - 뛤
+  - 뛥
+  - 뛦
+  - 뛧
+  - 뛨
+  - 뛩
+  - 뛪
+  - 뛫
+  - 뛬
+  - 뛭
+  - 뛮
+  - 뛯
+  - 뛰
+  - 뛱
+  - 뛲
+  - 뛳
+  - 뛴
+  - 뛵
+  - 뛶
+  - 뛷
+  - 뛸
+  - 뛹
+  - 뛺
+  - 뛻
+  - 뛼
+  - 뛽
+  - 뛾
+  - 뛿
+  - 뜀
+  - 뜁
+  - 뜂
+  - 뜃
+  - 뜄
+  - 뜅
+  - 뜆
+  - 뜇
+  - 뜈
+  - 뜉
+  - 뜊
+  - 뜋
+  - 뜌
+  - 뜍
+  - 뜎
+  - 뜏
+  - 뜐
+  - 뜑
+  - 뜒
+  - 뜓
+  - 뜔
+  - 뜕
+  - 뜖
+  - 뜗
+  - 뜘
+  - 뜙
+  - 뜚
+  - 뜛
+  - 뜜
+  - 뜝
+  - 뜞
+  - 뜟
+  - 뜠
+  - 뜡
+  - 뜢
+  - 뜣
+  - 뜤
+  - 뜥
+  - 뜦
+  - 뜧
+  - 뜨
+  - 뜩
+  - 뜪
+  - 뜫
+  - 뜬
+  - 뜭
+  - 뜮
+  - 뜯
+  - 뜰
+  - 뜱
+  - 뜲
+  - 뜳
+  - 뜴
+  - 뜵
+  - 뜶
+  - 뜷
+  - 뜸
+  - 뜹
+  - 뜺
+  - 뜻
+  - 뜼
+  - 뜽
+  - 뜾
+  - 뜿
+  - 띀
+  - 띁
+  - 띂
+  - 띃
+  - 띄
+  - 띅
+  - 띆
+  - 띇
+  - 띈
+  - 띉
+  - 띊
+  - 띋
+  - 띌
+  - 띍
+  - 띎
+  - 띏
+  - 띐
+  - 띑
+  - 띒
+  - 띓
+  - 띔
+  - 띕
+  - 띖
+  - 띗
+  - 띘
+  - 띙
+  - 띚
+  - 띛
+  - 띜
+  - 띝
+  - 띞
+  - 띟
+  - 띠
+  - 띡
+  - 띢
+  - 띣
+  - 띤
+  - 띥
+  - 띦
+  - 띧
+  - 띨
+  - 띩
+  - 띪
+  - 띫
+  - 띬
+  - 띭
+  - 띮
+  - 띯
+  - 띰
+  - 띱
+  - 띲
+  - 띳
+  - 띴
+  - 띵
+  - 띶
+  - 띷
+  - 띸
+  - 띹
+  - 띺
+  - 띻
+  - 라
+  - 락
+  - 띾
+  - 띿
+  - 란
+  - 랁
+  - 랂
+  - 랃
+  - 랄
+  - 랅
+  - 랆
+  - 랇
+  - 랈
+  - 랉
+  - 랊
+  - 랋
+  - 람
+  - 랍
+  - 랎
+  - 랏
+  - 랐
+  - 랑
+  - 랒
+  - 랓
+  - 랔
+  - 랕
+  - 랖
+  - 랗
+  - 래
+  - 랙
+  - 랚
+  - 랛
+  - 랜
+  - 랝
+  - 랞
+  - 랟
+  - 랠
+  - 랡
+  - 랢
+  - 랣
+  - 랤
+  - 랥
+  - 랦
+  - 랧
+  - 램
+  - 랩
+  - 랪
+  - 랫
+  - 랬
+  - 랭
+  - 랮
+  - 랯
+  - 랰
+  - 랱
+  - 랲
+  - 랳
+  - 랴
+  - 략
+  - 랶
+  - 랷
+  - 랸
+  - 랹
+  - 랺
+  - 랻
+  - 랼
+  - 랽
+  - 랾
+  - 랿
+  - 럀
+  - 럁
+  - 럂
+  - 럃
+  - 럄
+  - 럅
+  - 럆
+  - 럇
+  - 럈
+  - 량
+  - 럊
+  - 럋
+  - 럌
+  - 럍
+  - 럎
+  - 럏
+  - 럐
+  - 럑
+  - 럒
+  - 럓
+  - 럔
+  - 럕
+  - 럖
+  - 럗
+  - 럘
+  - 럙
+  - 럚
+  - 럛
+  - 럜
+  - 럝
+  - 럞
+  - 럟
+  - 럠
+  - 럡
+  - 럢
+  - 럣
+  - 럤
+  - 럥
+  - 럦
+  - 럧
+  - 럨
+  - 럩
+  - 럪
+  - 럫
+  - 러
+  - 럭
+  - 럮
+  - 럯
+  - 런
+  - 럱
+  - 럲
+  - 럳
+  - 럴
+  - 럵
+  - 럶
+  - 럷
+  - 럸
+  - 럹
+  - 럺
+  - 럻
+  - 럼
+  - 럽
+  - 럾
+  - 럿
+  - 렀
+  - 렁
+  - 렂
+  - 렃
+  - 렄
+  - 렅
+  - 렆
+  - 렇
+  - 레
+  - 렉
+  - 렊
+  - 렋
+  - 렌
+  - 렍
+  - 렎
+  - 렏
+  - 렐
+  - 렑
+  - 렒
+  - 렓
+  - 렔
+  - 렕
+  - 렖
+  - 렗
+  - 렘
+  - 렙
+  - 렚
+  - 렛
+  - 렜
+  - 렝
+  - 렞
+  - 렟
+  - 렠
+  - 렡
+  - 렢
+  - 렣
+  - 려
+  - 력
+  - 렦
+  - 렧
+  - 련
+  - 렩
+  - 렪
+  - 렫
+  - 렬
+  - 렭
+  - 렮
+  - 렯
+  - 렰
+  - 렱
+  - 렲
+  - 렳
+  - 렴
+  - 렵
+  - 렶
+  - 렷
+  - 렸
+  - 령
+  - 렺
+  - 렻
+  - 렼
+  - 렽
+  - 렾
+  - 렿
+  - 례
+  - 롁
+  - 롂
+  - 롃
+  - 롄
+  - 롅
+  - 롆
+  - 롇
+  - 롈
+  - 롉
+  - 롊
+  - 롋
+  - 롌
+  - 롍
+  - 롎
+  - 롏
+  - 롐
+  - 롑
+  - 롒
+  - 롓
+  - 롔
+  - 롕
+  - 롖
+  - 롗
+  - 롘
+  - 롙
+  - 롚
+  - 롛
+  - 로
+  - 록
+  - 롞
+  - 롟
+  - 론
+  - 롡
+  - 롢
+  - 롣
+  - 롤
+  - 롥
+  - 롦
+  - 롧
+  - 롨
+  - 롩
+  - 롪
+  - 롫
+  - 롬
+  - 롭
+  - 롮
+  - 롯
+  - 롰
+  - 롱
+  - 롲
+  - 롳
+  - 롴
+  - 롵
+  - 롶
+  - 롷
+  - 롸
+  - 롹
+  - 롺
+  - 롻
+  - 롼
+  - 롽
+  - 롾
+  - 롿
+  - 뢀
+  - 뢁
+  - 뢂
+  - 뢃
+  - 뢄
+  - 뢅
+  - 뢆
+  - 뢇
+  - 뢈
+  - 뢉
+  - 뢊
+  - 뢋
+  - 뢌
+  - 뢍
+  - 뢎
+  - 뢏
+  - 뢐
+  - 뢑
+  - 뢒
+  - 뢓
+  - 뢔
+  - 뢕
+  - 뢖
+  - 뢗
+  - 뢘
+  - 뢙
+  - 뢚
+  - 뢛
+  - 뢜
+  - 뢝
+  - 뢞
+  - 뢟
+  - 뢠
+  - 뢡
+  - 뢢
+  - 뢣
+  - 뢤
+  - 뢥
+  - 뢦
+  - 뢧
+  - 뢨
+  - 뢩
+  - 뢪
+  - 뢫
+  - 뢬
+  - 뢭
+  - 뢮
+  - 뢯
+  - 뢰
+  - 뢱
+  - 뢲
+  - 뢳
+  - 뢴
+  - 뢵
+  - 뢶
+  - 뢷
+  - 뢸
+  - 뢹
+  - 뢺
+  - 뢻
+  - 뢼
+  - 뢽
+  - 뢾
+  - 뢿
+  - 룀
+  - 룁
+  - 룂
+  - 룃
+  - 룄
+  - 룅
+  - 룆
+  - 룇
+  - 룈
+  - 룉
+  - 룊
+  - 룋
+  - 료
+  - 룍
+  - 룎
+  - 룏
+  - 룐
+  - 룑
+  - 룒
+  - 룓
+  - 룔
+  - 룕
+  - 룖
+  - 룗
+  - 룘
+  - 룙
+  - 룚
+  - 룛
+  - 룜
+  - 룝
+  - 룞
+  - 룟
+  - 룠
+  - 룡
+  - 룢
+  - 룣
+  - 룤
+  - 룥
+  - 룦
+  - 룧
+  - 루
+  - 룩
+  - 룪
+  - 룫
+  - 룬
+  - 룭
+  - 룮
+  - 룯
+  - 룰
+  - 룱
+  - 룲
+  - 룳
+  - 룴
+  - 룵
+  - 룶
+  - 룷
+  - 룸
+  - 룹
+  - 룺
+  - 룻
+  - 룼
+  - 룽
+  - 룾
+  - 룿
+  - 뤀
+  - 뤁
+  - 뤂
+  - 뤃
+  - 뤄
+  - 뤅
+  - 뤆
+  - 뤇
+  - 뤈
+  - 뤉
+  - 뤊
+  - 뤋
+  - 뤌
+  - 뤍
+  - 뤎
+  - 뤏
+  - 뤐
+  - 뤑
+  - 뤒
+  - 뤓
+  - 뤔
+  - 뤕
+  - 뤖
+  - 뤗
+  - 뤘
+  - 뤙
+  - 뤚
+  - 뤛
+  - 뤜
+  - 뤝
+  - 뤞
+  - 뤟
+  - 뤠
+  - 뤡
+  - 뤢
+  - 뤣
+  - 뤤
+  - 뤥
+  - 뤦
+  - 뤧
+  - 뤨
+  - 뤩
+  - 뤪
+  - 뤫
+  - 뤬
+  - 뤭
+  - 뤮
+  - 뤯
+  - 뤰
+  - 뤱
+  - 뤲
+  - 뤳
+  - 뤴
+  - 뤵
+  - 뤶
+  - 뤷
+  - 뤸
+  - 뤹
+  - 뤺
+  - 뤻
+  - 뤼
+  - 뤽
+  - 뤾
+  - 뤿
+  - 륀
+  - 륁
+  - 륂
+  - 륃
+  - 륄
+  - 륅
+  - 륆
+  - 륇
+  - 륈
+  - 륉
+  - 륊
+  - 륋
+  - 륌
+  - 륍
+  - 륎
+  - 륏
+  - 륐
+  - 륑
+  - 륒
+  - 륓
+  - 륔
+  - 륕
+  - 륖
+  - 륗
+  - 류
+  - 륙
+  - 륚
+  - 륛
+  - 륜
+  - 륝
+  - 륞
+  - 륟
+  - 률
+  - 륡
+  - 륢
+  - 륣
+  - 륤
+  - 륥
+  - 륦
+  - 륧
+  - 륨
+  - 륩
+  - 륪
+  - 륫
+  - 륬
+  - 륭
+  - 륮
+  - 륯
+  - 륰
+  - 륱
+  - 륲
+  - 륳
+  - 르
+  - 륵
+  - 륶
+  - 륷
+  - 른
+  - 륹
+  - 륺
+  - 륻
+  - 를
+  - 륽
+  - 륾
+  - 륿
+  - 릀
+  - 릁
+  - 릂
+  - 릃
+  - 름
+  - 릅
+  - 릆
+  - 릇
+  - 릈
+  - 릉
+  - 릊
+  - 릋
+  - 릌
+  - 릍
+  - 릎
+  - 릏
+  - 릐
+  - 릑
+  - 릒
+  - 릓
+  - 릔
+  - 릕
+  - 릖
+  - 릗
+  - 릘
+  - 릙
+  - 릚
+  - 릛
+  - 릜
+  - 릝
+  - 릞
+  - 릟
+  - 릠
+  - 릡
+  - 릢
+  - 릣
+  - 릤
+  - 릥
+  - 릦
+  - 릧
+  - 릨
+  - 릩
+  - 릪
+  - 릫
+  - 리
+  - 릭
+  - 릮
+  - 릯
+  - 린
+  - 릱
+  - 릲
+  - 릳
+  - 릴
+  - 릵
+  - 릶
+  - 릷
+  - 릸
+  - 릹
+  - 릺
+  - 릻
+  - 림
+  - 립
+  - 릾
+  - 릿
+  - 맀
+  - 링
+  - 맂
+  - 맃
+  - 맄
+  - 맅
+  - 맆
+  - 맇
+  - 마
+  - 막
+  - 맊
+  - 맋
+  - 만
+  - 맍
+  - 많
+  - 맏
+  - 말
+  - 맑
+  - 맒
+  - 맓
+  - 맔
+  - 맕
+  - 맖
+  - 맗
+  - 맘
+  - 맙
+  - 맚
+  - 맛
+  - 맜
+  - 망
+  - 맞
+  - 맟
+  - 맠
+  - 맡
+  - 맢
+  - 맣
+  - 매
+  - 맥
+  - 맦
+  - 맧
+  - 맨
+  - 맩
+  - 맪
+  - 맫
+  - 맬
+  - 맭
+  - 맮
+  - 맯
+  - 맰
+  - 맱
+  - 맲
+  - 맳
+  - 맴
+  - 맵
+  - 맶
+  - 맷
+  - 맸
+  - 맹
+  - 맺
+  - 맻
+  - 맼
+  - 맽
+  - 맾
+  - 맿
+  - 먀
+  - 먁
+  - 먂
+  - 먃
+  - 먄
+  - 먅
+  - 먆
+  - 먇
+  - 먈
+  - 먉
+  - 먊
+  - 먋
+  - 먌
+  - 먍
+  - 먎
+  - 먏
+  - 먐
+  - 먑
+  - 먒
+  - 먓
+  - 먔
+  - 먕
+  - 먖
+  - 먗
+  - 먘
+  - 먙
+  - 먚
+  - 먛
+  - 먜
+  - 먝
+  - 먞
+  - 먟
+  - 먠
+  - 먡
+  - 먢
+  - 먣
+  - 먤
+  - 먥
+  - 먦
+  - 먧
+  - 먨
+  - 먩
+  - 먪
+  - 먫
+  - 먬
+  - 먭
+  - 먮
+  - 먯
+  - 먰
+  - 먱
+  - 먲
+  - 먳
+  - 먴
+  - 먵
+  - 먶
+  - 먷
+  - 머
+  - 먹
+  - 먺
+  - 먻
+  - 먼
+  - 먽
+  - 먾
+  - 먿
+  - 멀
+  - 멁
+  - 멂
+  - 멃
+  - 멄
+  - 멅
+  - 멆
+  - 멇
+  - 멈
+  - 멉
+  - 멊
+  - 멋
+  - 멌
+  - 멍
+  - 멎
+  - 멏
+  - 멐
+  - 멑
+  - 멒
+  - 멓
+  - 메
+  - 멕
+  - 멖
+  - 멗
+  - 멘
+  - 멙
+  - 멚
+  - 멛
+  - 멜
+  - 멝
+  - 멞
+  - 멟
+  - 멠
+  - 멡
+  - 멢
+  - 멣
+  - 멤
+  - 멥
+  - 멦
+  - 멧
+  - 멨
+  - 멩
+  - 멪
+  - 멫
+  - 멬
+  - 멭
+  - 멮
+  - 멯
+  - 며
+  - 멱
+  - 멲
+  - 멳
+  - 면
+  - 멵
+  - 멶
+  - 멷
+  - 멸
+  - 멹
+  - 멺
+  - 멻
+  - 멼
+  - 멽
+  - 멾
+  - 멿
+  - 몀
+  - 몁
+  - 몂
+  - 몃
+  - 몄
+  - 명
+  - 몆
+  - 몇
+  - 몈
+  - 몉
+  - 몊
+  - 몋
+  - 몌
+  - 몍
+  - 몎
+  - 몏
+  - 몐
+  - 몑
+  - 몒
+  - 몓
+  - 몔
+  - 몕
+  - 몖
+  - 몗
+  - 몘
+  - 몙
+  - 몚
+  - 몛
+  - 몜
+  - 몝
+  - 몞
+  - 몟
+  - 몠
+  - 몡
+  - 몢
+  - 몣
+  - 몤
+  - 몥
+  - 몦
+  - 몧
+  - 모
+  - 목
+  - 몪
+  - 몫
+  - 몬
+  - 몭
+  - 몮
+  - 몯
+  - 몰
+  - 몱
+  - 몲
+  - 몳
+  - 몴
+  - 몵
+  - 몶
+  - 몷
+  - 몸
+  - 몹
+  - 몺
+  - 못
+  - 몼
+  - 몽
+  - 몾
+  - 몿
+  - 뫀
+  - 뫁
+  - 뫂
+  - 뫃
+  - 뫄
+  - 뫅
+  - 뫆
+  - 뫇
+  - 뫈
+  - 뫉
+  - 뫊
+  - 뫋
+  - 뫌
+  - 뫍
+  - 뫎
+  - 뫏
+  - 뫐
+  - 뫑
+  - 뫒
+  - 뫓
+  - 뫔
+  - 뫕
+  - 뫖
+  - 뫗
+  - 뫘
+  - 뫙
+  - 뫚
+  - 뫛
+  - 뫜
+  - 뫝
+  - 뫞
+  - 뫟
+  - 뫠
+  - 뫡
+  - 뫢
+  - 뫣
+  - 뫤
+  - 뫥
+  - 뫦
+  - 뫧
+  - 뫨
+  - 뫩
+  - 뫪
+  - 뫫
+  - 뫬
+  - 뫭
+  - 뫮
+  - 뫯
+  - 뫰
+  - 뫱
+  - 뫲
+  - 뫳
+  - 뫴
+  - 뫵
+  - 뫶
+  - 뫷
+  - 뫸
+  - 뫹
+  - 뫺
+  - 뫻
+  - 뫼
+  - 뫽
+  - 뫾
+  - 뫿
+  - 묀
+  - 묁
+  - 묂
+  - 묃
+  - 묄
+  - 묅
+  - 묆
+  - 묇
+  - 묈
+  - 묉
+  - 묊
+  - 묋
+  - 묌
+  - 묍
+  - 묎
+  - 묏
+  - 묐
+  - 묑
+  - 묒
+  - 묓
+  - 묔
+  - 묕
+  - 묖
+  - 묗
+  - 묘
+  - 묙
+  - 묚
+  - 묛
+  - 묜
+  - 묝
+  - 묞
+  - 묟
+  - 묠
+  - 묡
+  - 묢
+  - 묣
+  - 묤
+  - 묥
+  - 묦
+  - 묧
+  - 묨
+  - 묩
+  - 묪
+  - 묫
+  - 묬
+  - 묭
+  - 묮
+  - 묯
+  - 묰
+  - 묱
+  - 묲
+  - 묳
+  - 무
+  - 묵
+  - 묶
+  - 묷
+  - 문
+  - 묹
+  - 묺
+  - 묻
+  - 물
+  - 묽
+  - 묾
+  - 묿
+  - 뭀
+  - 뭁
+  - 뭂
+  - 뭃
+  - 뭄
+  - 뭅
+  - 뭆
+  - 뭇
+  - 뭈
+  - 뭉
+  - 뭊
+  - 뭋
+  - 뭌
+  - 뭍
+  - 뭎
+  - 뭏
+  - 뭐
+  - 뭑
+  - 뭒
+  - 뭓
+  - 뭔
+  - 뭕
+  - 뭖
+  - 뭗
+  - 뭘
+  - 뭙
+  - 뭚
+  - 뭛
+  - 뭜
+  - 뭝
+  - 뭞
+  - 뭟
+  - 뭠
+  - 뭡
+  - 뭢
+  - 뭣
+  - 뭤
+  - 뭥
+  - 뭦
+  - 뭧
+  - 뭨
+  - 뭩
+  - 뭪
+  - 뭫
+  - 뭬
+  - 뭭
+  - 뭮
+  - 뭯
+  - 뭰
+  - 뭱
+  - 뭲
+  - 뭳
+  - 뭴
+  - 뭵
+  - 뭶
+  - 뭷
+  - 뭸
+  - 뭹
+  - 뭺
+  - 뭻
+  - 뭼
+  - 뭽
+  - 뭾
+  - 뭿
+  - 뮀
+  - 뮁
+  - 뮂
+  - 뮃
+  - 뮄
+  - 뮅
+  - 뮆
+  - 뮇
+  - 뮈
+  - 뮉
+  - 뮊
+  - 뮋
+  - 뮌
+  - 뮍
+  - 뮎
+  - 뮏
+  - 뮐
+  - 뮑
+  - 뮒
+  - 뮓
+  - 뮔
+  - 뮕
+  - 뮖
+  - 뮗
+  - 뮘
+  - 뮙
+  - 뮚
+  - 뮛
+  - 뮜
+  - 뮝
+  - 뮞
+  - 뮟
+  - 뮠
+  - 뮡
+  - 뮢
+  - 뮣
+  - 뮤
+  - 뮥
+  - 뮦
+  - 뮧
+  - 뮨
+  - 뮩
+  - 뮪
+  - 뮫
+  - 뮬
+  - 뮭
+  - 뮮
+  - 뮯
+  - 뮰
+  - 뮱
+  - 뮲
+  - 뮳
+  - 뮴
+  - 뮵
+  - 뮶
+  - 뮷
+  - 뮸
+  - 뮹
+  - 뮺
+  - 뮻
+  - 뮼
+  - 뮽
+  - 뮾
+  - 뮿
+  - 므
+  - 믁
+  - 믂
+  - 믃
+  - 믄
+  - 믅
+  - 믆
+  - 믇
+  - 믈
+  - 믉
+  - 믊
+  - 믋
+  - 믌
+  - 믍
+  - 믎
+  - 믏
+  - 믐
+  - 믑
+  - 믒
+  - 믓
+  - 믔
+  - 믕
+  - 믖
+  - 믗
+  - 믘
+  - 믙
+  - 믚
+  - 믛
+  - 믜
+  - 믝
+  - 믞
+  - 믟
+  - 믠
+  - 믡
+  - 믢
+  - 믣
+  - 믤
+  - 믥
+  - 믦
+  - 믧
+  - 믨
+  - 믩
+  - 믪
+  - 믫
+  - 믬
+  - 믭
+  - 믮
+  - 믯
+  - 믰
+  - 믱
+  - 믲
+  - 믳
+  - 믴
+  - 믵
+  - 믶
+  - 믷
+  - 미
+  - 믹
+  - 믺
+  - 믻
+  - 민
+  - 믽
+  - 믾
+  - 믿
+  - 밀
+  - 밁
+  - 밂
+  - 밃
+  - 밄
+  - 밅
+  - 밆
+  - 밇
+  - 밈
+  - 밉
+  - 밊
+  - 밋
+  - 밌
+  - 밍
+  - 밎
+  - 및
+  - 밐
+  - 밑
+  - 밒
+  - 밓
+  - 바
+  - 박
+  - 밖
+  - 밗
+  - 반
+  - 밙
+  - 밚
+  - 받
+  - 발
+  - 밝
+  - 밞
+  - 밟
+  - 밠
+  - 밡
+  - 밢
+  - 밣
+  - 밤
+  - 밥
+  - 밦
+  - 밧
+  - 밨
+  - 방
+  - 밪
+  - 밫
+  - 밬
+  - 밭
+  - 밮
+  - 밯
+  - 배
+  - 백
+  - 밲
+  - 밳
+  - 밴
+  - 밵
+  - 밶
+  - 밷
+  - 밸
+  - 밹
+  - 밺
+  - 밻
+  - 밼
+  - 밽
+  - 밾
+  - 밿
+  - 뱀
+  - 뱁
+  - 뱂
+  - 뱃
+  - 뱄
+  - 뱅
+  - 뱆
+  - 뱇
+  - 뱈
+  - 뱉
+  - 뱊
+  - 뱋
+  - 뱌
+  - 뱍
+  - 뱎
+  - 뱏
+  - 뱐
+  - 뱑
+  - 뱒
+  - 뱓
+  - 뱔
+  - 뱕
+  - 뱖
+  - 뱗
+  - 뱘
+  - 뱙
+  - 뱚
+  - 뱛
+  - 뱜
+  - 뱝
+  - 뱞
+  - 뱟
+  - 뱠
+  - 뱡
+  - 뱢
+  - 뱣
+  - 뱤
+  - 뱥
+  - 뱦
+  - 뱧
+  - 뱨
+  - 뱩
+  - 뱪
+  - 뱫
+  - 뱬
+  - 뱭
+  - 뱮
+  - 뱯
+  - 뱰
+  - 뱱
+  - 뱲
+  - 뱳
+  - 뱴
+  - 뱵
+  - 뱶
+  - 뱷
+  - 뱸
+  - 뱹
+  - 뱺
+  - 뱻
+  - 뱼
+  - 뱽
+  - 뱾
+  - 뱿
+  - 벀
+  - 벁
+  - 벂
+  - 벃
+  - 버
+  - 벅
+  - 벆
+  - 벇
+  - 번
+  - 벉
+  - 벊
+  - 벋
+  - 벌
+  - 벍
+  - 벎
+  - 벏
+  - 벐
+  - 벑
+  - 벒
+  - 벓
+  - 범
+  - 법
+  - 벖
+  - 벗
+  - 벘
+  - 벙
+  - 벚
+  - 벛
+  - 벜
+  - 벝
+  - 벞
+  - 벟
+  - 베
+  - 벡
+  - 벢
+  - 벣
+  - 벤
+  - 벥
+  - 벦
+  - 벧
+  - 벨
+  - 벩
+  - 벪
+  - 벫
+  - 벬
+  - 벭
+  - 벮
+  - 벯
+  - 벰
+  - 벱
+  - 벲
+  - 벳
+  - 벴
+  - 벵
+  - 벶
+  - 벷
+  - 벸
+  - 벹
+  - 벺
+  - 벻
+  - 벼
+  - 벽
+  - 벾
+  - 벿
+  - 변
+  - 볁
+  - 볂
+  - 볃
+  - 별
+  - 볅
+  - 볆
+  - 볇
+  - 볈
+  - 볉
+  - 볊
+  - 볋
+  - 볌
+  - 볍
+  - 볎
+  - 볏
+  - 볐
+  - 병
+  - 볒
+  - 볓
+  - 볔
+  - 볕
+  - 볖
+  - 볗
+  - 볘
+  - 볙
+  - 볚
+  - 볛
+  - 볜
+  - 볝
+  - 볞
+  - 볟
+  - 볠
+  - 볡
+  - 볢
+  - 볣
+  - 볤
+  - 볥
+  - 볦
+  - 볧
+  - 볨
+  - 볩
+  - 볪
+  - 볫
+  - 볬
+  - 볭
+  - 볮
+  - 볯
+  - 볰
+  - 볱
+  - 볲
+  - 볳
+  - 보
+  - 복
+  - 볶
+  - 볷
+  - 본
+  - 볹
+  - 볺
+  - 볻
+  - 볼
+  - 볽
+  - 볾
+  - 볿
+  - 봀
+  - 봁
+  - 봂
+  - 봃
+  - 봄
+  - 봅
+  - 봆
+  - 봇
+  - 봈
+  - 봉
+  - 봊
+  - 봋
+  - 봌
+  - 봍
+  - 봎
+  - 봏
+  - 봐
+  - 봑
+  - 봒
+  - 봓
+  - 봔
+  - 봕
+  - 봖
+  - 봗
+  - 봘
+  - 봙
+  - 봚
+  - 봛
+  - 봜
+  - 봝
+  - 봞
+  - 봟
+  - 봠
+  - 봡
+  - 봢
+  - 봣
+  - 봤
+  - 봥
+  - 봦
+  - 봧
+  - 봨
+  - 봩
+  - 봪
+  - 봫
+  - 봬
+  - 봭
+  - 봮
+  - 봯
+  - 봰
+  - 봱
+  - 봲
+  - 봳
+  - 봴
+  - 봵
+  - 봶
+  - 봷
+  - 봸
+  - 봹
+  - 봺
+  - 봻
+  - 봼
+  - 봽
+  - 봾
+  - 봿
+  - 뵀
+  - 뵁
+  - 뵂
+  - 뵃
+  - 뵄
+  - 뵅
+  - 뵆
+  - 뵇
+  - 뵈
+  - 뵉
+  - 뵊
+  - 뵋
+  - 뵌
+  - 뵍
+  - 뵎
+  - 뵏
+  - 뵐
+  - 뵑
+  - 뵒
+  - 뵓
+  - 뵔
+  - 뵕
+  - 뵖
+  - 뵗
+  - 뵘
+  - 뵙
+  - 뵚
+  - 뵛
+  - 뵜
+  - 뵝
+  - 뵞
+  - 뵟
+  - 뵠
+  - 뵡
+  - 뵢
+  - 뵣
+  - 뵤
+  - 뵥
+  - 뵦
+  - 뵧
+  - 뵨
+  - 뵩
+  - 뵪
+  - 뵫
+  - 뵬
+  - 뵭
+  - 뵮
+  - 뵯
+  - 뵰
+  - 뵱
+  - 뵲
+  - 뵳
+  - 뵴
+  - 뵵
+  - 뵶
+  - 뵷
+  - 뵸
+  - 뵹
+  - 뵺
+  - 뵻
+  - 뵼
+  - 뵽
+  - 뵾
+  - 뵿
+  - 부
+  - 북
+  - 붂
+  - 붃
+  - 분
+  - 붅
+  - 붆
+  - 붇
+  - 불
+  - 붉
+  - 붊
+  - 붋
+  - 붌
+  - 붍
+  - 붎
+  - 붏
+  - 붐
+  - 붑
+  - 붒
+  - 붓
+  - 붔
+  - 붕
+  - 붖
+  - 붗
+  - 붘
+  - 붙
+  - 붚
+  - 붛
+  - 붜
+  - 붝
+  - 붞
+  - 붟
+  - 붠
+  - 붡
+  - 붢
+  - 붣
+  - 붤
+  - 붥
+  - 붦
+  - 붧
+  - 붨
+  - 붩
+  - 붪
+  - 붫
+  - 붬
+  - 붭
+  - 붮
+  - 붯
+  - 붰
+  - 붱
+  - 붲
+  - 붳
+  - 붴
+  - 붵
+  - 붶
+  - 붷
+  - 붸
+  - 붹
+  - 붺
+  - 붻
+  - 붼
+  - 붽
+  - 붾
+  - 붿
+  - 뷀
+  - 뷁
+  - 뷂
+  - 뷃
+  - 뷄
+  - 뷅
+  - 뷆
+  - 뷇
+  - 뷈
+  - 뷉
+  - 뷊
+  - 뷋
+  - 뷌
+  - 뷍
+  - 뷎
+  - 뷏
+  - 뷐
+  - 뷑
+  - 뷒
+  - 뷓
+  - 뷔
+  - 뷕
+  - 뷖
+  - 뷗
+  - 뷘
+  - 뷙
+  - 뷚
+  - 뷛
+  - 뷜
+  - 뷝
+  - 뷞
+  - 뷟
+  - 뷠
+  - 뷡
+  - 뷢
+  - 뷣
+  - 뷤
+  - 뷥
+  - 뷦
+  - 뷧
+  - 뷨
+  - 뷩
+  - 뷪
+  - 뷫
+  - 뷬
+  - 뷭
+  - 뷮
+  - 뷯
+  - 뷰
+  - 뷱
+  - 뷲
+  - 뷳
+  - 뷴
+  - 뷵
+  - 뷶
+  - 뷷
+  - 뷸
+  - 뷹
+  - 뷺
+  - 뷻
+  - 뷼
+  - 뷽
+  - 뷾
+  - 뷿
+  - 븀
+  - 븁
+  - 븂
+  - 븃
+  - 븄
+  - 븅
+  - 븆
+  - 븇
+  - 븈
+  - 븉
+  - 븊
+  - 븋
+  - 브
+  - 븍
+  - 븎
+  - 븏
+  - 븐
+  - 븑
+  - 븒
+  - 븓
+  - 블
+  - 븕
+  - 븖
+  - 븗
+  - 븘
+  - 븙
+  - 븚
+  - 븛
+  - 븜
+  - 븝
+  - 븞
+  - 븟
+  - 븠
+  - 븡
+  - 븢
+  - 븣
+  - 븤
+  - 븥
+  - 븦
+  - 븧
+  - 븨
+  - 븩
+  - 븪
+  - 븫
+  - 븬
+  - 븭
+  - 븮
+  - 븯
+  - 븰
+  - 븱
+  - 븲
+  - 븳
+  - 븴
+  - 븵
+  - 븶
+  - 븷
+  - 븸
+  - 븹
+  - 븺
+  - 븻
+  - 븼
+  - 븽
+  - 븾
+  - 븿
+  - 빀
+  - 빁
+  - 빂
+  - 빃
+  - 비
+  - 빅
+  - 빆
+  - 빇
+  - 빈
+  - 빉
+  - 빊
+  - 빋
+  - 빌
+  - 빍
+  - 빎
+  - 빏
+  - 빐
+  - 빑
+  - 빒
+  - 빓
+  - 빔
+  - 빕
+  - 빖
+  - 빗
+  - 빘
+  - 빙
+  - 빚
+  - 빛
+  - 빜
+  - 빝
+  - 빞
+  - 빟
+  - 빠
+  - 빡
+  - 빢
+  - 빣
+  - 빤
+  - 빥
+  - 빦
+  - 빧
+  - 빨
+  - 빩
+  - 빪
+  - 빫
+  - 빬
+  - 빭
+  - 빮
+  - 빯
+  - 빰
+  - 빱
+  - 빲
+  - 빳
+  - 빴
+  - 빵
+  - 빶
+  - 빷
+  - 빸
+  - 빹
+  - 빺
+  - 빻
+  - 빼
+  - 빽
+  - 빾
+  - 빿
+  - 뺀
+  - 뺁
+  - 뺂
+  - 뺃
+  - 뺄
+  - 뺅
+  - 뺆
+  - 뺇
+  - 뺈
+  - 뺉
+  - 뺊
+  - 뺋
+  - 뺌
+  - 뺍
+  - 뺎
+  - 뺏
+  - 뺐
+  - 뺑
+  - 뺒
+  - 뺓
+  - 뺔
+  - 뺕
+  - 뺖
+  - 뺗
+  - 뺘
+  - 뺙
+  - 뺚
+  - 뺛
+  - 뺜
+  - 뺝
+  - 뺞
+  - 뺟
+  - 뺠
+  - 뺡
+  - 뺢
+  - 뺣
+  - 뺤
+  - 뺥
+  - 뺦
+  - 뺧
+  - 뺨
+  - 뺩
+  - 뺪
+  - 뺫
+  - 뺬
+  - 뺭
+  - 뺮
+  - 뺯
+  - 뺰
+  - 뺱
+  - 뺲
+  - 뺳
+  - 뺴
+  - 뺵
+  - 뺶
+  - 뺷
+  - 뺸
+  - 뺹
+  - 뺺
+  - 뺻
+  - 뺼
+  - 뺽
+  - 뺾
+  - 뺿
+  - 뻀
+  - 뻁
+  - 뻂
+  - 뻃
+  - 뻄
+  - 뻅
+  - 뻆
+  - 뻇
+  - 뻈
+  - 뻉
+  - 뻊
+  - 뻋
+  - 뻌
+  - 뻍
+  - 뻎
+  - 뻏
+  - 뻐
+  - 뻑
+  - 뻒
+  - 뻓
+  - 뻔
+  - 뻕
+  - 뻖
+  - 뻗
+  - 뻘
+  - 뻙
+  - 뻚
+  - 뻛
+  - 뻜
+  - 뻝
+  - 뻞
+  - 뻟
+  - 뻠
+  - 뻡
+  - 뻢
+  - 뻣
+  - 뻤
+  - 뻥
+  - 뻦
+  - 뻧
+  - 뻨
+  - 뻩
+  - 뻪
+  - 뻫
+  - 뻬
+  - 뻭
+  - 뻮
+  - 뻯
+  - 뻰
+  - 뻱
+  - 뻲
+  - 뻳
+  - 뻴
+  - 뻵
+  - 뻶
+  - 뻷
+  - 뻸
+  - 뻹
+  - 뻺
+  - 뻻
+  - 뻼
+  - 뻽
+  - 뻾
+  - 뻿
+  - 뼀
+  - 뼁
+  - 뼂
+  - 뼃
+  - 뼄
+  - 뼅
+  - 뼆
+  - 뼇
+  - 뼈
+  - 뼉
+  - 뼊
+  - 뼋
+  - 뼌
+  - 뼍
+  - 뼎
+  - 뼏
+  - 뼐
+  - 뼑
+  - 뼒
+  - 뼓
+  - 뼔
+  - 뼕
+  - 뼖
+  - 뼗
+  - 뼘
+  - 뼙
+  - 뼚
+  - 뼛
+  - 뼜
+  - 뼝
+  - 뼞
+  - 뼟
+  - 뼠
+  - 뼡
+  - 뼢
+  - 뼣
+  - 뼤
+  - 뼥
+  - 뼦
+  - 뼧
+  - 뼨
+  - 뼩
+  - 뼪
+  - 뼫
+  - 뼬
+  - 뼭
+  - 뼮
+  - 뼯
+  - 뼰
+  - 뼱
+  - 뼲
+  - 뼳
+  - 뼴
+  - 뼵
+  - 뼶
+  - 뼷
+  - 뼸
+  - 뼹
+  - 뼺
+  - 뼻
+  - 뼼
+  - 뼽
+  - 뼾
+  - 뼿
+  - 뽀
+  - 뽁
+  - 뽂
+  - 뽃
+  - 뽄
+  - 뽅
+  - 뽆
+  - 뽇
+  - 뽈
+  - 뽉
+  - 뽊
+  - 뽋
+  - 뽌
+  - 뽍
+  - 뽎
+  - 뽏
+  - 뽐
+  - 뽑
+  - 뽒
+  - 뽓
+  - 뽔
+  - 뽕
+  - 뽖
+  - 뽗
+  - 뽘
+  - 뽙
+  - 뽚
+  - 뽛
+  - 뽜
+  - 뽝
+  - 뽞
+  - 뽟
+  - 뽠
+  - 뽡
+  - 뽢
+  - 뽣
+  - 뽤
+  - 뽥
+  - 뽦
+  - 뽧
+  - 뽨
+  - 뽩
+  - 뽪
+  - 뽫
+  - 뽬
+  - 뽭
+  - 뽮
+  - 뽯
+  - 뽰
+  - 뽱
+  - 뽲
+  - 뽳
+  - 뽴
+  - 뽵
+  - 뽶
+  - 뽷
+  - 뽸
+  - 뽹
+  - 뽺
+  - 뽻
+  - 뽼
+  - 뽽
+  - 뽾
+  - 뽿
+  - 뾀
+  - 뾁
+  - 뾂
+  - 뾃
+  - 뾄
+  - 뾅
+  - 뾆
+  - 뾇
+  - 뾈
+  - 뾉
+  - 뾊
+  - 뾋
+  - 뾌
+  - 뾍
+  - 뾎
+  - 뾏
+  - 뾐
+  - 뾑
+  - 뾒
+  - 뾓
+  - 뾔
+  - 뾕
+  - 뾖
+  - 뾗
+  - 뾘
+  - 뾙
+  - 뾚
+  - 뾛
+  - 뾜
+  - 뾝
+  - 뾞
+  - 뾟
+  - 뾠
+  - 뾡
+  - 뾢
+  - 뾣
+  - 뾤
+  - 뾥
+  - 뾦
+  - 뾧
+  - 뾨
+  - 뾩
+  - 뾪
+  - 뾫
+  - 뾬
+  - 뾭
+  - 뾮
+  - 뾯
+  - 뾰
+  - 뾱
+  - 뾲
+  - 뾳
+  - 뾴
+  - 뾵
+  - 뾶
+  - 뾷
+  - 뾸
+  - 뾹
+  - 뾺
+  - 뾻
+  - 뾼
+  - 뾽
+  - 뾾
+  - 뾿
+  - 뿀
+  - 뿁
+  - 뿂
+  - 뿃
+  - 뿄
+  - 뿅
+  - 뿆
+  - 뿇
+  - 뿈
+  - 뿉
+  - 뿊
+  - 뿋
+  - 뿌
+  - 뿍
+  - 뿎
+  - 뿏
+  - 뿐
+  - 뿑
+  - 뿒
+  - 뿓
+  - 뿔
+  - 뿕
+  - 뿖
+  - 뿗
+  - 뿘
+  - 뿙
+  - 뿚
+  - 뿛
+  - 뿜
+  - 뿝
+  - 뿞
+  - 뿟
+  - 뿠
+  - 뿡
+  - 뿢
+  - 뿣
+  - 뿤
+  - 뿥
+  - 뿦
+  - 뿧
+  - 뿨
+  - 뿩
+  - 뿪
+  - 뿫
+  - 뿬
+  - 뿭
+  - 뿮
+  - 뿯
+  - 뿰
+  - 뿱
+  - 뿲
+  - 뿳
+  - 뿴
+  - 뿵
+  - 뿶
+  - 뿷
+  - 뿸
+  - 뿹
+  - 뿺
+  - 뿻
+  - 뿼
+  - 뿽
+  - 뿾
+  - 뿿
+  - 쀀
+  - 쀁
+  - 쀂
+  - 쀃
+  - 쀄
+  - 쀅
+  - 쀆
+  - 쀇
+  - 쀈
+  - 쀉
+  - 쀊
+  - 쀋
+  - 쀌
+  - 쀍
+  - 쀎
+  - 쀏
+  - 쀐
+  - 쀑
+  - 쀒
+  - 쀓
+  - 쀔
+  - 쀕
+  - 쀖
+  - 쀗
+  - 쀘
+  - 쀙
+  - 쀚
+  - 쀛
+  - 쀜
+  - 쀝
+  - 쀞
+  - 쀟
+  - 쀠
+  - 쀡
+  - 쀢
+  - 쀣
+  - 쀤
+  - 쀥
+  - 쀦
+  - 쀧
+  - 쀨
+  - 쀩
+  - 쀪
+  - 쀫
+  - 쀬
+  - 쀭
+  - 쀮
+  - 쀯
+  - 쀰
+  - 쀱
+  - 쀲
+  - 쀳
+  - 쀴
+  - 쀵
+  - 쀶
+  - 쀷
+  - 쀸
+  - 쀹
+  - 쀺
+  - 쀻
+  - 쀼
+  - 쀽
+  - 쀾
+  - 쀿
+  - 쁀
+  - 쁁
+  - 쁂
+  - 쁃
+  - 쁄
+  - 쁅
+  - 쁆
+  - 쁇
+  - 쁈
+  - 쁉
+  - 쁊
+  - 쁋
+  - 쁌
+  - 쁍
+  - 쁎
+  - 쁏
+  - 쁐
+  - 쁑
+  - 쁒
+  - 쁓
+  - 쁔
+  - 쁕
+  - 쁖
+  - 쁗
+  - 쁘
+  - 쁙
+  - 쁚
+  - 쁛
+  - 쁜
+  - 쁝
+  - 쁞
+  - 쁟
+  - 쁠
+  - 쁡
+  - 쁢
+  - 쁣
+  - 쁤
+  - 쁥
+  - 쁦
+  - 쁧
+  - 쁨
+  - 쁩
+  - 쁪
+  - 쁫
+  - 쁬
+  - 쁭
+  - 쁮
+  - 쁯
+  - 쁰
+  - 쁱
+  - 쁲
+  - 쁳
+  - 쁴
+  - 쁵
+  - 쁶
+  - 쁷
+  - 쁸
+  - 쁹
+  - 쁺
+  - 쁻
+  - 쁼
+  - 쁽
+  - 쁾
+  - 쁿
+  - 삀
+  - 삁
+  - 삂
+  - 삃
+  - 삄
+  - 삅
+  - 삆
+  - 삇
+  - 삈
+  - 삉
+  - 삊
+  - 삋
+  - 삌
+  - 삍
+  - 삎
+  - 삏
+  - 삐
+  - 삑
+  - 삒
+  - 삓
+  - 삔
+  - 삕
+  - 삖
+  - 삗
+  - 삘
+  - 삙
+  - 삚
+  - 삛
+  - 삜
+  - 삝
+  - 삞
+  - 삟
+  - 삠
+  - 삡
+  - 삢
+  - 삣
+  - 삤
+  - 삥
+  - 삦
+  - 삧
+  - 삨
+  - 삩
+  - 삪
+  - 삫
+  - 사
+  - 삭
+  - 삮
+  - 삯
+  - 산
+  - 삱
+  - 삲
+  - 삳
+  - 살
+  - 삵
+  - 삶
+  - 삷
+  - 삸
+  - 삹
+  - 삺
+  - 삻
+  - 삼
+  - 삽
+  - 삾
+  - 삿
+  - 샀
+  - 상
+  - 샂
+  - 샃
+  - 샄
+  - 샅
+  - 샆
+  - 샇
+  - 새
+  - 색
+  - 샊
+  - 샋
+  - 샌
+  - 샍
+  - 샎
+  - 샏
+  - 샐
+  - 샑
+  - 샒
+  - 샓
+  - 샔
+  - 샕
+  - 샖
+  - 샗
+  - 샘
+  - 샙
+  - 샚
+  - 샛
+  - 샜
+  - 생
+  - 샞
+  - 샟
+  - 샠
+  - 샡
+  - 샢
+  - 샣
+  - 샤
+  - 샥
+  - 샦
+  - 샧
+  - 샨
+  - 샩
+  - 샪
+  - 샫
+  - 샬
+  - 샭
+  - 샮
+  - 샯
+  - 샰
+  - 샱
+  - 샲
+  - 샳
+  - 샴
+  - 샵
+  - 샶
+  - 샷
+  - 샸
+  - 샹
+  - 샺
+  - 샻
+  - 샼
+  - 샽
+  - 샾
+  - 샿
+  - 섀
+  - 섁
+  - 섂
+  - 섃
+  - 섄
+  - 섅
+  - 섆
+  - 섇
+  - 섈
+  - 섉
+  - 섊
+  - 섋
+  - 섌
+  - 섍
+  - 섎
+  - 섏
+  - 섐
+  - 섑
+  - 섒
+  - 섓
+  - 섔
+  - 섕
+  - 섖
+  - 섗
+  - 섘
+  - 섙
+  - 섚
+  - 섛
+  - 서
+  - 석
+  - 섞
+  - 섟
+  - 선
+  - 섡
+  - 섢
+  - 섣
+  - 설
+  - 섥
+  - 섦
+  - 섧
+  - 섨
+  - 섩
+  - 섪
+  - 섫
+  - 섬
+  - 섭
+  - 섮
+  - 섯
+  - 섰
+  - 성
+  - 섲
+  - 섳
+  - 섴
+  - 섵
+  - 섶
+  - 섷
+  - 세
+  - 섹
+  - 섺
+  - 섻
+  - 센
+  - 섽
+  - 섾
+  - 섿
+  - 셀
+  - 셁
+  - 셂
+  - 셃
+  - 셄
+  - 셅
+  - 셆
+  - 셇
+  - 셈
+  - 셉
+  - 셊
+  - 셋
+  - 셌
+  - 셍
+  - 셎
+  - 셏
+  - 셐
+  - 셑
+  - 셒
+  - 셓
+  - 셔
+  - 셕
+  - 셖
+  - 셗
+  - 션
+  - 셙
+  - 셚
+  - 셛
+  - 셜
+  - 셝
+  - 셞
+  - 셟
+  - 셠
+  - 셡
+  - 셢
+  - 셣
+  - 셤
+  - 셥
+  - 셦
+  - 셧
+  - 셨
+  - 셩
+  - 셪
+  - 셫
+  - 셬
+  - 셭
+  - 셮
+  - 셯
+  - 셰
+  - 셱
+  - 셲
+  - 셳
+  - 셴
+  - 셵
+  - 셶
+  - 셷
+  - 셸
+  - 셹
+  - 셺
+  - 셻
+  - 셼
+  - 셽
+  - 셾
+  - 셿
+  - 솀
+  - 솁
+  - 솂
+  - 솃
+  - 솄
+  - 솅
+  - 솆
+  - 솇
+  - 솈
+  - 솉
+  - 솊
+  - 솋
+  - 소
+  - 속
+  - 솎
+  - 솏
+  - 손
+  - 솑
+  - 솒
+  - 솓
+  - 솔
+  - 솕
+  - 솖
+  - 솗
+  - 솘
+  - 솙
+  - 솚
+  - 솛
+  - 솜
+  - 솝
+  - 솞
+  - 솟
+  - 솠
+  - 송
+  - 솢
+  - 솣
+  - 솤
+  - 솥
+  - 솦
+  - 솧
+  - 솨
+  - 솩
+  - 솪
+  - 솫
+  - 솬
+  - 솭
+  - 솮
+  - 솯
+  - 솰
+  - 솱
+  - 솲
+  - 솳
+  - 솴
+  - 솵
+  - 솶
+  - 솷
+  - 솸
+  - 솹
+  - 솺
+  - 솻
+  - 솼
+  - 솽
+  - 솾
+  - 솿
+  - 쇀
+  - 쇁
+  - 쇂
+  - 쇃
+  - 쇄
+  - 쇅
+  - 쇆
+  - 쇇
+  - 쇈
+  - 쇉
+  - 쇊
+  - 쇋
+  - 쇌
+  - 쇍
+  - 쇎
+  - 쇏
+  - 쇐
+  - 쇑
+  - 쇒
+  - 쇓
+  - 쇔
+  - 쇕
+  - 쇖
+  - 쇗
+  - 쇘
+  - 쇙
+  - 쇚
+  - 쇛
+  - 쇜
+  - 쇝
+  - 쇞
+  - 쇟
+  - 쇠
+  - 쇡
+  - 쇢
+  - 쇣
+  - 쇤
+  - 쇥
+  - 쇦
+  - 쇧
+  - 쇨
+  - 쇩
+  - 쇪
+  - 쇫
+  - 쇬
+  - 쇭
+  - 쇮
+  - 쇯
+  - 쇰
+  - 쇱
+  - 쇲
+  - 쇳
+  - 쇴
+  - 쇵
+  - 쇶
+  - 쇷
+  - 쇸
+  - 쇹
+  - 쇺
+  - 쇻
+  - 쇼
+  - 쇽
+  - 쇾
+  - 쇿
+  - 숀
+  - 숁
+  - 숂
+  - 숃
+  - 숄
+  - 숅
+  - 숆
+  - 숇
+  - 숈
+  - 숉
+  - 숊
+  - 숋
+  - 숌
+  - 숍
+  - 숎
+  - 숏
+  - 숐
+  - 숑
+  - 숒
+  - 숓
+  - 숔
+  - 숕
+  - 숖
+  - 숗
+  - 수
+  - 숙
+  - 숚
+  - 숛
+  - 순
+  - 숝
+  - 숞
+  - 숟
+  - 술
+  - 숡
+  - 숢
+  - 숣
+  - 숤
+  - 숥
+  - 숦
+  - 숧
+  - 숨
+  - 숩
+  - 숪
+  - 숫
+  - 숬
+  - 숭
+  - 숮
+  - 숯
+  - 숰
+  - 숱
+  - 숲
+  - 숳
+  - 숴
+  - 숵
+  - 숶
+  - 숷
+  - 숸
+  - 숹
+  - 숺
+  - 숻
+  - 숼
+  - 숽
+  - 숾
+  - 숿
+  - 쉀
+  - 쉁
+  - 쉂
+  - 쉃
+  - 쉄
+  - 쉅
+  - 쉆
+  - 쉇
+  - 쉈
+  - 쉉
+  - 쉊
+  - 쉋
+  - 쉌
+  - 쉍
+  - 쉎
+  - 쉏
+  - 쉐
+  - 쉑
+  - 쉒
+  - 쉓
+  - 쉔
+  - 쉕
+  - 쉖
+  - 쉗
+  - 쉘
+  - 쉙
+  - 쉚
+  - 쉛
+  - 쉜
+  - 쉝
+  - 쉞
+  - 쉟
+  - 쉠
+  - 쉡
+  - 쉢
+  - 쉣
+  - 쉤
+  - 쉥
+  - 쉦
+  - 쉧
+  - 쉨
+  - 쉩
+  - 쉪
+  - 쉫
+  - 쉬
+  - 쉭
+  - 쉮
+  - 쉯
+  - 쉰
+  - 쉱
+  - 쉲
+  - 쉳
+  - 쉴
+  - 쉵
+  - 쉶
+  - 쉷
+  - 쉸
+  - 쉹
+  - 쉺
+  - 쉻
+  - 쉼
+  - 쉽
+  - 쉾
+  - 쉿
+  - 슀
+  - 슁
+  - 슂
+  - 슃
+  - 슄
+  - 슅
+  - 슆
+  - 슇
+  - 슈
+  - 슉
+  - 슊
+  - 슋
+  - 슌
+  - 슍
+  - 슎
+  - 슏
+  - 슐
+  - 슑
+  - 슒
+  - 슓
+  - 슔
+  - 슕
+  - 슖
+  - 슗
+  - 슘
+  - 슙
+  - 슚
+  - 슛
+  - 슜
+  - 슝
+  - 슞
+  - 슟
+  - 슠
+  - 슡
+  - 슢
+  - 슣
+  - 스
+  - 슥
+  - 슦
+  - 슧
+  - 슨
+  - 슩
+  - 슪
+  - 슫
+  - 슬
+  - 슭
+  - 슮
+  - 슯
+  - 슰
+  - 슱
+  - 슲
+  - 슳
+  - 슴
+  - 습
+  - 슶
+  - 슷
+  - 슸
+  - 승
+  - 슺
+  - 슻
+  - 슼
+  - 슽
+  - 슾
+  - 슿
+  - 싀
+  - 싁
+  - 싂
+  - 싃
+  - 싄
+  - 싅
+  - 싆
+  - 싇
+  - 싈
+  - 싉
+  - 싊
+  - 싋
+  - 싌
+  - 싍
+  - 싎
+  - 싏
+  - 싐
+  - 싑
+  - 싒
+  - 싓
+  - 싔
+  - 싕
+  - 싖
+  - 싗
+  - 싘
+  - 싙
+  - 싚
+  - 싛
+  - 시
+  - 식
+  - 싞
+  - 싟
+  - 신
+  - 싡
+  - 싢
+  - 싣
+  - 실
+  - 싥
+  - 싦
+  - 싧
+  - 싨
+  - 싩
+  - 싪
+  - 싫
+  - 심
+  - 십
+  - 싮
+  - 싯
+  - 싰
+  - 싱
+  - 싲
+  - 싳
+  - 싴
+  - 싵
+  - 싶
+  - 싷
+  - 싸
+  - 싹
+  - 싺
+  - 싻
+  - 싼
+  - 싽
+  - 싾
+  - 싿
+  - 쌀
+  - 쌁
+  - 쌂
+  - 쌃
+  - 쌄
+  - 쌅
+  - 쌆
+  - 쌇
+  - 쌈
+  - 쌉
+  - 쌊
+  - 쌋
+  - 쌌
+  - 쌍
+  - 쌎
+  - 쌏
+  - 쌐
+  - 쌑
+  - 쌒
+  - 쌓
+  - 쌔
+  - 쌕
+  - 쌖
+  - 쌗
+  - 쌘
+  - 쌙
+  - 쌚
+  - 쌛
+  - 쌜
+  - 쌝
+  - 쌞
+  - 쌟
+  - 쌠
+  - 쌡
+  - 쌢
+  - 쌣
+  - 쌤
+  - 쌥
+  - 쌦
+  - 쌧
+  - 쌨
+  - 쌩
+  - 쌪
+  - 쌫
+  - 쌬
+  - 쌭
+  - 쌮
+  - 쌯
+  - 쌰
+  - 쌱
+  - 쌲
+  - 쌳
+  - 쌴
+  - 쌵
+  - 쌶
+  - 쌷
+  - 쌸
+  - 쌹
+  - 쌺
+  - 쌻
+  - 쌼
+  - 쌽
+  - 쌾
+  - 쌿
+  - 썀
+  - 썁
+  - 썂
+  - 썃
+  - 썄
+  - 썅
+  - 썆
+  - 썇
+  - 썈
+  - 썉
+  - 썊
+  - 썋
+  - 썌
+  - 썍
+  - 썎
+  - 썏
+  - 썐
+  - 썑
+  - 썒
+  - 썓
+  - 썔
+  - 썕
+  - 썖
+  - 썗
+  - 썘
+  - 썙
+  - 썚
+  - 썛
+  - 썜
+  - 썝
+  - 썞
+  - 썟
+  - 썠
+  - 썡
+  - 썢
+  - 썣
+  - 썤
+  - 썥
+  - 썦
+  - 썧
+  - 써
+  - 썩
+  - 썪
+  - 썫
+  - 썬
+  - 썭
+  - 썮
+  - 썯
+  - 썰
+  - 썱
+  - 썲
+  - 썳
+  - 썴
+  - 썵
+  - 썶
+  - 썷
+  - 썸
+  - 썹
+  - 썺
+  - 썻
+  - 썼
+  - 썽
+  - 썾
+  - 썿
+  - 쎀
+  - 쎁
+  - 쎂
+  - 쎃
+  - 쎄
+  - 쎅
+  - 쎆
+  - 쎇
+  - 쎈
+  - 쎉
+  - 쎊
+  - 쎋
+  - 쎌
+  - 쎍
+  - 쎎
+  - 쎏
+  - 쎐
+  - 쎑
+  - 쎒
+  - 쎓
+  - 쎔
+  - 쎕
+  - 쎖
+  - 쎗
+  - 쎘
+  - 쎙
+  - 쎚
+  - 쎛
+  - 쎜
+  - 쎝
+  - 쎞
+  - 쎟
+  - 쎠
+  - 쎡
+  - 쎢
+  - 쎣
+  - 쎤
+  - 쎥
+  - 쎦
+  - 쎧
+  - 쎨
+  - 쎩
+  - 쎪
+  - 쎫
+  - 쎬
+  - 쎭
+  - 쎮
+  - 쎯
+  - 쎰
+  - 쎱
+  - 쎲
+  - 쎳
+  - 쎴
+  - 쎵
+  - 쎶
+  - 쎷
+  - 쎸
+  - 쎹
+  - 쎺
+  - 쎻
+  - 쎼
+  - 쎽
+  - 쎾
+  - 쎿
+  - 쏀
+  - 쏁
+  - 쏂
+  - 쏃
+  - 쏄
+  - 쏅
+  - 쏆
+  - 쏇
+  - 쏈
+  - 쏉
+  - 쏊
+  - 쏋
+  - 쏌
+  - 쏍
+  - 쏎
+  - 쏏
+  - 쏐
+  - 쏑
+  - 쏒
+  - 쏓
+  - 쏔
+  - 쏕
+  - 쏖
+  - 쏗
+  - 쏘
+  - 쏙
+  - 쏚
+  - 쏛
+  - 쏜
+  - 쏝
+  - 쏞
+  - 쏟
+  - 쏠
+  - 쏡
+  - 쏢
+  - 쏣
+  - 쏤
+  - 쏥
+  - 쏦
+  - 쏧
+  - 쏨
+  - 쏩
+  - 쏪
+  - 쏫
+  - 쏬
+  - 쏭
+  - 쏮
+  - 쏯
+  - 쏰
+  - 쏱
+  - 쏲
+  - 쏳
+  - 쏴
+  - 쏵
+  - 쏶
+  - 쏷
+  - 쏸
+  - 쏹
+  - 쏺
+  - 쏻
+  - 쏼
+  - 쏽
+  - 쏾
+  - 쏿
+  - 쐀
+  - 쐁
+  - 쐂
+  - 쐃
+  - 쐄
+  - 쐅
+  - 쐆
+  - 쐇
+  - 쐈
+  - 쐉
+  - 쐊
+  - 쐋
+  - 쐌
+  - 쐍
+  - 쐎
+  - 쐏
+  - 쐐
+  - 쐑
+  - 쐒
+  - 쐓
+  - 쐔
+  - 쐕
+  - 쐖
+  - 쐗
+  - 쐘
+  - 쐙
+  - 쐚
+  - 쐛
+  - 쐜
+  - 쐝
+  - 쐞
+  - 쐟
+  - 쐠
+  - 쐡
+  - 쐢
+  - 쐣
+  - 쐤
+  - 쐥
+  - 쐦
+  - 쐧
+  - 쐨
+  - 쐩
+  - 쐪
+  - 쐫
+  - 쐬
+  - 쐭
+  - 쐮
+  - 쐯
+  - 쐰
+  - 쐱
+  - 쐲
+  - 쐳
+  - 쐴
+  - 쐵
+  - 쐶
+  - 쐷
+  - 쐸
+  - 쐹
+  - 쐺
+  - 쐻
+  - 쐼
+  - 쐽
+  - 쐾
+  - 쐿
+  - 쑀
+  - 쑁
+  - 쑂
+  - 쑃
+  - 쑄
+  - 쑅
+  - 쑆
+  - 쑇
+  - 쑈
+  - 쑉
+  - 쑊
+  - 쑋
+  - 쑌
+  - 쑍
+  - 쑎
+  - 쑏
+  - 쑐
+  - 쑑
+  - 쑒
+  - 쑓
+  - 쑔
+  - 쑕
+  - 쑖
+  - 쑗
+  - 쑘
+  - 쑙
+  - 쑚
+  - 쑛
+  - 쑜
+  - 쑝
+  - 쑞
+  - 쑟
+  - 쑠
+  - 쑡
+  - 쑢
+  - 쑣
+  - 쑤
+  - 쑥
+  - 쑦
+  - 쑧
+  - 쑨
+  - 쑩
+  - 쑪
+  - 쑫
+  - 쑬
+  - 쑭
+  - 쑮
+  - 쑯
+  - 쑰
+  - 쑱
+  - 쑲
+  - 쑳
+  - 쑴
+  - 쑵
+  - 쑶
+  - 쑷
+  - 쑸
+  - 쑹
+  - 쑺
+  - 쑻
+  - 쑼
+  - 쑽
+  - 쑾
+  - 쑿
+  - 쒀
+  - 쒁
+  - 쒂
+  - 쒃
+  - 쒄
+  - 쒅
+  - 쒆
+  - 쒇
+  - 쒈
+  - 쒉
+  - 쒊
+  - 쒋
+  - 쒌
+  - 쒍
+  - 쒎
+  - 쒏
+  - 쒐
+  - 쒑
+  - 쒒
+  - 쒓
+  - 쒔
+  - 쒕
+  - 쒖
+  - 쒗
+  - 쒘
+  - 쒙
+  - 쒚
+  - 쒛
+  - 쒜
+  - 쒝
+  - 쒞
+  - 쒟
+  - 쒠
+  - 쒡
+  - 쒢
+  - 쒣
+  - 쒤
+  - 쒥
+  - 쒦
+  - 쒧
+  - 쒨
+  - 쒩
+  - 쒪
+  - 쒫
+  - 쒬
+  - 쒭
+  - 쒮
+  - 쒯
+  - 쒰
+  - 쒱
+  - 쒲
+  - 쒳
+  - 쒴
+  - 쒵
+  - 쒶
+  - 쒷
+  - 쒸
+  - 쒹
+  - 쒺
+  - 쒻
+  - 쒼
+  - 쒽
+  - 쒾
+  - 쒿
+  - 쓀
+  - 쓁
+  - 쓂
+  - 쓃
+  - 쓄
+  - 쓅
+  - 쓆
+  - 쓇
+  - 쓈
+  - 쓉
+  - 쓊
+  - 쓋
+  - 쓌
+  - 쓍
+  - 쓎
+  - 쓏
+  - 쓐
+  - 쓑
+  - 쓒
+  - 쓓
+  - 쓔
+  - 쓕
+  - 쓖
+  - 쓗
+  - 쓘
+  - 쓙
+  - 쓚
+  - 쓛
+  - 쓜
+  - 쓝
+  - 쓞
+  - 쓟
+  - 쓠
+  - 쓡
+  - 쓢
+  - 쓣
+  - 쓤
+  - 쓥
+  - 쓦
+  - 쓧
+  - 쓨
+  - 쓩
+  - 쓪
+  - 쓫
+  - 쓬
+  - 쓭
+  - 쓮
+  - 쓯
+  - 쓰
+  - 쓱
+  - 쓲
+  - 쓳
+  - 쓴
+  - 쓵
+  - 쓶
+  - 쓷
+  - 쓸
+  - 쓹
+  - 쓺
+  - 쓻
+  - 쓼
+  - 쓽
+  - 쓾
+  - 쓿
+  - 씀
+  - 씁
+  - 씂
+  - 씃
+  - 씄
+  - 씅
+  - 씆
+  - 씇
+  - 씈
+  - 씉
+  - 씊
+  - 씋
+  - 씌
+  - 씍
+  - 씎
+  - 씏
+  - 씐
+  - 씑
+  - 씒
+  - 씓
+  - 씔
+  - 씕
+  - 씖
+  - 씗
+  - 씘
+  - 씙
+  - 씚
+  - 씛
+  - 씜
+  - 씝
+  - 씞
+  - 씟
+  - 씠
+  - 씡
+  - 씢
+  - 씣
+  - 씤
+  - 씥
+  - 씦
+  - 씧
+  - 씨
+  - 씩
+  - 씪
+  - 씫
+  - 씬
+  - 씭
+  - 씮
+  - 씯
+  - 씰
+  - 씱
+  - 씲
+  - 씳
+  - 씴
+  - 씵
+  - 씶
+  - 씷
+  - 씸
+  - 씹
+  - 씺
+  - 씻
+  - 씼
+  - 씽
+  - 씾
+  - 씿
+  - 앀
+  - 앁
+  - 앂
+  - 앃
+  - 아
+  - 악
+  - 앆
+  - 앇
+  - 안
+  - 앉
+  - 않
+  - 앋
+  - 알
+  - 앍
+  - 앎
+  - 앏
+  - 앐
+  - 앑
+  - 앒
+  - 앓
+  - 암
+  - 압
+  - 앖
+  - 앗
+  - 았
+  - 앙
+  - 앚
+  - 앛
+  - 앜
+  - 앝
+  - 앞
+  - 앟
+  - 애
+  - 액
+  - 앢
+  - 앣
+  - 앤
+  - 앥
+  - 앦
+  - 앧
+  - 앨
+  - 앩
+  - 앪
+  - 앫
+  - 앬
+  - 앭
+  - 앮
+  - 앯
+  - 앰
+  - 앱
+  - 앲
+  - 앳
+  - 앴
+  - 앵
+  - 앶
+  - 앷
+  - 앸
+  - 앹
+  - 앺
+  - 앻
+  - 야
+  - 약
+  - 앾
+  - 앿
+  - 얀
+  - 얁
+  - 얂
+  - 얃
+  - 얄
+  - 얅
+  - 얆
+  - 얇
+  - 얈
+  - 얉
+  - 얊
+  - 얋
+  - 얌
+  - 얍
+  - 얎
+  - 얏
+  - 얐
+  - 양
+  - 얒
+  - 얓
+  - 얔
+  - 얕
+  - 얖
+  - 얗
+  - 얘
+  - 얙
+  - 얚
+  - 얛
+  - 얜
+  - 얝
+  - 얞
+  - 얟
+  - 얠
+  - 얡
+  - 얢
+  - 얣
+  - 얤
+  - 얥
+  - 얦
+  - 얧
+  - 얨
+  - 얩
+  - 얪
+  - 얫
+  - 얬
+  - 얭
+  - 얮
+  - 얯
+  - 얰
+  - 얱
+  - 얲
+  - 얳
+  - 어
+  - 억
+  - 얶
+  - 얷
+  - 언
+  - 얹
+  - 얺
+  - 얻
+  - 얼
+  - 얽
+  - 얾
+  - 얿
+  - 엀
+  - 엁
+  - 엂
+  - 엃
+  - 엄
+  - 업
+  - 없
+  - 엇
+  - 었
+  - 엉
+  - 엊
+  - 엋
+  - 엌
+  - 엍
+  - 엎
+  - 엏
+  - 에
+  - 엑
+  - 엒
+  - 엓
+  - 엔
+  - 엕
+  - 엖
+  - 엗
+  - 엘
+  - 엙
+  - 엚
+  - 엛
+  - 엜
+  - 엝
+  - 엞
+  - 엟
+  - 엠
+  - 엡
+  - 엢
+  - 엣
+  - 엤
+  - 엥
+  - 엦
+  - 엧
+  - 엨
+  - 엩
+  - 엪
+  - 엫
+  - 여
+  - 역
+  - 엮
+  - 엯
+  - 연
+  - 엱
+  - 엲
+  - 엳
+  - 열
+  - 엵
+  - 엶
+  - 엷
+  - 엸
+  - 엹
+  - 엺
+  - 엻
+  - 염
+  - 엽
+  - 엾
+  - 엿
+  - 였
+  - 영
+  - 옂
+  - 옃
+  - 옄
+  - 옅
+  - 옆
+  - 옇
+  - 예
+  - 옉
+  - 옊
+  - 옋
+  - 옌
+  - 옍
+  - 옎
+  - 옏
+  - 옐
+  - 옑
+  - 옒
+  - 옓
+  - 옔
+  - 옕
+  - 옖
+  - 옗
+  - 옘
+  - 옙
+  - 옚
+  - 옛
+  - 옜
+  - 옝
+  - 옞
+  - 옟
+  - 옠
+  - 옡
+  - 옢
+  - 옣
+  - 오
+  - 옥
+  - 옦
+  - 옧
+  - 온
+  - 옩
+  - 옪
+  - 옫
+  - 올
+  - 옭
+  - 옮
+  - 옯
+  - 옰
+  - 옱
+  - 옲
+  - 옳
+  - 옴
+  - 옵
+  - 옶
+  - 옷
+  - 옸
+  - 옹
+  - 옺
+  - 옻
+  - 옼
+  - 옽
+  - 옾
+  - 옿
+  - 와
+  - 왁
+  - 왂
+  - 왃
+  - 완
+  - 왅
+  - 왆
+  - 왇
+  - 왈
+  - 왉
+  - 왊
+  - 왋
+  - 왌
+  - 왍
+  - 왎
+  - 왏
+  - 왐
+  - 왑
+  - 왒
+  - 왓
+  - 왔
+  - 왕
+  - 왖
+  - 왗
+  - 왘
+  - 왙
+  - 왚
+  - 왛
+  - 왜
+  - 왝
+  - 왞
+  - 왟
+  - 왠
+  - 왡
+  - 왢
+  - 왣
+  - 왤
+  - 왥
+  - 왦
+  - 왧
+  - 왨
+  - 왩
+  - 왪
+  - 왫
+  - 왬
+  - 왭
+  - 왮
+  - 왯
+  - 왰
+  - 왱
+  - 왲
+  - 왳
+  - 왴
+  - 왵
+  - 왶
+  - 왷
+  - 외
+  - 왹
+  - 왺
+  - 왻
+  - 왼
+  - 왽
+  - 왾
+  - 왿
+  - 욀
+  - 욁
+  - 욂
+  - 욃
+  - 욄
+  - 욅
+  - 욆
+  - 욇
+  - 욈
+  - 욉
+  - 욊
+  - 욋
+  - 욌
+  - 욍
+  - 욎
+  - 욏
+  - 욐
+  - 욑
+  - 욒
+  - 욓
+  - 요
+  - 욕
+  - 욖
+  - 욗
+  - 욘
+  - 욙
+  - 욚
+  - 욛
+  - 욜
+  - 욝
+  - 욞
+  - 욟
+  - 욠
+  - 욡
+  - 욢
+  - 욣
+  - 욤
+  - 욥
+  - 욦
+  - 욧
+  - 욨
+  - 용
+  - 욪
+  - 욫
+  - 욬
+  - 욭
+  - 욮
+  - 욯
+  - 우
+  - 욱
+  - 욲
+  - 욳
+  - 운
+  - 욵
+  - 욶
+  - 욷
+  - 울
+  - 욹
+  - 욺
+  - 욻
+  - 욼
+  - 욽
+  - 욾
+  - 욿
+  - 움
+  - 웁
+  - 웂
+  - 웃
+  - 웄
+  - 웅
+  - 웆
+  - 웇
+  - 웈
+  - 웉
+  - 웊
+  - 웋
+  - 워
+  - 웍
+  - 웎
+  - 웏
+  - 원
+  - 웑
+  - 웒
+  - 웓
+  - 월
+  - 웕
+  - 웖
+  - 웗
+  - 웘
+  - 웙
+  - 웚
+  - 웛
+  - 웜
+  - 웝
+  - 웞
+  - 웟
+  - 웠
+  - 웡
+  - 웢
+  - 웣
+  - 웤
+  - 웥
+  - 웦
+  - 웧
+  - 웨
+  - 웩
+  - 웪
+  - 웫
+  - 웬
+  - 웭
+  - 웮
+  - 웯
+  - 웰
+  - 웱
+  - 웲
+  - 웳
+  - 웴
+  - 웵
+  - 웶
+  - 웷
+  - 웸
+  - 웹
+  - 웺
+  - 웻
+  - 웼
+  - 웽
+  - 웾
+  - 웿
+  - 윀
+  - 윁
+  - 윂
+  - 윃
+  - 위
+  - 윅
+  - 윆
+  - 윇
+  - 윈
+  - 윉
+  - 윊
+  - 윋
+  - 윌
+  - 윍
+  - 윎
+  - 윏
+  - 윐
+  - 윑
+  - 윒
+  - 윓
+  - 윔
+  - 윕
+  - 윖
+  - 윗
+  - 윘
+  - 윙
+  - 윚
+  - 윛
+  - 윜
+  - 윝
+  - 윞
+  - 윟
+  - 유
+  - 육
+  - 윢
+  - 윣
+  - 윤
+  - 윥
+  - 윦
+  - 윧
+  - 율
+  - 윩
+  - 윪
+  - 윫
+  - 윬
+  - 윭
+  - 윮
+  - 윯
+  - 윰
+  - 윱
+  - 윲
+  - 윳
+  - 윴
+  - 융
+  - 윶
+  - 윷
+  - 윸
+  - 윹
+  - 윺
+  - 윻
+  - 으
+  - 윽
+  - 윾
+  - 윿
+  - 은
+  - 읁
+  - 읂
+  - 읃
+  - 을
+  - 읅
+  - 읆
+  - 읇
+  - 읈
+  - 읉
+  - 읊
+  - 읋
+  - 음
+  - 읍
+  - 읎
+  - 읏
+  - 읐
+  - 응
+  - 읒
+  - 읓
+  - 읔
+  - 읕
+  - 읖
+  - 읗
+  - 의
+  - 읙
+  - 읚
+  - 읛
+  - 읜
+  - 읝
+  - 읞
+  - 읟
+  - 읠
+  - 읡
+  - 읢
+  - 읣
+  - 읤
+  - 읥
+  - 읦
+  - 읧
+  - 읨
+  - 읩
+  - 읪
+  - 읫
+  - 읬
+  - 읭
+  - 읮
+  - 읯
+  - 읰
+  - 읱
+  - 읲
+  - 읳
+  - 이
+  - 익
+  - 읶
+  - 읷
+  - 인
+  - 읹
+  - 읺
+  - 읻
+  - 일
+  - 읽
+  - 읾
+  - 읿
+  - 잀
+  - 잁
+  - 잂
+  - 잃
+  - 임
+  - 입
+  - 잆
+  - 잇
+  - 있
+  - 잉
+  - 잊
+  - 잋
+  - 잌
+  - 잍
+  - 잎
+  - 잏
+  - 자
+  - 작
+  - 잒
+  - 잓
+  - 잔
+  - 잕
+  - 잖
+  - 잗
+  - 잘
+  - 잙
+  - 잚
+  - 잛
+  - 잜
+  - 잝
+  - 잞
+  - 잟
+  - 잠
+  - 잡
+  - 잢
+  - 잣
+  - 잤
+  - 장
+  - 잦
+  - 잧
+  - 잨
+  - 잩
+  - 잪
+  - 잫
+  - 재
+  - 잭
+  - 잮
+  - 잯
+  - 잰
+  - 잱
+  - 잲
+  - 잳
+  - 잴
+  - 잵
+  - 잶
+  - 잷
+  - 잸
+  - 잹
+  - 잺
+  - 잻
+  - 잼
+  - 잽
+  - 잾
+  - 잿
+  - 쟀
+  - 쟁
+  - 쟂
+  - 쟃
+  - 쟄
+  - 쟅
+  - 쟆
+  - 쟇
+  - 쟈
+  - 쟉
+  - 쟊
+  - 쟋
+  - 쟌
+  - 쟍
+  - 쟎
+  - 쟏
+  - 쟐
+  - 쟑
+  - 쟒
+  - 쟓
+  - 쟔
+  - 쟕
+  - 쟖
+  - 쟗
+  - 쟘
+  - 쟙
+  - 쟚
+  - 쟛
+  - 쟜
+  - 쟝
+  - 쟞
+  - 쟟
+  - 쟠
+  - 쟡
+  - 쟢
+  - 쟣
+  - 쟤
+  - 쟥
+  - 쟦
+  - 쟧
+  - 쟨
+  - 쟩
+  - 쟪
+  - 쟫
+  - 쟬
+  - 쟭
+  - 쟮
+  - 쟯
+  - 쟰
+  - 쟱
+  - 쟲
+  - 쟳
+  - 쟴
+  - 쟵
+  - 쟶
+  - 쟷
+  - 쟸
+  - 쟹
+  - 쟺
+  - 쟻
+  - 쟼
+  - 쟽
+  - 쟾
+  - 쟿
+  - 저
+  - 적
+  - 젂
+  - 젃
+  - 전
+  - 젅
+  - 젆
+  - 젇
+  - 절
+  - 젉
+  - 젊
+  - 젋
+  - 젌
+  - 젍
+  - 젎
+  - 젏
+  - 점
+  - 접
+  - 젒
+  - 젓
+  - 젔
+  - 정
+  - 젖
+  - 젗
+  - 젘
+  - 젙
+  - 젚
+  - 젛
+  - 제
+  - 젝
+  - 젞
+  - 젟
+  - 젠
+  - 젡
+  - 젢
+  - 젣
+  - 젤
+  - 젥
+  - 젦
+  - 젧
+  - 젨
+  - 젩
+  - 젪
+  - 젫
+  - 젬
+  - 젭
+  - 젮
+  - 젯
+  - 젰
+  - 젱
+  - 젲
+  - 젳
+  - 젴
+  - 젵
+  - 젶
+  - 젷
+  - 져
+  - 젹
+  - 젺
+  - 젻
+  - 젼
+  - 젽
+  - 젾
+  - 젿
+  - 졀
+  - 졁
+  - 졂
+  - 졃
+  - 졄
+  - 졅
+  - 졆
+  - 졇
+  - 졈
+  - 졉
+  - 졊
+  - 졋
+  - 졌
+  - 졍
+  - 졎
+  - 졏
+  - 졐
+  - 졑
+  - 졒
+  - 졓
+  - 졔
+  - 졕
+  - 졖
+  - 졗
+  - 졘
+  - 졙
+  - 졚
+  - 졛
+  - 졜
+  - 졝
+  - 졞
+  - 졟
+  - 졠
+  - 졡
+  - 졢
+  - 졣
+  - 졤
+  - 졥
+  - 졦
+  - 졧
+  - 졨
+  - 졩
+  - 졪
+  - 졫
+  - 졬
+  - 졭
+  - 졮
+  - 졯
+  - 조
+  - 족
+  - 졲
+  - 졳
+  - 존
+  - 졵
+  - 졶
+  - 졷
+  - 졸
+  - 졹
+  - 졺
+  - 졻
+  - 졼
+  - 졽
+  - 졾
+  - 졿
+  - 좀
+  - 좁
+  - 좂
+  - 좃
+  - 좄
+  - 종
+  - 좆
+  - 좇
+  - 좈
+  - 좉
+  - 좊
+  - 좋
+  - 좌
+  - 좍
+  - 좎
+  - 좏
+  - 좐
+  - 좑
+  - 좒
+  - 좓
+  - 좔
+  - 좕
+  - 좖
+  - 좗
+  - 좘
+  - 좙
+  - 좚
+  - 좛
+  - 좜
+  - 좝
+  - 좞
+  - 좟
+  - 좠
+  - 좡
+  - 좢
+  - 좣
+  - 좤
+  - 좥
+  - 좦
+  - 좧
+  - 좨
+  - 좩
+  - 좪
+  - 좫
+  - 좬
+  - 좭
+  - 좮
+  - 좯
+  - 좰
+  - 좱
+  - 좲
+  - 좳
+  - 좴
+  - 좵
+  - 좶
+  - 좷
+  - 좸
+  - 좹
+  - 좺
+  - 좻
+  - 좼
+  - 좽
+  - 좾
+  - 좿
+  - 죀
+  - 죁
+  - 죂
+  - 죃
+  - 죄
+  - 죅
+  - 죆
+  - 죇
+  - 죈
+  - 죉
+  - 죊
+  - 죋
+  - 죌
+  - 죍
+  - 죎
+  - 죏
+  - 죐
+  - 죑
+  - 죒
+  - 죓
+  - 죔
+  - 죕
+  - 죖
+  - 죗
+  - 죘
+  - 죙
+  - 죚
+  - 죛
+  - 죜
+  - 죝
+  - 죞
+  - 죟
+  - 죠
+  - 죡
+  - 죢
+  - 죣
+  - 죤
+  - 죥
+  - 죦
+  - 죧
+  - 죨
+  - 죩
+  - 죪
+  - 죫
+  - 죬
+  - 죭
+  - 죮
+  - 죯
+  - 죰
+  - 죱
+  - 죲
+  - 죳
+  - 죴
+  - 죵
+  - 죶
+  - 죷
+  - 죸
+  - 죹
+  - 죺
+  - 죻
+  - 주
+  - 죽
+  - 죾
+  - 죿
+  - 준
+  - 줁
+  - 줂
+  - 줃
+  - 줄
+  - 줅
+  - 줆
+  - 줇
+  - 줈
+  - 줉
+  - 줊
+  - 줋
+  - 줌
+  - 줍
+  - 줎
+  - 줏
+  - 줐
+  - 중
+  - 줒
+  - 줓
+  - 줔
+  - 줕
+  - 줖
+  - 줗
+  - 줘
+  - 줙
+  - 줚
+  - 줛
+  - 줜
+  - 줝
+  - 줞
+  - 줟
+  - 줠
+  - 줡
+  - 줢
+  - 줣
+  - 줤
+  - 줥
+  - 줦
+  - 줧
+  - 줨
+  - 줩
+  - 줪
+  - 줫
+  - 줬
+  - 줭
+  - 줮
+  - 줯
+  - 줰
+  - 줱
+  - 줲
+  - 줳
+  - 줴
+  - 줵
+  - 줶
+  - 줷
+  - 줸
+  - 줹
+  - 줺
+  - 줻
+  - 줼
+  - 줽
+  - 줾
+  - 줿
+  - 쥀
+  - 쥁
+  - 쥂
+  - 쥃
+  - 쥄
+  - 쥅
+  - 쥆
+  - 쥇
+  - 쥈
+  - 쥉
+  - 쥊
+  - 쥋
+  - 쥌
+  - 쥍
+  - 쥎
+  - 쥏
+  - 쥐
+  - 쥑
+  - 쥒
+  - 쥓
+  - 쥔
+  - 쥕
+  - 쥖
+  - 쥗
+  - 쥘
+  - 쥙
+  - 쥚
+  - 쥛
+  - 쥜
+  - 쥝
+  - 쥞
+  - 쥟
+  - 쥠
+  - 쥡
+  - 쥢
+  - 쥣
+  - 쥤
+  - 쥥
+  - 쥦
+  - 쥧
+  - 쥨
+  - 쥩
+  - 쥪
+  - 쥫
+  - 쥬
+  - 쥭
+  - 쥮
+  - 쥯
+  - 쥰
+  - 쥱
+  - 쥲
+  - 쥳
+  - 쥴
+  - 쥵
+  - 쥶
+  - 쥷
+  - 쥸
+  - 쥹
+  - 쥺
+  - 쥻
+  - 쥼
+  - 쥽
+  - 쥾
+  - 쥿
+  - 즀
+  - 즁
+  - 즂
+  - 즃
+  - 즄
+  - 즅
+  - 즆
+  - 즇
+  - 즈
+  - 즉
+  - 즊
+  - 즋
+  - 즌
+  - 즍
+  - 즎
+  - 즏
+  - 즐
+  - 즑
+  - 즒
+  - 즓
+  - 즔
+  - 즕
+  - 즖
+  - 즗
+  - 즘
+  - 즙
+  - 즚
+  - 즛
+  - 즜
+  - 증
+  - 즞
+  - 즟
+  - 즠
+  - 즡
+  - 즢
+  - 즣
+  - 즤
+  - 즥
+  - 즦
+  - 즧
+  - 즨
+  - 즩
+  - 즪
+  - 즫
+  - 즬
+  - 즭
+  - 즮
+  - 즯
+  - 즰
+  - 즱
+  - 즲
+  - 즳
+  - 즴
+  - 즵
+  - 즶
+  - 즷
+  - 즸
+  - 즹
+  - 즺
+  - 즻
+  - 즼
+  - 즽
+  - 즾
+  - 즿
+  - 지
+  - 직
+  - 짂
+  - 짃
+  - 진
+  - 짅
+  - 짆
+  - 짇
+  - 질
+  - 짉
+  - 짊
+  - 짋
+  - 짌
+  - 짍
+  - 짎
+  - 짏
+  - 짐
+  - 집
+  - 짒
+  - 짓
+  - 짔
+  - 징
+  - 짖
+  - 짗
+  - 짘
+  - 짙
+  - 짚
+  - 짛
+  - 짜
+  - 짝
+  - 짞
+  - 짟
+  - 짠
+  - 짡
+  - 짢
+  - 짣
+  - 짤
+  - 짥
+  - 짦
+  - 짧
+  - 짨
+  - 짩
+  - 짪
+  - 짫
+  - 짬
+  - 짭
+  - 짮
+  - 짯
+  - 짰
+  - 짱
+  - 짲
+  - 짳
+  - 짴
+  - 짵
+  - 짶
+  - 짷
+  - 째
+  - 짹
+  - 짺
+  - 짻
+  - 짼
+  - 짽
+  - 짾
+  - 짿
+  - 쨀
+  - 쨁
+  - 쨂
+  - 쨃
+  - 쨄
+  - 쨅
+  - 쨆
+  - 쨇
+  - 쨈
+  - 쨉
+  - 쨊
+  - 쨋
+  - 쨌
+  - 쨍
+  - 쨎
+  - 쨏
+  - 쨐
+  - 쨑
+  - 쨒
+  - 쨓
+  - 쨔
+  - 쨕
+  - 쨖
+  - 쨗
+  - 쨘
+  - 쨙
+  - 쨚
+  - 쨛
+  - 쨜
+  - 쨝
+  - 쨞
+  - 쨟
+  - 쨠
+  - 쨡
+  - 쨢
+  - 쨣
+  - 쨤
+  - 쨥
+  - 쨦
+  - 쨧
+  - 쨨
+  - 쨩
+  - 쨪
+  - 쨫
+  - 쨬
+  - 쨭
+  - 쨮
+  - 쨯
+  - 쨰
+  - 쨱
+  - 쨲
+  - 쨳
+  - 쨴
+  - 쨵
+  - 쨶
+  - 쨷
+  - 쨸
+  - 쨹
+  - 쨺
+  - 쨻
+  - 쨼
+  - 쨽
+  - 쨾
+  - 쨿
+  - 쩀
+  - 쩁
+  - 쩂
+  - 쩃
+  - 쩄
+  - 쩅
+  - 쩆
+  - 쩇
+  - 쩈
+  - 쩉
+  - 쩊
+  - 쩋
+  - 쩌
+  - 쩍
+  - 쩎
+  - 쩏
+  - 쩐
+  - 쩑
+  - 쩒
+  - 쩓
+  - 쩔
+  - 쩕
+  - 쩖
+  - 쩗
+  - 쩘
+  - 쩙
+  - 쩚
+  - 쩛
+  - 쩜
+  - 쩝
+  - 쩞
+  - 쩟
+  - 쩠
+  - 쩡
+  - 쩢
+  - 쩣
+  - 쩤
+  - 쩥
+  - 쩦
+  - 쩧
+  - 쩨
+  - 쩩
+  - 쩪
+  - 쩫
+  - 쩬
+  - 쩭
+  - 쩮
+  - 쩯
+  - 쩰
+  - 쩱
+  - 쩲
+  - 쩳
+  - 쩴
+  - 쩵
+  - 쩶
+  - 쩷
+  - 쩸
+  - 쩹
+  - 쩺
+  - 쩻
+  - 쩼
+  - 쩽
+  - 쩾
+  - 쩿
+  - 쪀
+  - 쪁
+  - 쪂
+  - 쪃
+  - 쪄
+  - 쪅
+  - 쪆
+  - 쪇
+  - 쪈
+  - 쪉
+  - 쪊
+  - 쪋
+  - 쪌
+  - 쪍
+  - 쪎
+  - 쪏
+  - 쪐
+  - 쪑
+  - 쪒
+  - 쪓
+  - 쪔
+  - 쪕
+  - 쪖
+  - 쪗
+  - 쪘
+  - 쪙
+  - 쪚
+  - 쪛
+  - 쪜
+  - 쪝
+  - 쪞
+  - 쪟
+  - 쪠
+  - 쪡
+  - 쪢
+  - 쪣
+  - 쪤
+  - 쪥
+  - 쪦
+  - 쪧
+  - 쪨
+  - 쪩
+  - 쪪
+  - 쪫
+  - 쪬
+  - 쪭
+  - 쪮
+  - 쪯
+  - 쪰
+  - 쪱
+  - 쪲
+  - 쪳
+  - 쪴
+  - 쪵
+  - 쪶
+  - 쪷
+  - 쪸
+  - 쪹
+  - 쪺
+  - 쪻
+  - 쪼
+  - 쪽
+  - 쪾
+  - 쪿
+  - 쫀
+  - 쫁
+  - 쫂
+  - 쫃
+  - 쫄
+  - 쫅
+  - 쫆
+  - 쫇
+  - 쫈
+  - 쫉
+  - 쫊
+  - 쫋
+  - 쫌
+  - 쫍
+  - 쫎
+  - 쫏
+  - 쫐
+  - 쫑
+  - 쫒
+  - 쫓
+  - 쫔
+  - 쫕
+  - 쫖
+  - 쫗
+  - 쫘
+  - 쫙
+  - 쫚
+  - 쫛
+  - 쫜
+  - 쫝
+  - 쫞
+  - 쫟
+  - 쫠
+  - 쫡
+  - 쫢
+  - 쫣
+  - 쫤
+  - 쫥
+  - 쫦
+  - 쫧
+  - 쫨
+  - 쫩
+  - 쫪
+  - 쫫
+  - 쫬
+  - 쫭
+  - 쫮
+  - 쫯
+  - 쫰
+  - 쫱
+  - 쫲
+  - 쫳
+  - 쫴
+  - 쫵
+  - 쫶
+  - 쫷
+  - 쫸
+  - 쫹
+  - 쫺
+  - 쫻
+  - 쫼
+  - 쫽
+  - 쫾
+  - 쫿
+  - 쬀
+  - 쬁
+  - 쬂
+  - 쬃
+  - 쬄
+  - 쬅
+  - 쬆
+  - 쬇
+  - 쬈
+  - 쬉
+  - 쬊
+  - 쬋
+  - 쬌
+  - 쬍
+  - 쬎
+  - 쬏
+  - 쬐
+  - 쬑
+  - 쬒
+  - 쬓
+  - 쬔
+  - 쬕
+  - 쬖
+  - 쬗
+  - 쬘
+  - 쬙
+  - 쬚
+  - 쬛
+  - 쬜
+  - 쬝
+  - 쬞
+  - 쬟
+  - 쬠
+  - 쬡
+  - 쬢
+  - 쬣
+  - 쬤
+  - 쬥
+  - 쬦
+  - 쬧
+  - 쬨
+  - 쬩
+  - 쬪
+  - 쬫
+  - 쬬
+  - 쬭
+  - 쬮
+  - 쬯
+  - 쬰
+  - 쬱
+  - 쬲
+  - 쬳
+  - 쬴
+  - 쬵
+  - 쬶
+  - 쬷
+  - 쬸
+  - 쬹
+  - 쬺
+  - 쬻
+  - 쬼
+  - 쬽
+  - 쬾
+  - 쬿
+  - 쭀
+  - 쭁
+  - 쭂
+  - 쭃
+  - 쭄
+  - 쭅
+  - 쭆
+  - 쭇
+  - 쭈
+  - 쭉
+  - 쭊
+  - 쭋
+  - 쭌
+  - 쭍
+  - 쭎
+  - 쭏
+  - 쭐
+  - 쭑
+  - 쭒
+  - 쭓
+  - 쭔
+  - 쭕
+  - 쭖
+  - 쭗
+  - 쭘
+  - 쭙
+  - 쭚
+  - 쭛
+  - 쭜
+  - 쭝
+  - 쭞
+  - 쭟
+  - 쭠
+  - 쭡
+  - 쭢
+  - 쭣
+  - 쭤
+  - 쭥
+  - 쭦
+  - 쭧
+  - 쭨
+  - 쭩
+  - 쭪
+  - 쭫
+  - 쭬
+  - 쭭
+  - 쭮
+  - 쭯
+  - 쭰
+  - 쭱
+  - 쭲
+  - 쭳
+  - 쭴
+  - 쭵
+  - 쭶
+  - 쭷
+  - 쭸
+  - 쭹
+  - 쭺
+  - 쭻
+  - 쭼
+  - 쭽
+  - 쭾
+  - 쭿
+  - 쮀
+  - 쮁
+  - 쮂
+  - 쮃
+  - 쮄
+  - 쮅
+  - 쮆
+  - 쮇
+  - 쮈
+  - 쮉
+  - 쮊
+  - 쮋
+  - 쮌
+  - 쮍
+  - 쮎
+  - 쮏
+  - 쮐
+  - 쮑
+  - 쮒
+  - 쮓
+  - 쮔
+  - 쮕
+  - 쮖
+  - 쮗
+  - 쮘
+  - 쮙
+  - 쮚
+  - 쮛
+  - 쮜
+  - 쮝
+  - 쮞
+  - 쮟
+  - 쮠
+  - 쮡
+  - 쮢
+  - 쮣
+  - 쮤
+  - 쮥
+  - 쮦
+  - 쮧
+  - 쮨
+  - 쮩
+  - 쮪
+  - 쮫
+  - 쮬
+  - 쮭
+  - 쮮
+  - 쮯
+  - 쮰
+  - 쮱
+  - 쮲
+  - 쮳
+  - 쮴
+  - 쮵
+  - 쮶
+  - 쮷
+  - 쮸
+  - 쮹
+  - 쮺
+  - 쮻
+  - 쮼
+  - 쮽
+  - 쮾
+  - 쮿
+  - 쯀
+  - 쯁
+  - 쯂
+  - 쯃
+  - 쯄
+  - 쯅
+  - 쯆
+  - 쯇
+  - 쯈
+  - 쯉
+  - 쯊
+  - 쯋
+  - 쯌
+  - 쯍
+  - 쯎
+  - 쯏
+  - 쯐
+  - 쯑
+  - 쯒
+  - 쯓
+  - 쯔
+  - 쯕
+  - 쯖
+  - 쯗
+  - 쯘
+  - 쯙
+  - 쯚
+  - 쯛
+  - 쯜
+  - 쯝
+  - 쯞
+  - 쯟
+  - 쯠
+  - 쯡
+  - 쯢
+  - 쯣
+  - 쯤
+  - 쯥
+  - 쯦
+  - 쯧
+  - 쯨
+  - 쯩
+  - 쯪
+  - 쯫
+  - 쯬
+  - 쯭
+  - 쯮
+  - 쯯
+  - 쯰
+  - 쯱
+  - 쯲
+  - 쯳
+  - 쯴
+  - 쯵
+  - 쯶
+  - 쯷
+  - 쯸
+  - 쯹
+  - 쯺
+  - 쯻
+  - 쯼
+  - 쯽
+  - 쯾
+  - 쯿
+  - 찀
+  - 찁
+  - 찂
+  - 찃
+  - 찄
+  - 찅
+  - 찆
+  - 찇
+  - 찈
+  - 찉
+  - 찊
+  - 찋
+  - 찌
+  - 찍
+  - 찎
+  - 찏
+  - 찐
+  - 찑
+  - 찒
+  - 찓
+  - 찔
+  - 찕
+  - 찖
+  - 찗
+  - 찘
+  - 찙
+  - 찚
+  - 찛
+  - 찜
+  - 찝
+  - 찞
+  - 찟
+  - 찠
+  - 찡
+  - 찢
+  - 찣
+  - 찤
+  - 찥
+  - 찦
+  - 찧
+  - 차
+  - 착
+  - 찪
+  - 찫
+  - 찬
+  - 찭
+  - 찮
+  - 찯
+  - 찰
+  - 찱
+  - 찲
+  - 찳
+  - 찴
+  - 찵
+  - 찶
+  - 찷
+  - 참
+  - 찹
+  - 찺
+  - 찻
+  - 찼
+  - 창
+  - 찾
+  - 찿
+  - 챀
+  - 챁
+  - 챂
+  - 챃
+  - 채
+  - 책
+  - 챆
+  - 챇
+  - 챈
+  - 챉
+  - 챊
+  - 챋
+  - 챌
+  - 챍
+  - 챎
+  - 챏
+  - 챐
+  - 챑
+  - 챒
+  - 챓
+  - 챔
+  - 챕
+  - 챖
+  - 챗
+  - 챘
+  - 챙
+  - 챚
+  - 챛
+  - 챜
+  - 챝
+  - 챞
+  - 챟
+  - 챠
+  - 챡
+  - 챢
+  - 챣
+  - 챤
+  - 챥
+  - 챦
+  - 챧
+  - 챨
+  - 챩
+  - 챪
+  - 챫
+  - 챬
+  - 챭
+  - 챮
+  - 챯
+  - 챰
+  - 챱
+  - 챲
+  - 챳
+  - 챴
+  - 챵
+  - 챶
+  - 챷
+  - 챸
+  - 챹
+  - 챺
+  - 챻
+  - 챼
+  - 챽
+  - 챾
+  - 챿
+  - 첀
+  - 첁
+  - 첂
+  - 첃
+  - 첄
+  - 첅
+  - 첆
+  - 첇
+  - 첈
+  - 첉
+  - 첊
+  - 첋
+  - 첌
+  - 첍
+  - 첎
+  - 첏
+  - 첐
+  - 첑
+  - 첒
+  - 첓
+  - 첔
+  - 첕
+  - 첖
+  - 첗
+  - 처
+  - 척
+  - 첚
+  - 첛
+  - 천
+  - 첝
+  - 첞
+  - 첟
+  - 철
+  - 첡
+  - 첢
+  - 첣
+  - 첤
+  - 첥
+  - 첦
+  - 첧
+  - 첨
+  - 첩
+  - 첪
+  - 첫
+  - 첬
+  - 청
+  - 첮
+  - 첯
+  - 첰
+  - 첱
+  - 첲
+  - 첳
+  - 체
+  - 첵
+  - 첶
+  - 첷
+  - 첸
+  - 첹
+  - 첺
+  - 첻
+  - 첼
+  - 첽
+  - 첾
+  - 첿
+  - 쳀
+  - 쳁
+  - 쳂
+  - 쳃
+  - 쳄
+  - 쳅
+  - 쳆
+  - 쳇
+  - 쳈
+  - 쳉
+  - 쳊
+  - 쳋
+  - 쳌
+  - 쳍
+  - 쳎
+  - 쳏
+  - 쳐
+  - 쳑
+  - 쳒
+  - 쳓
+  - 쳔
+  - 쳕
+  - 쳖
+  - 쳗
+  - 쳘
+  - 쳙
+  - 쳚
+  - 쳛
+  - 쳜
+  - 쳝
+  - 쳞
+  - 쳟
+  - 쳠
+  - 쳡
+  - 쳢
+  - 쳣
+  - 쳤
+  - 쳥
+  - 쳦
+  - 쳧
+  - 쳨
+  - 쳩
+  - 쳪
+  - 쳫
+  - 쳬
+  - 쳭
+  - 쳮
+  - 쳯
+  - 쳰
+  - 쳱
+  - 쳲
+  - 쳳
+  - 쳴
+  - 쳵
+  - 쳶
+  - 쳷
+  - 쳸
+  - 쳹
+  - 쳺
+  - 쳻
+  - 쳼
+  - 쳽
+  - 쳾
+  - 쳿
+  - 촀
+  - 촁
+  - 촂
+  - 촃
+  - 촄
+  - 촅
+  - 촆
+  - 촇
+  - 초
+  - 촉
+  - 촊
+  - 촋
+  - 촌
+  - 촍
+  - 촎
+  - 촏
+  - 촐
+  - 촑
+  - 촒
+  - 촓
+  - 촔
+  - 촕
+  - 촖
+  - 촗
+  - 촘
+  - 촙
+  - 촚
+  - 촛
+  - 촜
+  - 총
+  - 촞
+  - 촟
+  - 촠
+  - 촡
+  - 촢
+  - 촣
+  - 촤
+  - 촥
+  - 촦
+  - 촧
+  - 촨
+  - 촩
+  - 촪
+  - 촫
+  - 촬
+  - 촭
+  - 촮
+  - 촯
+  - 촰
+  - 촱
+  - 촲
+  - 촳
+  - 촴
+  - 촵
+  - 촶
+  - 촷
+  - 촸
+  - 촹
+  - 촺
+  - 촻
+  - 촼
+  - 촽
+  - 촾
+  - 촿
+  - 쵀
+  - 쵁
+  - 쵂
+  - 쵃
+  - 쵄
+  - 쵅
+  - 쵆
+  - 쵇
+  - 쵈
+  - 쵉
+  - 쵊
+  - 쵋
+  - 쵌
+  - 쵍
+  - 쵎
+  - 쵏
+  - 쵐
+  - 쵑
+  - 쵒
+  - 쵓
+  - 쵔
+  - 쵕
+  - 쵖
+  - 쵗
+  - 쵘
+  - 쵙
+  - 쵚
+  - 쵛
+  - 최
+  - 쵝
+  - 쵞
+  - 쵟
+  - 쵠
+  - 쵡
+  - 쵢
+  - 쵣
+  - 쵤
+  - 쵥
+  - 쵦
+  - 쵧
+  - 쵨
+  - 쵩
+  - 쵪
+  - 쵫
+  - 쵬
+  - 쵭
+  - 쵮
+  - 쵯
+  - 쵰
+  - 쵱
+  - 쵲
+  - 쵳
+  - 쵴
+  - 쵵
+  - 쵶
+  - 쵷
+  - 쵸
+  - 쵹
+  - 쵺
+  - 쵻
+  - 쵼
+  - 쵽
+  - 쵾
+  - 쵿
+  - 춀
+  - 춁
+  - 춂
+  - 춃
+  - 춄
+  - 춅
+  - 춆
+  - 춇
+  - 춈
+  - 춉
+  - 춊
+  - 춋
+  - 춌
+  - 춍
+  - 춎
+  - 춏
+  - 춐
+  - 춑
+  - 춒
+  - 춓
+  - 추
+  - 축
+  - 춖
+  - 춗
+  - 춘
+  - 춙
+  - 춚
+  - 춛
+  - 출
+  - 춝
+  - 춞
+  - 춟
+  - 춠
+  - 춡
+  - 춢
+  - 춣
+  - 춤
+  - 춥
+  - 춦
+  - 춧
+  - 춨
+  - 충
+  - 춪
+  - 춫
+  - 춬
+  - 춭
+  - 춮
+  - 춯
+  - 춰
+  - 춱
+  - 춲
+  - 춳
+  - 춴
+  - 춵
+  - 춶
+  - 춷
+  - 춸
+  - 춹
+  - 춺
+  - 춻
+  - 춼
+  - 춽
+  - 춾
+  - 춿
+  - 췀
+  - 췁
+  - 췂
+  - 췃
+  - 췄
+  - 췅
+  - 췆
+  - 췇
+  - 췈
+  - 췉
+  - 췊
+  - 췋
+  - 췌
+  - 췍
+  - 췎
+  - 췏
+  - 췐
+  - 췑
+  - 췒
+  - 췓
+  - 췔
+  - 췕
+  - 췖
+  - 췗
+  - 췘
+  - 췙
+  - 췚
+  - 췛
+  - 췜
+  - 췝
+  - 췞
+  - 췟
+  - 췠
+  - 췡
+  - 췢
+  - 췣
+  - 췤
+  - 췥
+  - 췦
+  - 췧
+  - 취
+  - 췩
+  - 췪
+  - 췫
+  - 췬
+  - 췭
+  - 췮
+  - 췯
+  - 췰
+  - 췱
+  - 췲
+  - 췳
+  - 췴
+  - 췵
+  - 췶
+  - 췷
+  - 췸
+  - 췹
+  - 췺
+  - 췻
+  - 췼
+  - 췽
+  - 췾
+  - 췿
+  - 츀
+  - 츁
+  - 츂
+  - 츃
+  - 츄
+  - 츅
+  - 츆
+  - 츇
+  - 츈
+  - 츉
+  - 츊
+  - 츋
+  - 츌
+  - 츍
+  - 츎
+  - 츏
+  - 츐
+  - 츑
+  - 츒
+  - 츓
+  - 츔
+  - 츕
+  - 츖
+  - 츗
+  - 츘
+  - 츙
+  - 츚
+  - 츛
+  - 츜
+  - 츝
+  - 츞
+  - 츟
+  - 츠
+  - 측
+  - 츢
+  - 츣
+  - 츤
+  - 츥
+  - 츦
+  - 츧
+  - 츨
+  - 츩
+  - 츪
+  - 츫
+  - 츬
+  - 츭
+  - 츮
+  - 츯
+  - 츰
+  - 츱
+  - 츲
+  - 츳
+  - 츴
+  - 층
+  - 츶
+  - 츷
+  - 츸
+  - 츹
+  - 츺
+  - 츻
+  - 츼
+  - 츽
+  - 츾
+  - 츿
+  - 칀
+  - 칁
+  - 칂
+  - 칃
+  - 칄
+  - 칅
+  - 칆
+  - 칇
+  - 칈
+  - 칉
+  - 칊
+  - 칋
+  - 칌
+  - 칍
+  - 칎
+  - 칏
+  - 칐
+  - 칑
+  - 칒
+  - 칓
+  - 칔
+  - 칕
+  - 칖
+  - 칗
+  - 치
+  - 칙
+  - 칚
+  - 칛
+  - 친
+  - 칝
+  - 칞
+  - 칟
+  - 칠
+  - 칡
+  - 칢
+  - 칣
+  - 칤
+  - 칥
+  - 칦
+  - 칧
+  - 침
+  - 칩
+  - 칪
+  - 칫
+  - 칬
+  - 칭
+  - 칮
+  - 칯
+  - 칰
+  - 칱
+  - 칲
+  - 칳
+  - 카
+  - 칵
+  - 칶
+  - 칷
+  - 칸
+  - 칹
+  - 칺
+  - 칻
+  - 칼
+  - 칽
+  - 칾
+  - 칿
+  - 캀
+  - 캁
+  - 캂
+  - 캃
+  - 캄
+  - 캅
+  - 캆
+  - 캇
+  - 캈
+  - 캉
+  - 캊
+  - 캋
+  - 캌
+  - 캍
+  - 캎
+  - 캏
+  - 캐
+  - 캑
+  - 캒
+  - 캓
+  - 캔
+  - 캕
+  - 캖
+  - 캗
+  - 캘
+  - 캙
+  - 캚
+  - 캛
+  - 캜
+  - 캝
+  - 캞
+  - 캟
+  - 캠
+  - 캡
+  - 캢
+  - 캣
+  - 캤
+  - 캥
+  - 캦
+  - 캧
+  - 캨
+  - 캩
+  - 캪
+  - 캫
+  - 캬
+  - 캭
+  - 캮
+  - 캯
+  - 캰
+  - 캱
+  - 캲
+  - 캳
+  - 캴
+  - 캵
+  - 캶
+  - 캷
+  - 캸
+  - 캹
+  - 캺
+  - 캻
+  - 캼
+  - 캽
+  - 캾
+  - 캿
+  - 컀
+  - 컁
+  - 컂
+  - 컃
+  - 컄
+  - 컅
+  - 컆
+  - 컇
+  - 컈
+  - 컉
+  - 컊
+  - 컋
+  - 컌
+  - 컍
+  - 컎
+  - 컏
+  - 컐
+  - 컑
+  - 컒
+  - 컓
+  - 컔
+  - 컕
+  - 컖
+  - 컗
+  - 컘
+  - 컙
+  - 컚
+  - 컛
+  - 컜
+  - 컝
+  - 컞
+  - 컟
+  - 컠
+  - 컡
+  - 컢
+  - 컣
+  - 커
+  - 컥
+  - 컦
+  - 컧
+  - 컨
+  - 컩
+  - 컪
+  - 컫
+  - 컬
+  - 컭
+  - 컮
+  - 컯
+  - 컰
+  - 컱
+  - 컲
+  - 컳
+  - 컴
+  - 컵
+  - 컶
+  - 컷
+  - 컸
+  - 컹
+  - 컺
+  - 컻
+  - 컼
+  - 컽
+  - 컾
+  - 컿
+  - 케
+  - 켁
+  - 켂
+  - 켃
+  - 켄
+  - 켅
+  - 켆
+  - 켇
+  - 켈
+  - 켉
+  - 켊
+  - 켋
+  - 켌
+  - 켍
+  - 켎
+  - 켏
+  - 켐
+  - 켑
+  - 켒
+  - 켓
+  - 켔
+  - 켕
+  - 켖
+  - 켗
+  - 켘
+  - 켙
+  - 켚
+  - 켛
+  - 켜
+  - 켝
+  - 켞
+  - 켟
+  - 켠
+  - 켡
+  - 켢
+  - 켣
+  - 켤
+  - 켥
+  - 켦
+  - 켧
+  - 켨
+  - 켩
+  - 켪
+  - 켫
+  - 켬
+  - 켭
+  - 켮
+  - 켯
+  - 켰
+  - 켱
+  - 켲
+  - 켳
+  - 켴
+  - 켵
+  - 켶
+  - 켷
+  - 켸
+  - 켹
+  - 켺
+  - 켻
+  - 켼
+  - 켽
+  - 켾
+  - 켿
+  - 콀
+  - 콁
+  - 콂
+  - 콃
+  - 콄
+  - 콅
+  - 콆
+  - 콇
+  - 콈
+  - 콉
+  - 콊
+  - 콋
+  - 콌
+  - 콍
+  - 콎
+  - 콏
+  - 콐
+  - 콑
+  - 콒
+  - 콓
+  - 코
+  - 콕
+  - 콖
+  - 콗
+  - 콘
+  - 콙
+  - 콚
+  - 콛
+  - 콜
+  - 콝
+  - 콞
+  - 콟
+  - 콠
+  - 콡
+  - 콢
+  - 콣
+  - 콤
+  - 콥
+  - 콦
+  - 콧
+  - 콨
+  - 콩
+  - 콪
+  - 콫
+  - 콬
+  - 콭
+  - 콮
+  - 콯
+  - 콰
+  - 콱
+  - 콲
+  - 콳
+  - 콴
+  - 콵
+  - 콶
+  - 콷
+  - 콸
+  - 콹
+  - 콺
+  - 콻
+  - 콼
+  - 콽
+  - 콾
+  - 콿
+  - 쾀
+  - 쾁
+  - 쾂
+  - 쾃
+  - 쾄
+  - 쾅
+  - 쾆
+  - 쾇
+  - 쾈
+  - 쾉
+  - 쾊
+  - 쾋
+  - 쾌
+  - 쾍
+  - 쾎
+  - 쾏
+  - 쾐
+  - 쾑
+  - 쾒
+  - 쾓
+  - 쾔
+  - 쾕
+  - 쾖
+  - 쾗
+  - 쾘
+  - 쾙
+  - 쾚
+  - 쾛
+  - 쾜
+  - 쾝
+  - 쾞
+  - 쾟
+  - 쾠
+  - 쾡
+  - 쾢
+  - 쾣
+  - 쾤
+  - 쾥
+  - 쾦
+  - 쾧
+  - 쾨
+  - 쾩
+  - 쾪
+  - 쾫
+  - 쾬
+  - 쾭
+  - 쾮
+  - 쾯
+  - 쾰
+  - 쾱
+  - 쾲
+  - 쾳
+  - 쾴
+  - 쾵
+  - 쾶
+  - 쾷
+  - 쾸
+  - 쾹
+  - 쾺
+  - 쾻
+  - 쾼
+  - 쾽
+  - 쾾
+  - 쾿
+  - 쿀
+  - 쿁
+  - 쿂
+  - 쿃
+  - 쿄
+  - 쿅
+  - 쿆
+  - 쿇
+  - 쿈
+  - 쿉
+  - 쿊
+  - 쿋
+  - 쿌
+  - 쿍
+  - 쿎
+  - 쿏
+  - 쿐
+  - 쿑
+  - 쿒
+  - 쿓
+  - 쿔
+  - 쿕
+  - 쿖
+  - 쿗
+  - 쿘
+  - 쿙
+  - 쿚
+  - 쿛
+  - 쿜
+  - 쿝
+  - 쿞
+  - 쿟
+  - 쿠
+  - 쿡
+  - 쿢
+  - 쿣
+  - 쿤
+  - 쿥
+  - 쿦
+  - 쿧
+  - 쿨
+  - 쿩
+  - 쿪
+  - 쿫
+  - 쿬
+  - 쿭
+  - 쿮
+  - 쿯
+  - 쿰
+  - 쿱
+  - 쿲
+  - 쿳
+  - 쿴
+  - 쿵
+  - 쿶
+  - 쿷
+  - 쿸
+  - 쿹
+  - 쿺
+  - 쿻
+  - 쿼
+  - 쿽
+  - 쿾
+  - 쿿
+  - 퀀
+  - 퀁
+  - 퀂
+  - 퀃
+  - 퀄
+  - 퀅
+  - 퀆
+  - 퀇
+  - 퀈
+  - 퀉
+  - 퀊
+  - 퀋
+  - 퀌
+  - 퀍
+  - 퀎
+  - 퀏
+  - 퀐
+  - 퀑
+  - 퀒
+  - 퀓
+  - 퀔
+  - 퀕
+  - 퀖
+  - 퀗
+  - 퀘
+  - 퀙
+  - 퀚
+  - 퀛
+  - 퀜
+  - 퀝
+  - 퀞
+  - 퀟
+  - 퀠
+  - 퀡
+  - 퀢
+  - 퀣
+  - 퀤
+  - 퀥
+  - 퀦
+  - 퀧
+  - 퀨
+  - 퀩
+  - 퀪
+  - 퀫
+  - 퀬
+  - 퀭
+  - 퀮
+  - 퀯
+  - 퀰
+  - 퀱
+  - 퀲
+  - 퀳
+  - 퀴
+  - 퀵
+  - 퀶
+  - 퀷
+  - 퀸
+  - 퀹
+  - 퀺
+  - 퀻
+  - 퀼
+  - 퀽
+  - 퀾
+  - 퀿
+  - 큀
+  - 큁
+  - 큂
+  - 큃
+  - 큄
+  - 큅
+  - 큆
+  - 큇
+  - 큈
+  - 큉
+  - 큊
+  - 큋
+  - 큌
+  - 큍
+  - 큎
+  - 큏
+  - 큐
+  - 큑
+  - 큒
+  - 큓
+  - 큔
+  - 큕
+  - 큖
+  - 큗
+  - 큘
+  - 큙
+  - 큚
+  - 큛
+  - 큜
+  - 큝
+  - 큞
+  - 큟
+  - 큠
+  - 큡
+  - 큢
+  - 큣
+  - 큤
+  - 큥
+  - 큦
+  - 큧
+  - 큨
+  - 큩
+  - 큪
+  - 큫
+  - 크
+  - 큭
+  - 큮
+  - 큯
+  - 큰
+  - 큱
+  - 큲
+  - 큳
+  - 클
+  - 큵
+  - 큶
+  - 큷
+  - 큸
+  - 큹
+  - 큺
+  - 큻
+  - 큼
+  - 큽
+  - 큾
+  - 큿
+  - 킀
+  - 킁
+  - 킂
+  - 킃
+  - 킄
+  - 킅
+  - 킆
+  - 킇
+  - 킈
+  - 킉
+  - 킊
+  - 킋
+  - 킌
+  - 킍
+  - 킎
+  - 킏
+  - 킐
+  - 킑
+  - 킒
+  - 킓
+  - 킔
+  - 킕
+  - 킖
+  - 킗
+  - 킘
+  - 킙
+  - 킚
+  - 킛
+  - 킜
+  - 킝
+  - 킞
+  - 킟
+  - 킠
+  - 킡
+  - 킢
+  - 킣
+  - 키
+  - 킥
+  - 킦
+  - 킧
+  - 킨
+  - 킩
+  - 킪
+  - 킫
+  - 킬
+  - 킭
+  - 킮
+  - 킯
+  - 킰
+  - 킱
+  - 킲
+  - 킳
+  - 킴
+  - 킵
+  - 킶
+  - 킷
+  - 킸
+  - 킹
+  - 킺
+  - 킻
+  - 킼
+  - 킽
+  - 킾
+  - 킿
+  - 타
+  - 탁
+  - 탂
+  - 탃
+  - 탄
+  - 탅
+  - 탆
+  - 탇
+  - 탈
+  - 탉
+  - 탊
+  - 탋
+  - 탌
+  - 탍
+  - 탎
+  - 탏
+  - 탐
+  - 탑
+  - 탒
+  - 탓
+  - 탔
+  - 탕
+  - 탖
+  - 탗
+  - 탘
+  - 탙
+  - 탚
+  - 탛
+  - 태
+  - 택
+  - 탞
+  - 탟
+  - 탠
+  - 탡
+  - 탢
+  - 탣
+  - 탤
+  - 탥
+  - 탦
+  - 탧
+  - 탨
+  - 탩
+  - 탪
+  - 탫
+  - 탬
+  - 탭
+  - 탮
+  - 탯
+  - 탰
+  - 탱
+  - 탲
+  - 탳
+  - 탴
+  - 탵
+  - 탶
+  - 탷
+  - 탸
+  - 탹
+  - 탺
+  - 탻
+  - 탼
+  - 탽
+  - 탾
+  - 탿
+  - 턀
+  - 턁
+  - 턂
+  - 턃
+  - 턄
+  - 턅
+  - 턆
+  - 턇
+  - 턈
+  - 턉
+  - 턊
+  - 턋
+  - 턌
+  - 턍
+  - 턎
+  - 턏
+  - 턐
+  - 턑
+  - 턒
+  - 턓
+  - 턔
+  - 턕
+  - 턖
+  - 턗
+  - 턘
+  - 턙
+  - 턚
+  - 턛
+  - 턜
+  - 턝
+  - 턞
+  - 턟
+  - 턠
+  - 턡
+  - 턢
+  - 턣
+  - 턤
+  - 턥
+  - 턦
+  - 턧
+  - 턨
+  - 턩
+  - 턪
+  - 턫
+  - 턬
+  - 턭
+  - 턮
+  - 턯
+  - 터
+  - 턱
+  - 턲
+  - 턳
+  - 턴
+  - 턵
+  - 턶
+  - 턷
+  - 털
+  - 턹
+  - 턺
+  - 턻
+  - 턼
+  - 턽
+  - 턾
+  - 턿
+  - 텀
+  - 텁
+  - 텂
+  - 텃
+  - 텄
+  - 텅
+  - 텆
+  - 텇
+  - 텈
+  - 텉
+  - 텊
+  - 텋
+  - 테
+  - 텍
+  - 텎
+  - 텏
+  - 텐
+  - 텑
+  - 텒
+  - 텓
+  - 텔
+  - 텕
+  - 텖
+  - 텗
+  - 텘
+  - 텙
+  - 텚
+  - 텛
+  - 템
+  - 텝
+  - 텞
+  - 텟
+  - 텠
+  - 텡
+  - 텢
+  - 텣
+  - 텤
+  - 텥
+  - 텦
+  - 텧
+  - 텨
+  - 텩
+  - 텪
+  - 텫
+  - 텬
+  - 텭
+  - 텮
+  - 텯
+  - 텰
+  - 텱
+  - 텲
+  - 텳
+  - 텴
+  - 텵
+  - 텶
+  - 텷
+  - 텸
+  - 텹
+  - 텺
+  - 텻
+  - 텼
+  - 텽
+  - 텾
+  - 텿
+  - 톀
+  - 톁
+  - 톂
+  - 톃
+  - 톄
+  - 톅
+  - 톆
+  - 톇
+  - 톈
+  - 톉
+  - 톊
+  - 톋
+  - 톌
+  - 톍
+  - 톎
+  - 톏
+  - 톐
+  - 톑
+  - 톒
+  - 톓
+  - 톔
+  - 톕
+  - 톖
+  - 톗
+  - 톘
+  - 톙
+  - 톚
+  - 톛
+  - 톜
+  - 톝
+  - 톞
+  - 톟
+  - 토
+  - 톡
+  - 톢
+  - 톣
+  - 톤
+  - 톥
+  - 톦
+  - 톧
+  - 톨
+  - 톩
+  - 톪
+  - 톫
+  - 톬
+  - 톭
+  - 톮
+  - 톯
+  - 톰
+  - 톱
+  - 톲
+  - 톳
+  - 톴
+  - 통
+  - 톶
+  - 톷
+  - 톸
+  - 톹
+  - 톺
+  - 톻
+  - 톼
+  - 톽
+  - 톾
+  - 톿
+  - 퇀
+  - 퇁
+  - 퇂
+  - 퇃
+  - 퇄
+  - 퇅
+  - 퇆
+  - 퇇
+  - 퇈
+  - 퇉
+  - 퇊
+  - 퇋
+  - 퇌
+  - 퇍
+  - 퇎
+  - 퇏
+  - 퇐
+  - 퇑
+  - 퇒
+  - 퇓
+  - 퇔
+  - 퇕
+  - 퇖
+  - 퇗
+  - 퇘
+  - 퇙
+  - 퇚
+  - 퇛
+  - 퇜
+  - 퇝
+  - 퇞
+  - 퇟
+  - 퇠
+  - 퇡
+  - 퇢
+  - 퇣
+  - 퇤
+  - 퇥
+  - 퇦
+  - 퇧
+  - 퇨
+  - 퇩
+  - 퇪
+  - 퇫
+  - 퇬
+  - 퇭
+  - 퇮
+  - 퇯
+  - 퇰
+  - 퇱
+  - 퇲
+  - 퇳
+  - 퇴
+  - 퇵
+  - 퇶
+  - 퇷
+  - 퇸
+  - 퇹
+  - 퇺
+  - 퇻
+  - 퇼
+  - 퇽
+  - 퇾
+  - 퇿
+  - 툀
+  - 툁
+  - 툂
+  - 툃
+  - 툄
+  - 툅
+  - 툆
+  - 툇
+  - 툈
+  - 툉
+  - 툊
+  - 툋
+  - 툌
+  - 툍
+  - 툎
+  - 툏
+  - 툐
+  - 툑
+  - 툒
+  - 툓
+  - 툔
+  - 툕
+  - 툖
+  - 툗
+  - 툘
+  - 툙
+  - 툚
+  - 툛
+  - 툜
+  - 툝
+  - 툞
+  - 툟
+  - 툠
+  - 툡
+  - 툢
+  - 툣
+  - 툤
+  - 툥
+  - 툦
+  - 툧
+  - 툨
+  - 툩
+  - 툪
+  - 툫
+  - 투
+  - 툭
+  - 툮
+  - 툯
+  - 툰
+  - 툱
+  - 툲
+  - 툳
+  - 툴
+  - 툵
+  - 툶
+  - 툷
+  - 툸
+  - 툹
+  - 툺
+  - 툻
+  - 툼
+  - 툽
+  - 툾
+  - 툿
+  - 퉀
+  - 퉁
+  - 퉂
+  - 퉃
+  - 퉄
+  - 퉅
+  - 퉆
+  - 퉇
+  - 퉈
+  - 퉉
+  - 퉊
+  - 퉋
+  - 퉌
+  - 퉍
+  - 퉎
+  - 퉏
+  - 퉐
+  - 퉑
+  - 퉒
+  - 퉓
+  - 퉔
+  - 퉕
+  - 퉖
+  - 퉗
+  - 퉘
+  - 퉙
+  - 퉚
+  - 퉛
+  - 퉜
+  - 퉝
+  - 퉞
+  - 퉟
+  - 퉠
+  - 퉡
+  - 퉢
+  - 퉣
+  - 퉤
+  - 퉥
+  - 퉦
+  - 퉧
+  - 퉨
+  - 퉩
+  - 퉪
+  - 퉫
+  - 퉬
+  - 퉭
+  - 퉮
+  - 퉯
+  - 퉰
+  - 퉱
+  - 퉲
+  - 퉳
+  - 퉴
+  - 퉵
+  - 퉶
+  - 퉷
+  - 퉸
+  - 퉹
+  - 퉺
+  - 퉻
+  - 퉼
+  - 퉽
+  - 퉾
+  - 퉿
+  - 튀
+  - 튁
+  - 튂
+  - 튃
+  - 튄
+  - 튅
+  - 튆
+  - 튇
+  - 튈
+  - 튉
+  - 튊
+  - 튋
+  - 튌
+  - 튍
+  - 튎
+  - 튏
+  - 튐
+  - 튑
+  - 튒
+  - 튓
+  - 튔
+  - 튕
+  - 튖
+  - 튗
+  - 튘
+  - 튙
+  - 튚
+  - 튛
+  - 튜
+  - 튝
+  - 튞
+  - 튟
+  - 튠
+  - 튡
+  - 튢
+  - 튣
+  - 튤
+  - 튥
+  - 튦
+  - 튧
+  - 튨
+  - 튩
+  - 튪
+  - 튫
+  - 튬
+  - 튭
+  - 튮
+  - 튯
+  - 튰
+  - 튱
+  - 튲
+  - 튳
+  - 튴
+  - 튵
+  - 튶
+  - 튷
+  - 트
+  - 특
+  - 튺
+  - 튻
+  - 튼
+  - 튽
+  - 튾
+  - 튿
+  - 틀
+  - 틁
+  - 틂
+  - 틃
+  - 틄
+  - 틅
+  - 틆
+  - 틇
+  - 틈
+  - 틉
+  - 틊
+  - 틋
+  - 틌
+  - 틍
+  - 틎
+  - 틏
+  - 틐
+  - 틑
+  - 틒
+  - 틓
+  - 틔
+  - 틕
+  - 틖
+  - 틗
+  - 틘
+  - 틙
+  - 틚
+  - 틛
+  - 틜
+  - 틝
+  - 틞
+  - 틟
+  - 틠
+  - 틡
+  - 틢
+  - 틣
+  - 틤
+  - 틥
+  - 틦
+  - 틧
+  - 틨
+  - 틩
+  - 틪
+  - 틫
+  - 틬
+  - 틭
+  - 틮
+  - 틯
+  - 티
+  - 틱
+  - 틲
+  - 틳
+  - 틴
+  - 틵
+  - 틶
+  - 틷
+  - 틸
+  - 틹
+  - 틺
+  - 틻
+  - 틼
+  - 틽
+  - 틾
+  - 틿
+  - 팀
+  - 팁
+  - 팂
+  - 팃
+  - 팄
+  - 팅
+  - 팆
+  - 팇
+  - 팈
+  - 팉
+  - 팊
+  - 팋
+  - 파
+  - 팍
+  - 팎
+  - 팏
+  - 판
+  - 팑
+  - 팒
+  - 팓
+  - 팔
+  - 팕
+  - 팖
+  - 팗
+  - 팘
+  - 팙
+  - 팚
+  - 팛
+  - 팜
+  - 팝
+  - 팞
+  - 팟
+  - 팠
+  - 팡
+  - 팢
+  - 팣
+  - 팤
+  - 팥
+  - 팦
+  - 팧
+  - 패
+  - 팩
+  - 팪
+  - 팫
+  - 팬
+  - 팭
+  - 팮
+  - 팯
+  - 팰
+  - 팱
+  - 팲
+  - 팳
+  - 팴
+  - 팵
+  - 팶
+  - 팷
+  - 팸
+  - 팹
+  - 팺
+  - 팻
+  - 팼
+  - 팽
+  - 팾
+  - 팿
+  - 퍀
+  - 퍁
+  - 퍂
+  - 퍃
+  - 퍄
+  - 퍅
+  - 퍆
+  - 퍇
+  - 퍈
+  - 퍉
+  - 퍊
+  - 퍋
+  - 퍌
+  - 퍍
+  - 퍎
+  - 퍏
+  - 퍐
+  - 퍑
+  - 퍒
+  - 퍓
+  - 퍔
+  - 퍕
+  - 퍖
+  - 퍗
+  - 퍘
+  - 퍙
+  - 퍚
+  - 퍛
+  - 퍜
+  - 퍝
+  - 퍞
+  - 퍟
+  - 퍠
+  - 퍡
+  - 퍢
+  - 퍣
+  - 퍤
+  - 퍥
+  - 퍦
+  - 퍧
+  - 퍨
+  - 퍩
+  - 퍪
+  - 퍫
+  - 퍬
+  - 퍭
+  - 퍮
+  - 퍯
+  - 퍰
+  - 퍱
+  - 퍲
+  - 퍳
+  - 퍴
+  - 퍵
+  - 퍶
+  - 퍷
+  - 퍸
+  - 퍹
+  - 퍺
+  - 퍻
+  - 퍼
+  - 퍽
+  - 퍾
+  - 퍿
+  - 펀
+  - 펁
+  - 펂
+  - 펃
+  - 펄
+  - 펅
+  - 펆
+  - 펇
+  - 펈
+  - 펉
+  - 펊
+  - 펋
+  - 펌
+  - 펍
+  - 펎
+  - 펏
+  - 펐
+  - 펑
+  - 펒
+  - 펓
+  - 펔
+  - 펕
+  - 펖
+  - 펗
+  - 페
+  - 펙
+  - 펚
+  - 펛
+  - 펜
+  - 펝
+  - 펞
+  - 펟
+  - 펠
+  - 펡
+  - 펢
+  - 펣
+  - 펤
+  - 펥
+  - 펦
+  - 펧
+  - 펨
+  - 펩
+  - 펪
+  - 펫
+  - 펬
+  - 펭
+  - 펮
+  - 펯
+  - 펰
+  - 펱
+  - 펲
+  - 펳
+  - 펴
+  - 펵
+  - 펶
+  - 펷
+  - 편
+  - 펹
+  - 펺
+  - 펻
+  - 펼
+  - 펽
+  - 펾
+  - 펿
+  - 폀
+  - 폁
+  - 폂
+  - 폃
+  - 폄
+  - 폅
+  - 폆
+  - 폇
+  - 폈
+  - 평
+  - 폊
+  - 폋
+  - 폌
+  - 폍
+  - 폎
+  - 폏
+  - 폐
+  - 폑
+  - 폒
+  - 폓
+  - 폔
+  - 폕
+  - 폖
+  - 폗
+  - 폘
+  - 폙
+  - 폚
+  - 폛
+  - 폜
+  - 폝
+  - 폞
+  - 폟
+  - 폠
+  - 폡
+  - 폢
+  - 폣
+  - 폤
+  - 폥
+  - 폦
+  - 폧
+  - 폨
+  - 폩
+  - 폪
+  - 폫
+  - 포
+  - 폭
+  - 폮
+  - 폯
+  - 폰
+  - 폱
+  - 폲
+  - 폳
+  - 폴
+  - 폵
+  - 폶
+  - 폷
+  - 폸
+  - 폹
+  - 폺
+  - 폻
+  - 폼
+  - 폽
+  - 폾
+  - 폿
+  - 퐀
+  - 퐁
+  - 퐂
+  - 퐃
+  - 퐄
+  - 퐅
+  - 퐆
+  - 퐇
+  - 퐈
+  - 퐉
+  - 퐊
+  - 퐋
+  - 퐌
+  - 퐍
+  - 퐎
+  - 퐏
+  - 퐐
+  - 퐑
+  - 퐒
+  - 퐓
+  - 퐔
+  - 퐕
+  - 퐖
+  - 퐗
+  - 퐘
+  - 퐙
+  - 퐚
+  - 퐛
+  - 퐜
+  - 퐝
+  - 퐞
+  - 퐟
+  - 퐠
+  - 퐡
+  - 퐢
+  - 퐣
+  - 퐤
+  - 퐥
+  - 퐦
+  - 퐧
+  - 퐨
+  - 퐩
+  - 퐪
+  - 퐫
+  - 퐬
+  - 퐭
+  - 퐮
+  - 퐯
+  - 퐰
+  - 퐱
+  - 퐲
+  - 퐳
+  - 퐴
+  - 퐵
+  - 퐶
+  - 퐷
+  - 퐸
+  - 퐹
+  - 퐺
+  - 퐻
+  - 퐼
+  - 퐽
+  - 퐾
+  - 퐿
+  - 푀
+  - 푁
+  - 푂
+  - 푃
+  - 푄
+  - 푅
+  - 푆
+  - 푇
+  - 푈
+  - 푉
+  - 푊
+  - 푋
+  - 푌
+  - 푍
+  - 푎
+  - 푏
+  - 푐
+  - 푑
+  - 푒
+  - 푓
+  - 푔
+  - 푕
+  - 푖
+  - 푗
+  - 푘
+  - 푙
+  - 푚
+  - 푛
+  - 표
+  - 푝
+  - 푞
+  - 푟
+  - 푠
+  - 푡
+  - 푢
+  - 푣
+  - 푤
+  - 푥
+  - 푦
+  - 푧
+  - 푨
+  - 푩
+  - 푪
+  - 푫
+  - 푬
+  - 푭
+  - 푮
+  - 푯
+  - 푰
+  - 푱
+  - 푲
+  - 푳
+  - 푴
+  - 푵
+  - 푶
+  - 푷
+  - 푸
+  - 푹
+  - 푺
+  - 푻
+  - 푼
+  - 푽
+  - 푾
+  - 푿
+  - 풀
+  - 풁
+  - 풂
+  - 풃
+  - 풄
+  - 풅
+  - 풆
+  - 풇
+  - 품
+  - 풉
+  - 풊
+  - 풋
+  - 풌
+  - 풍
+  - 풎
+  - 풏
+  - 풐
+  - 풑
+  - 풒
+  - 풓
+  - 풔
+  - 풕
+  - 풖
+  - 풗
+  - 풘
+  - 풙
+  - 풚
+  - 풛
+  - 풜
+  - 풝
+  - 풞
+  - 풟
+  - 풠
+  - 풡
+  - 풢
+  - 풣
+  - 풤
+  - 풥
+  - 풦
+  - 풧
+  - 풨
+  - 풩
+  - 풪
+  - 풫
+  - 풬
+  - 풭
+  - 풮
+  - 풯
+  - 풰
+  - 풱
+  - 풲
+  - 풳
+  - 풴
+  - 풵
+  - 풶
+  - 풷
+  - 풸
+  - 풹
+  - 풺
+  - 풻
+  - 풼
+  - 풽
+  - 풾
+  - 풿
+  - 퓀
+  - 퓁
+  - 퓂
+  - 퓃
+  - 퓄
+  - 퓅
+  - 퓆
+  - 퓇
+  - 퓈
+  - 퓉
+  - 퓊
+  - 퓋
+  - 퓌
+  - 퓍
+  - 퓎
+  - 퓏
+  - 퓐
+  - 퓑
+  - 퓒
+  - 퓓
+  - 퓔
+  - 퓕
+  - 퓖
+  - 퓗
+  - 퓘
+  - 퓙
+  - 퓚
+  - 퓛
+  - 퓜
+  - 퓝
+  - 퓞
+  - 퓟
+  - 퓠
+  - 퓡
+  - 퓢
+  - 퓣
+  - 퓤
+  - 퓥
+  - 퓦
+  - 퓧
+  - 퓨
+  - 퓩
+  - 퓪
+  - 퓫
+  - 퓬
+  - 퓭
+  - 퓮
+  - 퓯
+  - 퓰
+  - 퓱
+  - 퓲
+  - 퓳
+  - 퓴
+  - 퓵
+  - 퓶
+  - 퓷
+  - 퓸
+  - 퓹
+  - 퓺
+  - 퓻
+  - 퓼
+  - 퓽
+  - 퓾
+  - 퓿
+  - 픀
+  - 픁
+  - 픂
+  - 픃
+  - 프
+  - 픅
+  - 픆
+  - 픇
+  - 픈
+  - 픉
+  - 픊
+  - 픋
+  - 플
+  - 픍
+  - 픎
+  - 픏
+  - 픐
+  - 픑
+  - 픒
+  - 픓
+  - 픔
+  - 픕
+  - 픖
+  - 픗
+  - 픘
+  - 픙
+  - 픚
+  - 픛
+  - 픜
+  - 픝
+  - 픞
+  - 픟
+  - 픠
+  - 픡
+  - 픢
+  - 픣
+  - 픤
+  - 픥
+  - 픦
+  - 픧
+  - 픨
+  - 픩
+  - 픪
+  - 픫
+  - 픬
+  - 픭
+  - 픮
+  - 픯
+  - 픰
+  - 픱
+  - 픲
+  - 픳
+  - 픴
+  - 픵
+  - 픶
+  - 픷
+  - 픸
+  - 픹
+  - 픺
+  - 픻
+  - 피
+  - 픽
+  - 픾
+  - 픿
+  - 핀
+  - 핁
+  - 핂
+  - 핃
+  - 필
+  - 핅
+  - 핆
+  - 핇
+  - 핈
+  - 핉
+  - 핊
+  - 핋
+  - 핌
+  - 핍
+  - 핎
+  - 핏
+  - 핐
+  - 핑
+  - 핒
+  - 핓
+  - 핔
+  - 핕
+  - 핖
+  - 핗
+  - 하
+  - 학
+  - 핚
+  - 핛
+  - 한
+  - 핝
+  - 핞
+  - 핟
+  - 할
+  - 핡
+  - 핢
+  - 핣
+  - 핤
+  - 핥
+  - 핦
+  - 핧
+  - 함
+  - 합
+  - 핪
+  - 핫
+  - 핬
+  - 항
+  - 핮
+  - 핯
+  - 핰
+  - 핱
+  - 핲
+  - 핳
+  - 해
+  - 핵
+  - 핶
+  - 핷
+  - 핸
+  - 핹
+  - 핺
+  - 핻
+  - 핼
+  - 핽
+  - 핾
+  - 핿
+  - 햀
+  - 햁
+  - 햂
+  - 햃
+  - 햄
+  - 햅
+  - 햆
+  - 햇
+  - 했
+  - 행
+  - 햊
+  - 햋
+  - 햌
+  - 햍
+  - 햎
+  - 햏
+  - 햐
+  - 햑
+  - 햒
+  - 햓
+  - 햔
+  - 햕
+  - 햖
+  - 햗
+  - 햘
+  - 햙
+  - 햚
+  - 햛
+  - 햜
+  - 햝
+  - 햞
+  - 햟
+  - 햠
+  - 햡
+  - 햢
+  - 햣
+  - 햤
+  - 향
+  - 햦
+  - 햧
+  - 햨
+  - 햩
+  - 햪
+  - 햫
+  - 햬
+  - 햭
+  - 햮
+  - 햯
+  - 햰
+  - 햱
+  - 햲
+  - 햳
+  - 햴
+  - 햵
+  - 햶
+  - 햷
+  - 햸
+  - 햹
+  - 햺
+  - 햻
+  - 햼
+  - 햽
+  - 햾
+  - 햿
+  - 헀
+  - 헁
+  - 헂
+  - 헃
+  - 헄
+  - 헅
+  - 헆
+  - 헇
+  - 허
+  - 헉
+  - 헊
+  - 헋
+  - 헌
+  - 헍
+  - 헎
+  - 헏
+  - 헐
+  - 헑
+  - 헒
+  - 헓
+  - 헔
+  - 헕
+  - 헖
+  - 헗
+  - 험
+  - 헙
+  - 헚
+  - 헛
+  - 헜
+  - 헝
+  - 헞
+  - 헟
+  - 헠
+  - 헡
+  - 헢
+  - 헣
+  - 헤
+  - 헥
+  - 헦
+  - 헧
+  - 헨
+  - 헩
+  - 헪
+  - 헫
+  - 헬
+  - 헭
+  - 헮
+  - 헯
+  - 헰
+  - 헱
+  - 헲
+  - 헳
+  - 헴
+  - 헵
+  - 헶
+  - 헷
+  - 헸
+  - 헹
+  - 헺
+  - 헻
+  - 헼
+  - 헽
+  - 헾
+  - 헿
+  - 혀
+  - 혁
+  - 혂
+  - 혃
+  - 현
+  - 혅
+  - 혆
+  - 혇
+  - 혈
+  - 혉
+  - 혊
+  - 혋
+  - 혌
+  - 혍
+  - 혎
+  - 혏
+  - 혐
+  - 협
+  - 혒
+  - 혓
+  - 혔
+  - 형
+  - 혖
+  - 혗
+  - 혘
+  - 혙
+  - 혚
+  - 혛
+  - 혜
+  - 혝
+  - 혞
+  - 혟
+  - 혠
+  - 혡
+  - 혢
+  - 혣
+  - 혤
+  - 혥
+  - 혦
+  - 혧
+  - 혨
+  - 혩
+  - 혪
+  - 혫
+  - 혬
+  - 혭
+  - 혮
+  - 혯
+  - 혰
+  - 혱
+  - 혲
+  - 혳
+  - 혴
+  - 혵
+  - 혶
+  - 혷
+  - 호
+  - 혹
+  - 혺
+  - 혻
+  - 혼
+  - 혽
+  - 혾
+  - 혿
+  - 홀
+  - 홁
+  - 홂
+  - 홃
+  - 홄
+  - 홅
+  - 홆
+  - 홇
+  - 홈
+  - 홉
+  - 홊
+  - 홋
+  - 홌
+  - 홍
+  - 홎
+  - 홏
+  - 홐
+  - 홑
+  - 홒
+  - 홓
+  - 화
+  - 확
+  - 홖
+  - 홗
+  - 환
+  - 홙
+  - 홚
+  - 홛
+  - 활
+  - 홝
+  - 홞
+  - 홟
+  - 홠
+  - 홡
+  - 홢
+  - 홣
+  - 홤
+  - 홥
+  - 홦
+  - 홧
+  - 홨
+  - 황
+  - 홪
+  - 홫
+  - 홬
+  - 홭
+  - 홮
+  - 홯
+  - 홰
+  - 홱
+  - 홲
+  - 홳
+  - 홴
+  - 홵
+  - 홶
+  - 홷
+  - 홸
+  - 홹
+  - 홺
+  - 홻
+  - 홼
+  - 홽
+  - 홾
+  - 홿
+  - 횀
+  - 횁
+  - 횂
+  - 횃
+  - 횄
+  - 횅
+  - 횆
+  - 횇
+  - 횈
+  - 횉
+  - 횊
+  - 횋
+  - 회
+  - 획
+  - 횎
+  - 횏
+  - 횐
+  - 횑
+  - 횒
+  - 횓
+  - 횔
+  - 횕
+  - 횖
+  - 횗
+  - 횘
+  - 횙
+  - 횚
+  - 횛
+  - 횜
+  - 횝
+  - 횞
+  - 횟
+  - 횠
+  - 횡
+  - 횢
+  - 횣
+  - 횤
+  - 횥
+  - 횦
+  - 횧
+  - 효
+  - 횩
+  - 횪
+  - 횫
+  - 횬
+  - 횭
+  - 횮
+  - 횯
+  - 횰
+  - 횱
+  - 횲
+  - 횳
+  - 횴
+  - 횵
+  - 횶
+  - 횷
+  - 횸
+  - 횹
+  - 횺
+  - 횻
+  - 횼
+  - 횽
+  - 횾
+  - 횿
+  - 훀
+  - 훁
+  - 훂
+  - 훃
+  - 후
+  - 훅
+  - 훆
+  - 훇
+  - 훈
+  - 훉
+  - 훊
+  - 훋
+  - 훌
+  - 훍
+  - 훎
+  - 훏
+  - 훐
+  - 훑
+  - 훒
+  - 훓
+  - 훔
+  - 훕
+  - 훖
+  - 훗
+  - 훘
+  - 훙
+  - 훚
+  - 훛
+  - 훜
+  - 훝
+  - 훞
+  - 훟
+  - 훠
+  - 훡
+  - 훢
+  - 훣
+  - 훤
+  - 훥
+  - 훦
+  - 훧
+  - 훨
+  - 훩
+  - 훪
+  - 훫
+  - 훬
+  - 훭
+  - 훮
+  - 훯
+  - 훰
+  - 훱
+  - 훲
+  - 훳
+  - 훴
+  - 훵
+  - 훶
+  - 훷
+  - 훸
+  - 훹
+  - 훺
+  - 훻
+  - 훼
+  - 훽
+  - 훾
+  - 훿
+  - 휀
+  - 휁
+  - 휂
+  - 휃
+  - 휄
+  - 휅
+  - 휆
+  - 휇
+  - 휈
+  - 휉
+  - 휊
+  - 휋
+  - 휌
+  - 휍
+  - 휎
+  - 휏
+  - 휐
+  - 휑
+  - 휒
+  - 휓
+  - 휔
+  - 휕
+  - 휖
+  - 휗
+  - 휘
+  - 휙
+  - 휚
+  - 휛
+  - 휜
+  - 휝
+  - 휞
+  - 휟
+  - 휠
+  - 휡
+  - 휢
+  - 휣
+  - 휤
+  - 휥
+  - 휦
+  - 휧
+  - 휨
+  - 휩
+  - 휪
+  - 휫
+  - 휬
+  - 휭
+  - 휮
+  - 휯
+  - 휰
+  - 휱
+  - 휲
+  - 휳
+  - 휴
+  - 휵
+  - 휶
+  - 휷
+  - 휸
+  - 휹
+  - 휺
+  - 휻
+  - 휼
+  - 휽
+  - 휾
+  - 휿
+  - 흀
+  - 흁
+  - 흂
+  - 흃
+  - 흄
+  - 흅
+  - 흆
+  - 흇
+  - 흈
+  - 흉
+  - 흊
+  - 흋
+  - 흌
+  - 흍
+  - 흎
+  - 흏
+  - 흐
+  - 흑
+  - 흒
+  - 흓
+  - 흔
+  - 흕
+  - 흖
+  - 흗
+  - 흘
+  - 흙
+  - 흚
+  - 흛
+  - 흜
+  - 흝
+  - 흞
+  - 흟
+  - 흠
+  - 흡
+  - 흢
+  - 흣
+  - 흤
+  - 흥
+  - 흦
+  - 흧
+  - 흨
+  - 흩
+  - 흪
+  - 흫
+  - 희
+  - 흭
+  - 흮
+  - 흯
+  - 흰
+  - 흱
+  - 흲
+  - 흳
+  - 흴
+  - 흵
+  - 흶
+  - 흷
+  - 흸
+  - 흹
+  - 흺
+  - 흻
+  - 흼
+  - 흽
+  - 흾
+  - 흿
+  - 힀
+  - 힁
+  - 힂
+  - 힃
+  - 힄
+  - 힅
+  - 힆
+  - 힇
+  - 히
+  - 힉
+  - 힊
+  - 힋
+  - 힌
+  - 힍
+  - 힎
+  - 힏
+  - 힐
+  - 힑
+  - 힒
+  - 힓
+  - 힔
+  - 힕
+  - 힖
+  - 힗
+  - 힘
+  - 힙
+  - 힚
+  - 힛
+  - 힜
+  - 힝
+  - 힞
+  - 힟
+  - 힠
+  - 힡
+  - 힢
+  - 힣
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ₿
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ●
+  - ▶
+  - 𝑢
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - ︾
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - ¡
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - ₤
+  - ₡
+  - ₹
+  - −
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ™
+  - Ω
+  - ℮
+  - ∆
+  - ✓
+  - ✗
+  - ✘
+  - ▪
+  - ◼
+  - ✔
+  - ✕
+  - ☑
+  - ☒
+  - №
+  - ₽
+  - ₴
+  - Α
+  - α
+  - Β
+  - β
+  - Γ
+  - γ
+  - Δ
+  - δ
+  - Ε
+  - ε
+  - Ζ
+  - ζ
+  - Η
+  - η
+  - Θ
+  - θ
+  - Ι
+  - ι
+  - Κ
+  - κ
+  - Λ
+  - λ
+  - Μ
+  - μ
+  - Ν
+  - ν
+  - Ξ
+  - ξ
+  - Ο
+  - ο
+  - Π
+  - π
+  - Ρ
+  - ρ
+  - Σ
+  - σ
+  - ς
+  - Τ
+  - τ
+  - Υ
+  - υ
+  - Φ
+  - φ
+  - Χ
+  - χ
+  - Ψ
+  - ψ
+  - ω
diff --git a/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..c3e40e4
--- /dev/null
+++ b/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[838],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,838],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,838],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,838],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,838],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,838],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..e216da1
Binary files /dev/null and b/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..89550cd
--- /dev/null
+++ b/backend/models/V5/latin_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,881 @@
+Global:
+  model_name: latin_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+      max_text_length: 1000
+  - RecResizeImg:
+      eval_mode: true
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - ×
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - ß
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ÷
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - Ā
+  - ā
+  - Ă
+  - ă
+  - Ą
+  - ą
+  - Ć
+  - ć
+  - Ĉ
+  - ĉ
+  - Ċ
+  - ċ
+  - Č
+  - č
+  - Ď
+  - ď
+  - Đ
+  - đ
+  - Ē
+  - ē
+  - Ĕ
+  - ĕ
+  - Ė
+  - ė
+  - Ę
+  - ę
+  - Ě
+  - ě
+  - Ĝ
+  - ĝ
+  - Ğ
+  - ğ
+  - Ġ
+  - ġ
+  - Ģ
+  - ģ
+  - Ĥ
+  - ĥ
+  - Ħ
+  - ħ
+  - Ĩ
+  - ĩ
+  - Ī
+  - ī
+  - Ĭ
+  - ĭ
+  - Į
+  - į
+  - İ
+  - ı
+  - IJ
+  - ij
+  - Ĵ
+  - ĵ
+  - Ķ
+  - ķ
+  - ĸ
+  - Ĺ
+  - ĺ
+  - Ļ
+  - ļ
+  - Ľ
+  - ľ
+  - Ŀ
+  - ŀ
+  - Ł
+  - ł
+  - Ń
+  - ń
+  - Ņ
+  - ņ
+  - Ň
+  - ň
+  - ʼn
+  - Ŋ
+  - ŋ
+  - Ō
+  - ō
+  - Ŏ
+  - ŏ
+  - Ő
+  - ő
+  - Œ
+  - œ
+  - Ŕ
+  - ŕ
+  - Ŗ
+  - ŗ
+  - Ř
+  - ř
+  - Ś
+  - ś
+  - Ŝ
+  - ŝ
+  - Ş
+  - ş
+  - Š
+  - š
+  - Ţ
+  - ţ
+  - Ť
+  - ť
+  - Ŧ
+  - ŧ
+  - Ũ
+  - ũ
+  - Ū
+  - ū
+  - Ŭ
+  - ŭ
+  - Ů
+  - ů
+  - Ű
+  - ű
+  - Ų
+  - ų
+  - Ŵ
+  - ŵ
+  - Ŷ
+  - ŷ
+  - Ÿ
+  - Ź
+  - ź
+  - Ż
+  - ż
+  - Ž
+  - ž
+  - ſ
+  - ƀ
+  - Ɓ
+  - Ƃ
+  - ƃ
+  - Ƅ
+  - ƅ
+  - Ɔ
+  - Ƈ
+  - ƈ
+  - Ɖ
+  - Ɗ
+  - Ƌ
+  - ƌ
+  - ƍ
+  - Ǝ
+  - Ə
+  - Ɛ
+  - Ƒ
+  - ƒ
+  - Ɠ
+  - Ɣ
+  - ƕ
+  - Ɩ
+  - Ɨ
+  - Ƙ
+  - ƙ
+  - ƚ
+  - ƛ
+  - Ɯ
+  - Ɲ
+  - ƞ
+  - Ɵ
+  - Ơ
+  - ơ
+  - Ƣ
+  - ƣ
+  - Ƥ
+  - ƥ
+  - Ʀ
+  - Ƨ
+  - ƨ
+  - Ʃ
+  - ƪ
+  - ƫ
+  - Ƭ
+  - ƭ
+  - Ʈ
+  - Ư
+  - ư
+  - Ʊ
+  - Ʋ
+  - Ƴ
+  - ƴ
+  - Ƶ
+  - ƶ
+  - Ʒ
+  - Ƹ
+  - ƹ
+  - ƺ
+  - ƻ
+  - Ƽ
+  - ƽ
+  - ƾ
+  - ƿ
+  - ǀ
+  - ǁ
+  - ǂ
+  - ǃ
+  - DŽ
+  - Dž
+  - dž
+  - LJ
+  - Lj
+  - lj
+  - NJ
+  - Nj
+  - nj
+  - Ǎ
+  - ǎ
+  - Ǐ
+  - ǐ
+  - Ǒ
+  - ǒ
+  - Ǔ
+  - ǔ
+  - Ǖ
+  - ǖ
+  - Ǘ
+  - ǘ
+  - Ǚ
+  - ǚ
+  - Ǜ
+  - ǜ
+  - ǝ
+  - Ǟ
+  - ǟ
+  - Ǡ
+  - ǡ
+  - Ǣ
+  - ǣ
+  - Ǥ
+  - ǥ
+  - Ǧ
+  - ǧ
+  - Ǩ
+  - ǩ
+  - Ǫ
+  - ǫ
+  - Ǭ
+  - ǭ
+  - Ǯ
+  - ǯ
+  - ǰ
+  - DZ
+  - Dz
+  - dz
+  - Ǵ
+  - ǵ
+  - Ƕ
+  - Ƿ
+  - Ǹ
+  - ǹ
+  - Ǻ
+  - ǻ
+  - Ǽ
+  - ǽ
+  - Ǿ
+  - ǿ
+  - Ȁ
+  - ȁ
+  - Ȃ
+  - ȃ
+  - Ȅ
+  - ȅ
+  - Ȇ
+  - ȇ
+  - Ȉ
+  - ȉ
+  - Ȋ
+  - ȋ
+  - Ȍ
+  - ȍ
+  - Ȏ
+  - ȏ
+  - Ȑ
+  - ȑ
+  - Ȓ
+  - ȓ
+  - Ȕ
+  - ȕ
+  - Ȗ
+  - ȗ
+  - Ș
+  - ș
+  - Ț
+  - ț
+  - Ȝ
+  - ȝ
+  - Ȟ
+  - ȟ
+  - Ƞ
+  - ȡ
+  - Ȣ
+  - ȣ
+  - Ȥ
+  - ȥ
+  - Ȧ
+  - ȧ
+  - Ȩ
+  - ȩ
+  - Ȫ
+  - ȫ
+  - Ȭ
+  - ȭ
+  - Ȯ
+  - ȯ
+  - Ȱ
+  - ȱ
+  - Ȳ
+  - ȳ
+  - ȴ
+  - ȵ
+  - ȶ
+  - ȷ
+  - ȸ
+  - ȹ
+  - Ⱥ
+  - Ȼ
+  - ȼ
+  - Ƚ
+  - Ⱦ
+  - ȿ
+  - ɀ
+  - Ɂ
+  - ɂ
+  - Ƀ
+  - Ʉ
+  - Ʌ
+  - Ɇ
+  - ɇ
+  - Ɉ
+  - ɉ
+  - Ɋ
+  - ɋ
+  - Ɍ
+  - ɍ
+  - Ɏ
+  - ɏ
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - '@'
+  - '['
+  - \
+  - ']'
+  - _
+  - '`'
+  - '{'
+  - '|'
+  - '}'
+  - ^
+  - '~'
+  - ©
+  - ®
+  - ℉
+  - №
+  - Ω
+  - ℮
+  - ™
+  - ∆
+  - ✓
+  - ✔
+  - ✗
+  - ✘
+  - ✕
+  - ☑
+  - ☒
+  - ●
+  - ▪
+  - ▫
+  - ◼
+  - ▶
+  - ◀
+  - ⬆
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - −
+  - ₤
+  - ₡
+  - ₹
+  - ₽
+  - ₴
+  - ₿
+  - ¢
+  - €
+  - £
+  - ¥
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ∩
+  - ∪
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ⊥
+  - ⊾
+  - ⊿
+  - □
+  - ∥
+  - ∋
+  - ƒ
+  - ′
+  - ″
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - Α
+  - Β
+  - Γ
+  - Δ
+  - Ε
+  - Ζ
+  - Η
+  - Θ
+  - Ι
+  - Κ
+  - Λ
+  - Μ
+  - Ν
+  - Ξ
+  - Ο
+  - Π
+  - Ρ
+  - Σ
+  - Τ
+  - Υ
+  - Φ
+  - Χ
+  - Ψ
+  - Ω
+  - α
+  - β
+  - γ
+  - δ
+  - ε
+  - ζ
+  - η
+  - θ
+  - ι
+  - κ
+  - λ
+  - μ
+  - ν
+  - ξ
+  - ο
+  - π
+  - ρ
+  - σ
+  - ς
+  - τ
+  - υ
+  - φ
+  - χ
+  - ψ
+  - ω
+  - Å
+  - ℏ
+  - ⌀
+  - ⍺
+  - ⍵
+  - 𝑢
+  - 𝜓
+  - ०
+  - ‥
+  - ︽
+  - ﹥
+  - •
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ℧
+  - ☺
diff --git a/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.json b/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.json
new file mode 100644
index 0000000..ee6c9bf
--- /dev/null
+++ b/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.json
@@ -0,0 +1 @@
+{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[526],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,526],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,526],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,526],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,526],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,526],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}}
\ No newline at end of file
diff --git a/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.pdiparams b/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.pdiparams
new file mode 100644
index 0000000..aaee790
Binary files /dev/null and b/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.pdiparams differ
diff --git a/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.yml b/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.yml
new file mode 100644
index 0000000..642b895
--- /dev/null
+++ b/backend/models/V5/th_PP-OCRv5_mobile_rec_infer/inference.yml
@@ -0,0 +1,567 @@
+Global:
+  model_name: th_PP-OCRv5_mobile_rec
+Hpi:
+  backend_configs:
+    paddle_infer:
+      trt_dynamic_shapes: &id001
+        x:
+        - - 1
+          - 3
+          - 48
+          - 160
+        - - 1
+          - 3
+          - 48
+          - 320
+        - - 8
+          - 3
+          - 48
+          - 3200
+    tensorrt:
+      dynamic_shapes: *id001
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - MultiLabelEncode:
+      gtc_encode: NRTRLabelEncode
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 48
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label_ctc
+      - label_gtc
+      - length
+      - valid_ratio
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - '!'
+  - '"'
+  - '#'
+  - $
+  - '%'
+  - '&'
+  - ''''
+  - (
+  - )
+  - '*'
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - ;
+  - <
+  - '='
+  - '>'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - Q
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - _
+  - '`'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - ©
+  - ‥
+  - '{'
+  - '}'
+  - \
+  - '|'
+  - '@'
+  - ^
+  - '~'
+  - ÷
+  - ∕
+  - ∙
+  - ⋅
+  - ·
+  - ±
+  - ∓
+  - ∩
+  - ∪
+  - □
+  - ←
+  - ↔
+  - ⇒
+  - ⇐
+  - ⇔
+  - ∀
+  - ∃
+  - ∄
+  - ∴
+  - ∵
+  - ∝
+  - ∞
+  - ⊥
+  - ∟
+  - ∠
+  - ∡
+  - ∢
+  - ′
+  - ″
+  - ∥
+  - ⊾
+  - ⊿
+  - ∂
+  - ∫
+  - ∬
+  - ∭
+  - ∮
+  - ∯
+  - ∰
+  - ∑
+  - ∏
+  - √
+  - ∛
+  - ∜
+  - ∱
+  - ∲
+  - ∳
+  - ∶
+  - ∷
+  - ∼
+  - ®
+  - ℉
+  - Ω
+  - ℧
+  - Å
+  - ⌀
+  - ℏ
+  - ⅀
+  - ⍺
+  - ⍵
+  - ¢
+  - €
+  - £
+  - ¥
+  - ₿
+  - Ⅰ
+  - Ⅱ
+  - Ⅲ
+  - Ⅳ
+  - Ⅴ
+  - Ⅵ
+  - Ⅶ
+  - Ⅷ
+  - Ⅸ
+  - Ⅹ
+  - Ⅺ
+  - Ⅻ
+  - ⅰ
+  - ⅱ
+  - ⅲ
+  - ⅳ
+  - ⅴ
+  - ⅵ
+  - ⅶ
+  - ⅷ
+  - ⅸ
+  - ⅹ
+  - ⅺ
+  - ⅻ
+  - ➀
+  - ➁
+  - ➂
+  - ➃
+  - ➄
+  - ➅
+  - ➆
+  - ➇
+  - ➈
+  - ➉
+  - ➊
+  - ➋
+  - ➌
+  - ➍
+  - ➎
+  - ➏
+  - ➐
+  - ➑
+  - ➒
+  - ➓
+  - ❶
+  - ❷
+  - ❸
+  - ❹
+  - ❺
+  - ❻
+  - ❼
+  - ❽
+  - ❾
+  - ❿
+  - ①
+  - ②
+  - ③
+  - ④
+  - ⑤
+  - ⑥
+  - ⑦
+  - ⑧
+  - ⑨
+  - ⑩
+  - ●
+  - ▶
+  - 𝑢
+  - ︽
+  - –
+  - ﹥
+  - 𝜓
+  - •
+  - ∋
+  - ƒ
+  - ०
+  - ⬆
+  - Ạ
+  - ◀
+  - 
+  - ▫
+  - ︾
+  - À
+  - Á
+  - Â
+  - Ã
+  - Ä
+  - Å
+  - Æ
+  - Ç
+  - È
+  - É
+  - Ê
+  - Ë
+  - Ì
+  - Í
+  - Î
+  - Ï
+  - Ð
+  - Ñ
+  - Ò
+  - Ó
+  - Ô
+  - Õ
+  - Ö
+  - Ø
+  - Ù
+  - Ú
+  - Û
+  - Ü
+  - Ý
+  - Þ
+  - à
+  - á
+  - â
+  - ã
+  - ä
+  - å
+  - æ
+  - ç
+  - è
+  - é
+  - ê
+  - ë
+  - ì
+  - í
+  - î
+  - ï
+  - ð
+  - ñ
+  - ò
+  - ó
+  - ô
+  - õ
+  - ö
+  - ø
+  - ù
+  - ú
+  - û
+  - ü
+  - ý
+  - þ
+  - ÿ
+  - ¡
+  - ¤
+  - ¦
+  - §
+  - ¨
+  - ª
+  - «
+  - ¬
+  - ¯
+  - °
+  - ²
+  - ³
+  - ´
+  - µ
+  - ¶
+  - ¸
+  - ¹
+  - º
+  - »
+  - ¼
+  - ½
+  - ¾
+  - ¿
+  - ×
+  - ‐
+  - ‑
+  - ‒
+  - —
+  - ―
+  - ‖
+  - ‗
+  - ‘
+  - ’
+  - ‚
+  - ‛
+  - “
+  - ”
+  - „
+  - ‟
+  - †
+  - ‡
+  - ‣
+  - ․
+  - …
+  - ‧
+  - ‰
+  - ‴
+  - ‵
+  - ‶
+  - ‷
+  - ‸
+  - ‹
+  - ›
+  - ※
+  - ‼
+  - ‽
+  - ‾
+  - ₤
+  - ₡
+  - ₹
+  - −
+  - ∖
+  - ∗
+  - ≈
+  - ≠
+  - ≡
+  - ≤
+  - ≥
+  - ⊂
+  - ⊃
+  - ↑
+  - →
+  - ↓
+  - ↕
+  - ™
+  - Ω
+  - ℮
+  - ∆
+  - ✓
+  - ✗
+  - ✘
+  - ▪
+  - ◼
+  - ✔
+  - ✕
+  - ☑
+  - ☒
+  - №
+  - ₽
+  - ₴
+  - Α
+  - α
+  - Β
+  - β
+  - Γ
+  - γ
+  - Δ
+  - δ
+  - Ε
+  - ε
+  - Ζ
+  - ζ
+  - Η
+  - η
+  - Θ
+  - θ
+  - Ι
+  - ι
+  - Κ
+  - κ
+  - Λ
+  - λ
+  - Μ
+  - μ
+  - Ν
+  - ν
+  - Ξ
+  - ξ
+  - Ο
+  - ο
+  - Π
+  - π
+  - Ρ
+  - ρ
+  - Σ
+  - σ
+  - ς
+  - Τ
+  - τ
+  - Υ
+  - υ
+  - Φ
+  - φ
+  - Χ
+  - χ
+  - Ψ
+  - ψ
+  - ω
+  - ก
+  - ข
+  - ค
+  - ฅ
+  - ฆ
+  - ง
+  - จ
+  - ฉ
+  - ช
+  - ซ
+  - ฌ
+  - ญ
+  - ฎ
+  - ฏ
+  - ฐ
+  - ฑ
+  - ฒ
+  - ณ
+  - ด
+  - ต
+  - ถ
+  - ท
+  - ธ
+  - น
+  - บ
+  - ป
+  - ผ
+  - ฝ
+  - พ
+  - ฟ
+  - ภ
+  - ม
+  - ย
+  - ร
+  - ฤ
+  - ล
+  - ฦ
+  - ว
+  - ศ
+  - ษ
+  - ส
+  - ห
+  - ฬ
+  - อ
+  - ฮ
+  - ฯ
+  - ะ
+  - ั
+  - า
+  - ำ
+  - ิ
+  - ี
+  - ึ
+  - ื
+  - ุ
+  - ู
+  - ฺ
+  - ฿
+  - เ
+  - แ
+  - โ
+  - ใ
+  - ไ
+  - ๅ
+  - ๆ
+  - ็
+  - ่
+  - ้
+  - ๊
+  - ๋
+  - ์
+  - ํ
+  - ๐
+  - ๑
+  - ๒
+  - ๓
+  - ๔
+  - ๕
+  - ๖
+  - ๗
+  - ๘
+  - ๙
+  - ๚
diff --git a/backend/subfinder/linux/VideoSubFinderCli b/backend/subfinder/linux/VideoSubFinderCli
new file mode 100755
index 0000000..74ff384
Binary files /dev/null and b/backend/subfinder/linux/VideoSubFinderCli differ
diff --git a/backend/subfinder/linux/VideoSubFinderCli.run b/backend/subfinder/linux/VideoSubFinderCli.run
new file mode 100755
index 0000000..9f2ad6a
--- /dev/null
+++ b/backend/subfinder/linux/VideoSubFinderCli.run
@@ -0,0 +1,5 @@
+#!/bin/sh
+cd ${0%/*}
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD:/lib64
+chmod +x ./VideoSubFinderCli
+./VideoSubFinderCli "$@"
diff --git a/backend/subfinder/linux/settings/general.cfg b/backend/subfinder/linux/settings/general.cfg
new file mode 100644
index 0000000..da02917
--- /dev/null
+++ b/backend/subfinder/linux/settings/general.cfg
@@ -0,0 +1,35 @@
+prefered_locale = eng
+dont_delete_unrecognized_images1 = 1
+dont_delete_unrecognized_images2 = 1
+generate_cleared_text_images_on_test = 1
+dump_debug_images = 0
+dump_debug_second_filtration_images = 0
+clear_test_images_folder = 1
+show_transformed_images_only = 0
+moderate_threshold = 0.4
+moderate_threshold_for_NEdges = 0.3
+segment_width = 8
+segment_height = 3
+minimum_segments_count = 2
+min_sum_color_diff = 500
+between_text_distace = 0.05
+text_centre_offset = 0.1
+min_points_number = 30
+min_points_density = 0.3
+min_symbol_height = 0.02
+min_symbol_density = 0.2
+min_NEdges_points_density = 0.25
+threads = 4
+sub_frame_length = 6
+text_procent = 0.3
+min_text_len_(in_procent) = 0.022
+sub_square_error = 0.3
+vedges_points_line_error = 0.35
+clear_image_logical = 0
+clean_rgb_images_after_run = 0
+def_string_for_empty_sub = sub duration: %sub_duration%
+min_sub_duration = 0
+txt_dw = 5
+txt_dy = 5
+fount_size_ocr_lbl = 8
+fount_size_ocr_btn = 10
diff --git a/backend/subfinder/macos/VideoSubFinderCli b/backend/subfinder/macos/VideoSubFinderCli
new file mode 100755
index 0000000..62ed194
Binary files /dev/null and b/backend/subfinder/macos/VideoSubFinderCli differ
diff --git a/backend/subfinder/macos/settings/Localization/chn/locale.cfg b/backend/subfinder/macos/settings/Localization/chn/locale.cfg
new file mode 100644
index 0000000..6d2cdc9
--- /dev/null
+++ b/backend/subfinder/macos/settings/Localization/chn/locale.cfg
@@ -0,0 +1,220 @@
+help_desc_hotkeys_for_video_box = 视频预览框快捷键:;;滤镜快捷键:;按住'U'键: 全屏显示原始图片;按住'R'键: 将会显示使用滤镜后的图片;按住'T'键: 将会显示:;* - 所有和字幕颜色滤镜有关的像素会显示为红色;* - 所有和字幕描边滤镜有关的像素会显示为绿色;* - 同时存在于字幕和字幕描边滤镜中的像素会显示为黄色;(不显示黄色则更好);按住'Y'键: 会显示所有与字幕相关的原始颜色, 其他的则会显示为黑色或者白色;按住'I'键: 会显示所有与字幕描边相关的原始颜色, 其他的则会显示为黑色或者白色;;视频导航快捷键:;按住左/右键或者用鼠标滚轮显示上一帧或下一帧;按空格键播放/暂停视频;;设置运行起止时间快捷键:;使用'Ctrl+Z'设置开始时间;使用'Ctrl+X'设置结束时间
+help_desc_hotkeys_for_image_box = 图片预览框快捷键:;按住'U'键: 图片会全屏显示.;按住左/右键或者用鼠标滚轮显示测试时生成的不同类型的图片
+ocr_dg_sub_group_settings_for_create_txt_images = 生成二值化文本图片设置 (RGBImages->TXTImages)
+ocr_dg_sub_group_settings_for_join_images = 拼合图片设置;(TXT/RGBImages->ImagesJoined->"TXTResults/join_txt_results.txt")
+ocr_dg_sub_group_settings_for_create_sub = 生成字幕文件设置
+ocr_label_join_images_join_rgb_images = 拼合RGB图片 (取消勾选则拼合二值化图片)
+ocr_label_join_images_use_txt_images_data_for_join_rgb_images = 使用二值化图片的数据拼合RGB图片（取消勾选要设置分隔符字号）
+ocr_label_join_images_clear_dir = 运行之前清理ImagesJoined文件夹
+ocr_label_join_images_split_line_text = 拼合图片的分隔符
+ocr_label_join_images_split_line_font_size = 分隔符字号
+ocr_label_join_images_split_line_font_bold = 加粗分隔符
+ocr_label_join_images_sub_id_format = 分隔符格式
+ocr_label_join_images_sub_search_by_id_format = 叠图文本内定位分隔符格式
+ocr_label_join_images_scale = 缩放倍数 (根据原始RGB图像缩放)
+ocr_label_join_images_max_number = 拼图最大数量
+menu_fonts = 字体设置
+fd_main_font_gb_label = 主界面字体
+fd_buttons_font_gb_label = 按钮字体
+fd_font_size = 字号
+fd_font_name = 字体
+fd_font_bold = 加粗
+fd_font_italic = 斜体
+fd_font_underline = 下划线
+text_alignment_center = 居中
+text_alignment_left = 左对齐
+text_alignment_right = 右对齐
+text_alignment_any = 任意位置
+run_search_progress_format_string = 进度: %s 剩余时间: %s 运行时间: %s   |   %s%s
+ccti_start_progress_format_string = 进度: 0%%   |   0 : %.5d
+ccti_progress_format_string = 进度: %%%2.2f 剩余时间: %s 运行时间: %s   |   %.5d : %.5d
+file_dialog_title_open_video_file = 打开视频
+file_dialog_title_open_video_file_wild_card = 视频文件 (%s)|%s|所有文件 (*.*)|*.*
+file_dialog_title_open_settings_file = 导入设置文件
+file_dialog_title_open_settings_file_wild_card = *.cfg
+file_dialog_title_save_settings_file = 保存设置文件
+file_dialog_title_save_settings_file_wild_card = 设置文件 (*.cfg)|*.cfg
+file_dialog_title_save_subtitle_as = 保存字幕为...
+file_dialog_title_save_subtitle_as_wild_card = SubRip(*.srt)|*.srt|Advanced Sub Station Alpha(*.ass)|*.ass|所有文件 (*.*)|*.*
+menu_file = &文件
+menu_edit = &编辑
+menu_view = &查看
+menu_play = &播放
+menu_help = &帮助
+menu_localization = 语言
+menu_setpriority = 设置优先级
+menu_setpriority_high = 高
+menu_setpriority_abovenormal = 高于正常
+menu_setpriority_normal = 正常
+menu_setpriority_belownormal = 低于正常
+menu_setpriority_idle = 空闲
+menu_file_open_video_opencv = 打开视频 (OpenCV)
+menu_file_open_video_ffmpeg = 打开视频 (FFMPEG)
+menu_file_reopenvideo = 重新打开视频
+menu_file_openpreviousvideo = 打开上一个视频
+menu_file_savesettings = 保存设置
+menu_file_savesettingsas = 保存设置为...
+menu_file_loadsettings = 导入设置...
+menu_file_exit = 退出
+menu_edit_setbegintime = 设置开始时间
+menu_edit_setendtime = 设置结束时间
+menu_scale_text_size_inc = 放大菜单文字 +
+menu_scale_text_size_dec = 缩小菜单文字 -
+menu_play_pause = 播放/暂停
+menu_play_stop = 停止
+menu_next_frame = 下一帧
+menu_previous_frame = 上一帧
+menu_app_cmd_args_info = 命令行参数...
+menu_app_usage_docs = 使用说明文档
+menu_app_website = 官网
+menu_app_forum = 论坛
+menu_app_bug_tracker = 报错
+menu_app_about = 关于
+help_desc_app_about = 本程序由Simeon Kosnitsky编写并根据公共领域许可证发布。;;该程序的主要功能是从视频中提取硬字幕：;;1) 自动检测视频中带有硬字幕的帧，并保存有关时间轴位置的信息；;;2) 生成清除背景的文本图片，使用OCR程序(如FineReader或Subtitle Edit)生成带有原始文本和时间轴的完整字幕。;;(中文翻译：Cronus、Shijie，QQ交流群：1161766056)
+help_desc_app_about_dev_contact = Email:
+help_desc_app_about_dev_contact = 如想反馈错误并获得更快的支持,请通过以下方式与我联系:
+help_desc_app_about_dev_donate = 捐赠链接:
+help_desc_for_clear_dirs = Clear Folders (remove all images), performed before any other steps
+help_desc_for_run_search = Run Search (find frames with hardcoded text (hardsub) on video)
+help_desc_for_join_images = Join TXT/RGBImages (TXT/RGBImages->ImagesJoined)
+help_desc_for_create_cleared_text_images = Create Cleared Text Images
+help_desc_for_create_empty_sub = Create Empty Sub With Provided Output File Name (*.ass or *.srt)
+help_desc_for_create_sub_from_cleared_txt_images = Create Sub From Cleared TXT Images With Provided Output File Name (*.ass or *.srt)
+help_desc_for_create_sub_from_txt_results = Create Sub From TXT Results With Provided Output File Name (*.ass or *.srt)
+help_desc_for_input_video = input video file
+help_desc_for_open_video_opencv = open video by OpenCV (default)
+help_desc_for_open_video_ffmpeg = open video by FFMPEG
+help_desc_for_use_cuda = use cuda
+help_desc_for_start_time = start time, default = 0:00:00:000 (in format hour:min:sec:milisec)
+help_desc_for_end_time = end time, default = video length
+help_desc_for_top_video_image_percent_end = top video image percent offset from image bottom, can be in range [0.0,1.0], default = 1.0
+help_desc_for_bottom_video_image_percent_end = bottom video image percent offset from image bottom, can be in range [0.0,1.0], default = 0.0
+help_desc_for_left_video_image_percent_end = left video image percent end, can be in range [0.0,1.0], default = 0.0
+help_desc_for_right_video_image_percent_end = right video image percent end, can be in range [0.0,1.0], default = 1.0
+help_desc_for_output_dir = output dir (root directory where results will be stored)
+help_desc_for_general_settings = general settings (path to general settings *.cfg file, default = settings/general.cfg)
+help_desc_for_num_threads = number of threads used for Run Search
+help_desc_for_num_ocr_threads = number of threads used for Create Cleared TXT Images
+help_desc_for_help = show this help message;;Example of usage:;VideoSubFinderWXW.exe -c -r -ccti -i "C:\test_video.mp4" -cscti "C:\test_video.srt" -o "C:\ResultsDir" -te 0.5 -be 0.1 -le 0.1 -re 0.9 -s 0:00:05:300 -e 0:00:13:100
+button_clear_folders_text = 清空所有图片
+button_run_search_text = 开始识别
+button_run_search_stop_text = 停止识别
+button_test_text = 测试
+test_result_after_first_filtration_label = 第一次过滤
+test_result_after_second_filtration_label = 第二次过滤
+test_result_after_third_filtration_label = 第三次过滤
+test_result_nedges_points_image_label = NEdges Points Image
+test_result_cleared_text_image_label = 二值化图片
+grid_col_property_label = 属性
+grid_col_value_label = 参数
+label_begin_time = 开始时间:
+label_end_time = 结束时间:
+video_box_title = 视频预览
+image_box_title = 图片预览
+search_panel_title = 识别
+settings_panel_title = 设置
+ocr_panel_title = OCR
+label_text_alignment = 文本对齐方式
+ocr_label_msd_text = 字幕最小长度
+ocr_label_jsact_text = 生成字幕时合并相邻时间轴内容相同的行
+ocr_label_clear_txt_folders = 运行之前清理文本文件夹;(TXTImages/ImagesJoined/TXTResults)
+ocr_button_ccti_text = 生成二值化文本图片(RGBImages->TXTImages)
+ocr_button_ccti_stop_text = 停止二值化文本图片
+ocr_button_csftr_text = 根据文本生成字幕(TXTResults->Sub)
+ocr_button_cesfcti_text = 根据二值化文本图片生成只有时间轴的字幕(TXTImages->Sub)
+ocr_button_ces_text = 根据原始视频图片生成只有时间轴的字幕(RGBImages->Sub)
+ocr_button_join_text = 拼合图片(TXT/RGBImages->ImagesJoined)
+ocr_button_join_stop_text = 停止拼合图片
+ocr_button_test_text = 测试
+ocr_label_save_each_substring_separately = 拆分双行字幕
+ocr_label_save_scaled_images = 保存缩放后的图片
+ssp_label_parameters_influencing_image_processing = 影响图片处理的参数
+ssp_label_ocl_and_multiframe_image_stream_processing = OCR和多帧图片处理
+ssp_oi_group_global_image_processing_settings = 全局图片处理设置
+ssp_oi_property_use_ocl = 使用OpenCV的OCL模块
+ssp_oi_property_use_cuda_gpu = 使用显卡(CUDA)加速
+ssp_oi_property_image_scale_for_clear_image = 二值化图片缩放倍数 
+ssp_oi_property_cpu_kmeans_initial_loop_iterations = CPU kmeans initial loop iterations 
+ssp_oi_property_cpu_kmeans_loop_iterations = CPU kmeans loop iterations 
+ssp_oi_property_cuda_kmeans_initial_loop_iterations = CUDA kmeans initial loop iterations 
+ssp_oi_property_cuda_kmeans_loop_iterations = CUDA kmeans loop iterations 
+ssp_oi_property_generate_cleared_text_images_on_test = 点击测试按钮时生成二值化文本图片
+ssp_oi_property_dump_debug_images = 转储测试图片
+ssp_oi_property_dump_debug_second_filtration_images = 转储测试二次过滤图片
+ssp_oi_property_clear_test_images_folder = 清理DebugImages文件夹
+ssp_oi_property_show_transformed_images_only = 仅显示转换后的图片
+ssp_oi_group_initial_image_processing = 图片初次处理
+ssp_oi_sub_group_settings_for_sobel_operators = 索贝尔(Sobel)算子设置
+ssp_oi_property_moderate_threshold = 限制阈值 
+ssp_oi_property_moderate_nedges_threshold = NEdges限制阈值 
+ssp_oi_sub_group_settings_for_color_filtering = 颜色过滤设置
+ssp_oi_property_segment_width = 线段宽度 
+ssp_oi_property_min_segments_count = 最小分段计数  
+ssp_oi_property_min_sum_color_difference = 颜色容差 
+ssp_oi_group_secondary_image_processing = 图片二次处理
+ssp_oi_sub_group_settings_for_linear_filtering = 线性过滤设置
+ssp_oi_property_line_height = 线段高度 
+ssp_oi_property_max_between_text_distance = 文本之间的最大距离  
+ssp_oi_property_max_text_center_offset = 最大文本偏移 
+ssp_oi_property_max_text_center_percent_offset = 最大文本中心偏移百分比
+ssp_oi_sub_group_settings_for_color_border_points = 颜色边界点设置
+ssp_oi_property_min_points_number = 最小点数
+ssp_oi_property_min_points_density = 最小点密度
+ssp_oi_property_min_symbol_height = 最小字符高度 (在整张图片高度中的占比) 
+ssp_oi_property_min_symbol_density = 最小字符密度 (按其大小的占比)
+ssp_oi_property_min_vedges_points_density = 最小VEdges点密度 
+ssp_oi_property_min_nedges_points_density = 最小NEdges点密度 
+ssp_oi_property_min_sum_multiple_color_difference = 多重容差 
+ssp_oi_group_tertiary_image_processing = 图片三次处理 
+ssp_oi_property_min_vedges_points_density_per_half_line = Min VEdges points density (per half line) 
+ssp_oi_property_min_hedges_points_density_per_half_line = Min HEdges points density (per half line) 
+ssp_oi_property_min_nedges_points_density_per_half_line = Min NEdges points density (per half line) 
+ssp_oim_group_ocr_settings = OCR设置
+ssp_oim_property_clear_images_logical = 二值化图片多余字符处理(请勿用于象形文字或阿拉伯语)
+ssp_oim_property_clear_rgbimages_after_search_subtitles = 识别字幕后自动二值化 
+ssp_oim_property_using_isaimages_for_getting_txt_areas = 使用交叉字幕区域(ISAImages)获取文本图片 
+ssp_oim_property_using_ilaimages_for_getting_txt_areas = 使用相交亮度区域(ILAImages)获取文本图片 
+label_ILA_images_for_getting_txt_symbols_areas = 使用相交亮度区域(ILAImages)获取字符图片 
+label_use_ILA_images_before_clear_txt_images_from_borders = 在二值化图片前根据字幕边线使用相交亮度区域(ILAImages) 
+ssp_oim_property_validate_and_compare_cleared_txt_images = (未实现) 验证和对比二值化图片 
+ssp_oim_property_dont_delete_unrecognized_images_first = 不删除无法识别的图片 (初次识别) 
+ssp_oim_property_dont_delete_unrecognized_images_second = 不删除无法识别的图片 (二次识别) 
+ssp_oim_property_default_string_for_empty_sub = 生成仅包含时间轴的字幕时默认字符串 
+ssp_oim_group_settings_for_multiframe_image_processing = 多帧图片处理设置
+ssp_oim_sub_group_settings_for_sub_detection = 字幕识别设置
+ssp_oim_property_threads = 多线程 (识别视频) 
+ssp_ocr_threads = 多线程 (生成二值化文本图片) 
+ssp_oim_property_sub_frames_length = 字幕持续的最小帧数 
+ssp_oim_property_use_ILA_images_for_search_subtitles = 使用相交亮度区域(ILAImages)
+ssp_oim_property_use_ISA_images_for_search_subtitles = 使用交叉字幕区域(ISAImages)
+ssp_oim_property_replace_ISA_by_filtered_version = 使用过滤的版本替代交叉字幕区域(ISAImages)
+ssp_oim_property_max_dl_down = Max luminance diff from down for IL image generation
+ssp_oim_property_max_dl_up = Max luminance diff from up for IL image generation
+ssp_oim_sub_group_settings_for_comparing_subs = 字幕对比设置;(该参数影响时间轴切分，值越高，时间轴分割的越少；值越低，时间轴分割的越多)
+ssp_oim_property_vedges_points_line_error = VEdges Points line error 
+ssp_oim_property_ila_points_line_error = ILA Points line error 
+ssp_oim_sub_group_settings_for_checking_sub = 字幕校验设置
+ssp_oim_property_text_percent = 文本百分比  
+ssp_oim_property_min_text_length = 最小文本长度  
+ssp_oim_property_use_gradient_images_for_clear_txt_images = 二值化时使用渐变检测
+ssp_oim_property_use_ILA_images_for_clear_txt_images = 二值化时使用相交亮度区域(ILAImages)
+ssp_oim_property_clear_txt_images_by_main_color = 按选取的主要颜色二值化图片 
+ssp_oi_property_moderate_threshold_for_scaled_image = 缩放图片的限制阈值
+ssp_oim_property_remove_wide_symbols = 移除过宽的字符(请勿用于阿拉伯语和手写文字)
+ssp_hw_device = FFMPEG硬件加速
+label_filter_descr = FFMPEG视频滤镜
+label_settings_file = 当前设置文件
+label_playback_sound = 任务完成后播放提示音
+label_border_is_darker = 字幕深色描边(字幕有边线时使用)
+label_extend_by_grey_color = 灰度扩展(在字幕亮度不稳定的时候使用)
+label_allow_min_luminance = 允许的最低亮度(仅在灰度扩展选项下生效)
+ssp_oim_sub_group_settings_for_update_video_color = 视频动态颜色设置
+label_video_contrast = 对比度(Video Contrast)
+label_video_gamma = 伽马(Video Gamma)
+label_pixel_color = 颜色预览;(在视频预览框中单击鼠标左键吸取)
+label_use_filter_color = 字幕颜色滤镜;(使用 'Ctrl+Enter' 换行);(按住键盘的'T'/'R'/'Y'/'U'可在视频预览框中放大查看)
+label_use_outline_filter_color = 字幕描边滤镜;(使用 'Ctrl+Enter' 换行);(按住键盘的'T'/'R'/'I'/'U'可在视频预览框中放大查看)
+label_dL_color = RGB和Lab颜色滤镜的dL默认值
+label_dA_color = RGB和Lab颜色滤镜的dA默认值
+label_dB_color = RGB和Lab颜色滤镜的dB默认值
+label_combine_to_single_cluster = 合并到单个集群(可用于单行中有多种颜色的情况)
\ No newline at end of file
diff --git a/backend/subfinder/macos/settings/Localization/eng/locale.cfg b/backend/subfinder/macos/settings/Localization/eng/locale.cfg
new file mode 100644
index 0000000..78665b2
--- /dev/null
+++ b/backend/subfinder/macos/settings/Localization/eng/locale.cfg
@@ -0,0 +1,220 @@
+help_desc_hotkeys_for_video_box = Video Box hotkeys:;;Hotkeys For Color Filters:;Press and hold 'U' keyboard button: will show original video frame in full screen.;Press and hold 'R' keyboard button: will show original video frame filtered by;all Color Filters in case of "Run Search" version (which extend inline/outline pixels area).;Press and hold 'T' keyboard button: will show:;* - all pixels which are in inline Color Filters will be shown as 'red';(pixels related to searched symbols);* - all pixels which are in outline Color Filters will be shown as 'green';(pixels related to searched symbols borders);* - all pixels which are in inline and outline Color Filters will be shown as 'yellow';(better that no one will be in yellow (no intersection));Press and hold 'Y' keyboard button: will show pixels related to;inline color with their original colors, all others with black (or white) color.;Press and hold 'I' keyboard button: will show pixels related to;outline color with their original colors, all others with black (or white) color.;;Hotkeys For Video Navigation:;Press 'Left', 'Right' keyboard buttons or use "Mouse Wheel" for navigate to previous or next video frames.;Press 'Space' for Play or Pause video.;;Hotkeys For Set Begin/End Video Time For "Run Search":;Use 'Ctrl+Z' for set begin time;Use 'Ctrl+X' for set end time
+help_desc_hotkeys_for_image_box = Image Box hotkeys:;Press and hold 'U' keyboard button: will show image in full screen.;Press 'Left', 'Right' keyboard buttons or use "Mouse Wheel" will allow to;change showed image type produced by "Test" button.
+ocr_dg_sub_group_settings_for_create_txt_images = Settings For Create Cleared TXTImages (RGBImages->TXTImages)
+ocr_dg_sub_group_settings_for_join_images = Settings For Join TXT/RGBImages;(TXT/RGBImages->ImagesJoined->"TXTResults/join_txt_results.txt")
+ocr_dg_sub_group_settings_for_create_sub = Settings For Create Sub
+ocr_label_join_images_join_rgb_images = Join RGBImages (otherwise TXTImages)
+ocr_label_join_images_use_txt_images_data_for_join_rgb_images = Use TXTImages Info For Join RGBImages
+ocr_label_join_images_clear_dir = Clear ImagesJoined Before Run
+ocr_label_join_images_split_line_text = Join Images Split Line Text
+ocr_label_join_images_split_line_font_size = Join Images Split Line Font Size
+ocr_label_join_images_split_line_font_bold = Join Images Split Line Font Bold
+ocr_label_join_images_sub_id_format = Format For Generate [sub_id]
+ocr_label_join_images_sub_search_by_id_format = Format For Search Subtitle Data By [sub_id] In "TXTResults/join_txt_results.txt"
+ocr_label_join_images_scale = Join Images Scale (From Original RGBImages Size)
+ocr_label_join_images_max_number = Join Images Max Number
+menu_fonts = Fonts
+fd_main_font_gb_label = Main Font
+fd_buttons_font_gb_label = Buttons Font
+fd_font_size = Font Size:
+fd_font_name = Font Name:
+fd_font_bold = Bold
+fd_font_italic = Italic
+fd_font_underline = Underline
+text_alignment_center = Center
+text_alignment_left = Left
+text_alignment_right = Right
+text_alignment_any = Any
+run_search_progress_format_string = progress: %s eta : %s run_time : %s   |   %s%s
+ccti_start_progress_format_string = progress: 0%%   |   0 : %.5d
+ccti_progress_format_string = progress: %%%2.2f eta : %s run_time : %s   |   %.5d : %.5d
+file_dialog_title_open_video_file = Open Video File
+file_dialog_title_open_video_file_wild_card = Video Files (%s)|%s|All Files (*.*)|*.*
+file_dialog_title_open_settings_file = Open Settings File
+file_dialog_title_open_settings_file_wild_card = *.cfg
+file_dialog_title_save_settings_file = Save Settings File
+file_dialog_title_save_settings_file_wild_card = Settings Files (*.cfg)|*.cfg
+file_dialog_title_save_subtitle_as = Save subtitle as...
+file_dialog_title_save_subtitle_as_wild_card = SubRip(*.srt)|*.srt|Advanced Sub Station Alpha(*.ass)|*.ass|All Files (*.*)|*.*
+menu_file = &File
+menu_edit = &Edit
+menu_view = &View
+menu_play = &Play
+menu_help = &Help
+menu_localization = Localization
+menu_setpriority = Set Priority
+menu_setpriority_high = HIGH
+menu_setpriority_abovenormal = ABOVE NORMAL
+menu_setpriority_normal = NORMAL
+menu_setpriority_belownormal = BELOW NORMAL
+menu_setpriority_idle = IDLE
+menu_file_open_video_opencv = Open Video (OpenCV)
+menu_file_open_video_ffmpeg = Open Video (FFMPEG)
+menu_file_reopenvideo = Reopen Video
+menu_file_openpreviousvideo = Open Or Continue Previous Video
+menu_file_savesettings = Save Settings
+menu_file_savesettingsas = Save Settings As...
+menu_file_loadsettings = Load Settings...
+menu_file_exit = E&xit
+menu_edit_setbegintime = Set Begin Time
+menu_edit_setendtime = Set End Time
+menu_scale_text_size_inc = Scale Text Size +
+menu_scale_text_size_dec = Scale Text Size -
+menu_play_pause = Play/Pause
+menu_play_stop = Stop
+menu_next_frame = Next Frame
+menu_previous_frame = Previous Frame
+menu_app_cmd_args_info = Command Line Arguments...
+menu_app_usage_docs = Usage Documentation
+menu_app_website = Website
+menu_app_forum = Forum
+menu_app_bug_tracker = Bug Tracker
+menu_app_about = About
+help_desc_app_about = This program was written by Simeon Kosnitsky and published under: GNU General Public License version 2.0 (GPLv2);;The main purpose of this program is to provide functionality for extract hardcoded text (hardsub) from video.;;It provides two main features:;1) Autodetection of frames with hardcoded text (hardsub) on video with saving info about timing positions.;2) Generation of cleared from background text images, which allows with usage of OCR programs (like FineReader, Subtitle Edit, Google Drive) to generate complete subtitle with original text and timing.
+help_desc_app_about_dev_email = Email:
+help_desc_app_about_dev_contact = For faster support in case of bug fixes please contact me in:
+help_desc_app_about_dev_donate = For donate you can use:
+help_desc_for_clear_dirs = Clear Folders (remove all images), performed before any other steps
+help_desc_for_run_search = Run Search (find frames with hardcoded text (hardsub) on video)
+help_desc_for_join_images = Join TXT/RGBImages (TXT/RGBImages->ImagesJoined)
+help_desc_for_create_cleared_text_images = Create Cleared Text Images
+help_desc_for_create_empty_sub = Create Empty Sub With Provided Output File Name (*.ass or *.srt)
+help_desc_for_create_sub_from_cleared_txt_images = Create Sub From Cleared TXT Images With Provided Output File Name (*.ass or *.srt)
+help_desc_for_create_sub_from_txt_results = Create Sub From TXT Results With Provided Output File Name (*.ass or *.srt)
+help_desc_for_input_video = input video file
+help_desc_for_open_video_opencv = open video by OpenCV (default)
+help_desc_for_open_video_ffmpeg = open video by FFMPEG
+help_desc_for_use_cuda = use cuda
+help_desc_for_start_time = start time, default = 0:00:00:000 (in format hour:min:sec:millisec)
+help_desc_for_end_time = end time, default = video length
+help_desc_for_top_video_image_percent_end = top video image percent offset from image bottom, can be in range [0.0,1.0], default = 1.0
+help_desc_for_bottom_video_image_percent_end = bottom video image percent offset from image bottom, can be in range [0.0,1.0], default = 0.0
+help_desc_for_left_video_image_percent_end = left video image percent end, can be in range [0.0,1.0], default = 0.0
+help_desc_for_right_video_image_percent_end = right video image percent end, can be in range [0.0,1.0], default = 1.0
+help_desc_for_output_dir = output dir (root directory where results will be stored)
+help_desc_for_general_settings = general settings (path to general settings *.cfg file, default = settings/general.cfg)
+help_desc_for_num_threads = number of threads used for Run Search
+help_desc_for_num_ocr_threads = number of threads used for Create Cleared TXT Images
+help_desc_for_help = show this help message;;Example of usage:;VideoSubFinderWXW.exe -c -r -ccti -i "C:\test_video.mp4" -cscti "C:\test_video.srt" -o "C:\ResultsDir" -te 0.5 -be 0.1 -le 0.1 -re 0.9 -s 0:00:05:300 -e 0:00:13:100;;You can also modify any setting from general.cfg through command line by using it's name:
+button_clear_folders_text = Clear Folders
+button_run_search_text = Run Search
+button_run_search_stop_text = Stop Run Search
+button_test_text = Test
+test_result_after_first_filtration_label = After First Filtration
+test_result_after_second_filtration_label = After Second Filtration
+test_result_after_third_filtration_label = After Third Filtration
+test_result_nedges_points_image_label = NEdges Points Image
+test_result_cleared_text_image_label = Cleared Text Image
+grid_col_property_label = Property
+grid_col_value_label = Value
+label_begin_time = Begin Time:
+label_end_time = End Time:
+video_box_title = Video Box
+image_box_title = Image Box
+search_panel_title = Search
+settings_panel_title = Settings
+ocr_panel_title = OCR
+label_text_alignment = Text Alignment
+ocr_label_msd_text = Min Sub Duration In Seconds
+ocr_label_jsact_text = Join Subs And Correct Time
+ocr_label_clear_txt_folders = Clear TXT Folders Before Run;(TXTImages/ImagesJoined/TXTResults)
+ocr_button_ccti_text = Create Cleared Text Images (RGBImages->TXTImages)
+ocr_button_ccti_stop_text = Stop Create Cleared Text Images
+ocr_button_csftr_text = Create Sub From Text Results (TXTResults->Sub)
+ocr_button_cesfcti_text = Create Empty Sub From Cleared Text Images (TXTImages->Sub)
+ocr_button_ces_text = Create Empty Sub From Found Video Frames With Text (RGBImages->Sub)
+ocr_button_join_text = Join TXT/RGBImages (TXT/RGBImages->ImagesJoined)
+ocr_button_join_stop_text = Stop Join TXT/RGBImages
+ocr_button_test_text = Test
+ocr_label_save_each_substring_separately = Save Each Substring Separately
+ocr_label_save_scaled_images = Save Scaled Images
+ssp_label_parameters_influencing_image_processing = Parameters Influencing Image Processing
+ssp_label_ocl_and_multiframe_image_stream_processing = OCR and Multiframe Image Stream Processing
+ssp_oi_group_global_image_processing_settings = Global Image Processing Settings
+ssp_oi_property_use_ocl = Use OCL In OpenCV
+ssp_oi_property_use_cuda_gpu = Use CUDA GPU Acceleration
+ssp_oi_property_image_scale_for_clear_image = Image Scale For Clear Image
+ssp_oi_property_cpu_kmeans_initial_loop_iterations = CPU kmeans initial loop iterations
+ssp_oi_property_cpu_kmeans_loop_iterations = CPU kmeans loop iterations
+ssp_oi_property_cuda_kmeans_initial_loop_iterations = CUDA kmeans initial loop iterations
+ssp_oi_property_cuda_kmeans_loop_iterations = CUDA kmeans loop iterations
+ssp_oi_property_generate_cleared_text_images_on_test = Generate Cleared Text Images On Test Button
+ssp_oi_property_dump_debug_images = Dump Debug Images
+ssp_oi_property_dump_debug_second_filtration_images = Dump Debug Secondary Processing Images
+ssp_oi_property_clear_test_images_folder = Clear Debug Images Folder (DebugImages)
+ssp_oi_property_show_transformed_images_only = Show Transformed Images Only
+ssp_oi_group_initial_image_processing = Initial Image Processing
+ssp_oi_sub_group_settings_for_sobel_operators = Settings For Sobel Operators
+ssp_oi_property_moderate_threshold = Moderate Threshold
+ssp_oi_property_moderate_nedges_threshold = Moderate NEdges Threshold
+ssp_oi_sub_group_settings_for_color_filtering = Settings For Color Filtering
+ssp_oi_property_segment_width = Line Segment Width
+ssp_oi_property_min_segments_count = Min Segments Count
+ssp_oi_property_min_sum_color_difference = Min Sum Color Difference
+ssp_oi_group_secondary_image_processing = Secondary Image Processing
+ssp_oi_sub_group_settings_for_linear_filtering = Settings For Linear Filtering
+ssp_oi_property_line_height = Line Segment Height
+ssp_oi_property_max_between_text_distance = Max Between Text Distance
+ssp_oi_property_max_text_center_offset = Max Text Offset
+ssp_oi_property_max_text_center_percent_offset = Max Text Center Percent Offset
+ssp_oi_sub_group_settings_for_color_border_points = Settings For Color Border Points
+ssp_oi_property_min_points_number = Min Points Number
+ssp_oi_property_min_points_density = Min Points Density
+ssp_oi_property_min_symbol_height = Min Symbol Height (in % to Full Image Height)
+ssp_oi_property_min_symbol_density = Min Symbol Density (in % to Its Size)
+ssp_oi_property_min_vedges_points_density = Min VEdges points density
+ssp_oi_property_min_nedges_points_density = Min NEdges points density
+ssp_oi_property_min_sum_multiple_color_difference = Min Sum Multiple Color Difference
+ssp_oi_group_tertiary_image_processing = Tertiary Image Processing
+ssp_oi_property_min_vedges_points_density_per_half_line = Min VEdges points density (per half line)
+ssp_oi_property_min_hedges_points_density_per_half_line = Min HEdges points density (per half line)
+ssp_oi_property_min_nedges_points_density_per_half_line = Min NEdges points density (per half line)
+ssp_oim_group_ocr_settings = OCR settings
+ssp_oim_property_clear_images_logical = Clear Images Logical;(don't use on Hieroglyph or Arabic subs)
+ssp_oim_property_clear_rgbimages_after_search_subtitles = Clear RGBImages after search subtitles
+ssp_oim_property_using_isaimages_for_getting_txt_areas = Use ISAImages for getting TXT areas
+ssp_oim_property_using_ilaimages_for_getting_txt_areas = Use ILAImages for getting TXT areas
+label_ILA_images_for_getting_txt_symbols_areas = Use ILAImages for getting TXT symbols areas
+label_use_ILA_images_before_clear_txt_images_from_borders = Use ILAImages before clear TXT images from borders
+ssp_oim_property_validate_and_compare_cleared_txt_images = (NotRealized) Validate And Compare Cleared TXTImages
+ssp_oim_property_dont_delete_unrecognized_images_first = Don't Delete Unrecognized Images (First)
+ssp_oim_property_dont_delete_unrecognized_images_second = Don't Delete Unrecognized Images (Second)
+ssp_oim_property_default_string_for_empty_sub = Default string for empty sub
+ssp_oim_group_settings_for_multiframe_image_processing = Settings For Multi-Frame Image Processing
+ssp_oim_sub_group_settings_for_sub_detection = Settings For Sub Detection
+ssp_oim_property_threads = Number Of Parallel Tasks;(For Run Search)
+ssp_ocr_threads = Number Of Parallel Tasks;(For Create Cleared TXTImages)
+ssp_oim_property_sub_frames_length = Sub Frames Length
+ssp_oim_property_use_ILA_images_for_search_subtitles = Use ILAImages for search subtitles
+ssp_oim_property_use_ISA_images_for_search_subtitles = Analyze ISAImages for sub presence
+ssp_oim_property_replace_ISA_by_filtered_version = Replace ISAImages by filtered version
+ssp_oim_property_max_dl_down = Max luminance diff from down for IL image generation
+ssp_oim_property_max_dl_up = Max luminance diff from up for IL image generation
+ssp_oim_sub_group_settings_for_comparing_subs = Settings For Comparing Subs
+ssp_oim_property_vedges_points_line_error = VEdges Points line error
+ssp_oim_property_ila_points_line_error = ILA Points line error
+ssp_oim_sub_group_settings_for_checking_sub = Settings For Checking Sub
+ssp_oim_property_text_percent = Text Percent
+ssp_oim_property_min_text_length = Min Text Length
+ssp_oim_property_use_gradient_images_for_clear_txt_images = Use Gradient Images For Clear TXTImages
+ssp_oim_property_use_ILA_images_for_clear_txt_images = Use ILAImages For Clear TXTImages
+ssp_oim_property_clear_txt_images_by_main_color = Clear TXTImages By Main Color
+ssp_oi_property_moderate_threshold_for_scaled_image = Moderate Threshold For Scaled Image
+ssp_oim_property_remove_wide_symbols = Remove too wide symbols;(don't use for Arabic or handwritten subs)
+ssp_hw_device = FFMPEG HW Devices
+label_filter_descr = FFMPEG Video Filters
+label_settings_file = Current Settings File
+label_playback_sound = Playback Sound On Task Finished
+label_border_is_darker = Characters Border Is Darker
+label_extend_by_grey_color = Extend By Grey Color;(try to use in case of subs with unstable luminance)
+label_allow_min_luminance = Allow Min Luminance;(used only if "Extend By Grey Color" is set)
+ssp_oim_sub_group_settings_for_update_video_color = Settings For Update Video Color
+label_video_contrast = Video Contrast
+label_video_gamma = Video Gamma
+label_pixel_color = Pixel Color;(By 'Left Mouse Click' in Video Box)
+label_use_filter_color = Use Filter Colors (For Find Text);(Use 'Ctrl+Enter' for add New Line);(Press and hold 'T'/'R'/'Y'/'U' button in Video Box for check)
+label_use_outline_filter_color = Use Outline Filter Colors (For Find Text Borders/Outlines);(Use 'Ctrl+Enter' for add New Line);(Press and hold 'T'/'R'/'I'/'U' button in Video Box for check)
+label_dL_color = default dL For RGB and Lab Filter Colors
+label_dA_color = default dA For Lab Filter Colors
+label_dB_color = default dB For Lab Filter Colors
+label_combine_to_single_cluster = Combine To Single Cluster;(can be used in case of multiple colors in single line)
diff --git a/backend/subfinder/macos/settings/Localization/rus/locale.cfg b/backend/subfinder/macos/settings/Localization/rus/locale.cfg
new file mode 100644
index 0000000..ca0b23d
--- /dev/null
+++ b/backend/subfinder/macos/settings/Localization/rus/locale.cfg
@@ -0,0 +1,220 @@
+help_desc_hotkeys_for_video_box = Горячие Клавиши Для Видео Окна:;;Горячие Клавиши Для Цветовой Фильтрации:;Нажмите и удерживайте кнопку 'U' на клавиатуре: покажет исходный видеокадр в полноэкранном режиме.;Нажмите и удерживайте кнопку 'R' на клавиатуре: покажет видеокадр отфильтрованный всеми Цветовыми Фильтрами в случаи использования;"Запустить Поиск" (который расширяет области основных и контурных (границы текста) текстовых пикселей соответствующих цветовым фильтрам).;Нажмите и удерживайте кнопку 'T' на клавиатуре: покажет:;* - все пиксели находящиеся в (Основных) Цветовых Фильтрах, будут отображаться как 'красные';(пиксели, относящиеся к искомым символам);* - все пиксели находящиеся в Контурных Цветовых Фильтрах (границы текста), будут отображаться как 'зеленые';(пиксели, относящиеся к границам искомых символов);* - все пиксели которые находятся одновременно в Основных и Контурных Цветовых Фильтрах, будут отображаться как 'желтые';(лучше чтобы таких пикселей совсем не было (без пересечений)).;Нажмите и удерживайте кнопку 'Y' на клавиатуре: покажет все пиксели находящиеся в;(Основных) Цветовых Фильтрах с их оригинальным цветом, все остальные чёрным (или белым) цветом.;Нажмите и удерживайте кнопку 'I' на клавиатуре: покажет все пиксели находящиеся в;Контурных Цветовых Фильтрах с их оригинальным цветом, все остальные чёрным (или белым) цветом.;;Горячие клавиши для навигации по видео:;Нажимайте кнопки 'Влево', 'Вправо' на клавиатуре или используйте 'Колесо мыши' для перехода к предыдущему или следующему видеокадру;Нажмите 'Пробел' чтобы воспроизвести или приостановить видео.;;Горячие клавиши для установки времени начала/окончания видео для "Запустить Поиск":;Используйте 'Ctrl+Z' для установки времени начала;Используйте 'Ctrl+X' для установки времени окончания
+help_desc_hotkeys_for_image_box = Горячие Клавиши Для Окна Результата:;Нажмите и удерживайте кнопку 'U' на клавиатуре: покажет изображение в полноэкранном режиме.;Нажатие кнопок 'Влево', 'Вправо' на клавиатуре или использование 'Колесика мыши' позволит;изменить тип отображаемого изображения, создаваемого кнопкой 'Тест'.
+ocr_dg_sub_group_settings_for_create_txt_images = Настройки Для Создания TXTImages (RGBImages->TXTImages)
+ocr_dg_sub_group_settings_for_join_images = Настройки Для Объединения TXT/RGBImages;(TXT/RGBImages->ImagesJoined->"TXTResults/join_txt_results.txt")
+ocr_dg_sub_group_settings_for_create_sub = Настройки Для Создания Субтитров
+ocr_label_join_images_join_rgb_images = Объединять RGBImages (иначе TXTImages)
+ocr_label_join_images_use_txt_images_data_for_join_rgb_images = Использовать Информацию Из TXTImages При Объединении RGBImages
+ocr_label_join_images_clear_dir = Очищать ImagesJoined Папку Перед Запуском
+ocr_label_join_images_split_line_text = Разделительная Строка При Объединении Изображений
+ocr_label_join_images_split_line_font_size = Размер Шрифта В Разделительной Строке
+ocr_label_join_images_split_line_font_bold = Жирный Шрифт В Разделительной Строке
+ocr_label_join_images_sub_id_format = Формат Для Создания [sub_id] В Разделительной Строке
+ocr_label_join_images_sub_search_by_id_format = Формат Для Поиска Данных Субтитра По [sub_id] В "TXTResults/join_txt_results.txt"
+ocr_label_join_images_scale = Увеличение Изображений В ImagesJoined Относительно Исходных Размеров В RGBImages
+ocr_label_join_images_max_number = Максимальное Количество Объединяемых Изображений В ImagesJoined
+menu_fonts = Шрифты
+fd_main_font_gb_label = Основной Шрифт
+fd_buttons_font_gb_label = Шрифт Для Кнопок
+fd_font_size = Размер Шрифта:
+fd_font_name = Название Шрифта:
+fd_font_bold = Жирный
+fd_font_italic = Курсив
+fd_font_underline = Подчёркнутый
+text_alignment_center = По Центру
+text_alignment_left = Слева
+text_alignment_right = Справо
+text_alignment_any = Любое
+run_search_progress_format_string = прогресс: %s осталось : %s прошло : %s   |   %s%s
+ccti_start_progress_format_string = прогресс: 0%%   |   0 : %.5d
+ccti_progress_format_string = прогресс: %%%2.2f осталось : %s прошло : %s   |   %.5d : %.5d
+file_dialog_title_open_video_file = Открыть Видеофайл
+file_dialog_title_open_video_file_wild_card = Видеофайлы (%s)|%s|Все Файлы (*.*)|*.*
+file_dialog_title_open_settings_file = Открыть Файл Настроек
+file_dialog_title_open_settings_file_wild_card = *.cfg
+file_dialog_title_save_settings_file = Сохранить Файл Настроек
+file_dialog_title_save_settings_file_wild_card = Файлы Настроек (*.cfg)|*.cfg
+file_dialog_title_save_subtitle_as = Сохранить субтитры как...
+file_dialog_title_save_subtitle_as_wild_card = SubRip(*.srt)|*.srt|Advanced Sub Station Alpha(*.ass)|*.ass|Все Файлы (*.*)|*.*
+menu_file = &Файл
+menu_edit = &Правка
+menu_view = &Вид
+menu_play = &Видео
+menu_help = &Помощь
+menu_localization = Локализация
+menu_setpriority = Установить Приоритет
+menu_setpriority_high = ВЫСОКИЙ
+menu_setpriority_abovenormal = ВЫШЕ НОРМАЛЬНОГО
+menu_setpriority_normal = НОРМАЛЬНЫЙ
+menu_setpriority_belownormal = НИЖЕ НОРМАЛЬНОГО
+menu_setpriority_idle = НИЗКИЙ
+menu_file_open_video_opencv = Открыть Видео (OpenCV)
+menu_file_open_video_ffmpeg = Открыть Видео (FFMPEG)
+menu_file_reopenvideo = Переоткрыть Последнее Видео
+menu_file_openpreviousvideo = Открыть Видео С Прошлого Запуска
+menu_file_savesettings = Сохранить Настройки
+menu_file_savesettingsas = Сохранить Настройки Как...
+menu_file_loadsettings = Загрузить Настройки...
+menu_file_exit = &Выход
+menu_edit_setbegintime = Установить Время Начала
+menu_edit_setendtime = Установить Время Окончания
+menu_scale_text_size_inc = Увеличить Размер Текста +
+menu_scale_text_size_dec = Уменьшить Размер Текста -
+menu_play_pause = Воспроизведение/Пауза
+menu_play_stop = Остановить
+menu_next_frame = Следующий Кадр
+menu_previous_frame = Предыдущий Кадр
+menu_app_cmd_args_info = Аргументы Командной Строки...
+menu_app_usage_docs = Документация По Использованию
+menu_app_website = Домашняя Страница
+menu_app_forum = Форум
+menu_app_bug_tracker = Баг-трекер
+menu_app_about = О Программе
+help_desc_app_about = Эта программа была написана Семёном Косницким и опубликована под лицензией: GNU General Public License version 2.0 (GPLv2);;Основной целью этой программы является — предоставить функциональность для извлечения наложенного текста (хардсабов) из видео.;;Она предоставляет две основные возможности:;1) Нахождение видео кадров с наложенным текстом (хардсабов) с сохранением информации о расположении по времени.;2) Генерацию очищенных от фона изображений с текстом, что позволяет с помощью программ OCR (таких как FineReader, Subtitle Edit, Google Drive) генерировать субтитры с исходным текстом и расположением по времени.
+help_desc_app_about_dev_email = Email:
+help_desc_app_about_dev_contact = Для более быстрой поддержки в случае исправления ошибок, со мной можно связаться в:
+help_desc_app_about_dev_donate = Для доната (поддержания проекта) вы можете воспользоваться:
+help_desc_for_clear_dirs = Очистить Папки (удалить все изображения), выполняется перед любыми другими шагами
+help_desc_for_run_search = Запустить Поиск (найти кадры с наложенным текстом (хардсаб) на видео)
+help_desc_for_join_images = Объединить TXT/RGBImages (TXT/RGBImages->ImagesJoined)
+help_desc_for_create_cleared_text_images = Создать Изображения С Очищенным Текстом (от фона)
+help_desc_for_create_empty_sub = Создать Субтитры Без Текста (Только Тайминг) Из Найденных Оригинальных Видео Кадров С Указанным Именем Выходного Файла (*.ass или *.srt)
+help_desc_for_create_sub_from_cleared_txt_images = Создать Субтитры Без Текста (Только Тайминг) Из Очищенных Текстовых Изображений От Фона С Указанным Именем Выходного Файла (*.ass или *.srt)
+help_desc_for_create_sub_from_txt_results = Создать Субтитры Из Полученных Текстовых Файлов С Указанным Именем Выходного Файла (*.ass или *.srt)
+help_desc_for_input_video = исходный видеофайл
+help_desc_for_open_video_opencv = открыть видео с помощью OpenCV (по умолчанию)
+help_desc_for_open_video_ffmpeg = открыть видео с помощью FFMPEG
+help_desc_for_use_cuda = использовать cuda
+help_desc_for_start_time = время начала, по умолчанию = 0:00:00:000 (в формате час:мин:сек:милисек)
+help_desc_for_end_time = время окончания, по умолчанию = продолжительность видео
+help_desc_for_top_video_image_percent_end = процентное смещение верхней границы поиска от нижнего изображения, может быть в диапазоне [0.0,1.0], по умолчанию = 1.0
+help_desc_for_bottom_video_image_percent_end = процентное смещение нижней границы поиска от нижнего края изображения, может быть в диапазоне [0.0,1.0], по умолчанию = 0.0
+help_desc_for_left_video_image_percent_end = процентное смещение левой границы поиска от левого края изображения, может быть в диапазоне [0.0,1.0], по умолчанию = 0.0
+help_desc_for_right_video_image_percent_end = процентное смещение правой границы поиска от левого края изображения, может быть в диапазоне [0.0,1.0], по умолчанию = 1.0
+help_desc_for_output_dir = путь к папке в которой будут храниться результаты
+help_desc_for_general_settings = общие настройки (путь к файлу общих настроек *.cfg, по умолчанию = settings/general.cfg)
+help_desc_for_num_threads = количество потоков, используемых для "Запуcтить Поиск"
+help_desc_for_num_ocr_threads = количество потоков, используемых для создания изображений с очищенным текстом
+help_desc_for_help = показать это справочное сообщение;;Пример использования:;VideoSubFinderWXW.exe -c -r -ccti -i "C:\test_video.mp4" -cscti "C:\test_video.srt" -o "C:\ResultsDir" -te 0.5 -be 0.1 -le 0.1 -re 0.9 -s 0:00:05:300 -e 0:00:13:100;;Вы также можете изменить любой параметр из general.cfg через командную строку используя его имя:
+button_clear_folders_text = Очистить Папки
+button_run_search_text = Запустить Поиск
+button_run_search_stop_text = Остановить Поиск
+button_test_text = Тест
+test_result_after_first_filtration_label = После Первичной Фильтрации
+test_result_after_second_filtration_label = После Вторичной Фильтрации
+test_result_after_third_filtration_label = После Третичной Фильтрации
+test_result_nedges_points_image_label = Изображение с NEdges
+test_result_cleared_text_image_label = Очищенное Текстовое Изображение
+grid_col_property_label = Свойство
+grid_col_value_label = Значение
+label_begin_time = Время Начала:
+label_end_time = Время Окончания:
+video_box_title = Видео Окно
+image_box_title = Окно Результата
+search_panel_title = Поиск
+settings_panel_title = Настройки
+ocr_panel_title = OCR
+label_text_alignment = Выравнивание Текста
+ocr_label_msd_text = Минимальная Продолжительность Субтитров
+ocr_label_jsact_text = Исправлять Время При Создании Субтитров
+ocr_label_clear_txt_folders = Очищать TXT Папки Перед Запуском;(TXTImages/ImagesJoined/TXTResults)
+ocr_button_ccti_text = Запустить Очистку Текстовых Изображения От Фона (RGBImages->TXTImages)
+ocr_button_ccti_stop_text = Остановить Очистку
+ocr_button_csftr_text = Создать Субтитры Из Полученных Текстовых Файлов (TXTResults->Субтитры)
+ocr_button_cesfcti_text = Создать Субтитры Без Текста Из TXTImages (TXTImages->Субтитры)
+ocr_button_ces_text = Создать Субтитры Без Текста Из RGBImages (RGBImages->Субтитры)
+ocr_button_join_text = Объединить TXT/RGBImages (TXT/RGBImages->ImagesJoined)
+ocr_button_join_stop_text = Остановить Объединение TXT/RGBImages
+ocr_button_test_text = Тест
+ocr_label_save_each_substring_separately = Сохранять Каждую Подстроку Субтитров Отдельно
+ocr_label_save_scaled_images = Сохранять Увеличенные Очищенные Текстовые Изображения
+ssp_label_parameters_influencing_image_processing = Параметры Влияющие На Обработку Изображения
+ssp_label_ocl_and_multiframe_image_stream_processing = OCR и Многопоточная Обработка Видео Изображений
+ssp_oi_group_global_image_processing_settings = Глобальные Настройки Обработки Изображений
+ssp_oi_property_use_ocl = Использовать OCL в OpenCV
+ssp_oi_property_use_cuda_gpu = Использовать CUDA GPU ускорение
+ssp_oi_property_image_scale_for_clear_image = Увеличение Изображений При Очистке От Фона
+ssp_oi_property_cpu_kmeans_initial_loop_iterations = количество предварительных итераций в CPU kmeans
+ssp_oi_property_cpu_kmeans_loop_iterations = количество основных итераций в CPU kmeans
+ssp_oi_property_cuda_kmeans_initial_loop_iterations = количество предварительных итераций в CUDA GPU kmeans
+ssp_oi_property_cuda_kmeans_loop_iterations = количество основных итераций в CUDA GPU kmeans
+ssp_oi_property_generate_cleared_text_images_on_test = Создавать Очищенные Текстовые Изображения При Запуске Теста
+ssp_oi_property_dump_debug_images = Сохранять Отладочные Изображения
+ssp_oi_property_dump_debug_second_filtration_images = Сохранять Отладочные Изображения При Вторичной Фильтрации
+ssp_oi_property_clear_test_images_folder = Очищать Папку С Отладочными Изображениями (DebugImages)
+ssp_oi_property_show_transformed_images_only = Показывать Только Преобразованные Изображения
+ssp_oi_group_initial_image_processing = Первичная Обработка Изображений
+ssp_oi_sub_group_settings_for_sobel_operators = Настройки Для Операторов Sobel
+ssp_oi_property_moderate_threshold = Средний Порог
+ssp_oi_property_moderate_nedges_threshold = Средний Порог Для NEdges
+ssp_oi_sub_group_settings_for_color_filtering = Настройки Для Цветовой Фильтрации
+ssp_oi_property_segment_width = Ширина Сегмента Линии
+ssp_oi_property_min_segments_count = Минимальное Количество Сегментов
+ssp_oi_property_min_sum_color_difference = Минимальная Суммарная Разница Цветов
+ssp_oi_group_secondary_image_processing = Вторичная Обработка Изображений
+ssp_oi_sub_group_settings_for_linear_filtering = Настройки Для Линейной Фильтрации
+ssp_oi_property_line_height = Высота (Толщина) Сегмента Линии
+ssp_oi_property_max_between_text_distance = Максимальное Расстояние Между Словами
+ssp_oi_property_max_text_center_offset = Максимальное Смещение Текста
+ssp_oi_property_max_text_center_percent_offset = Максимальное Смещение Текста В Процентах
+ssp_oi_sub_group_settings_for_color_border_points = Настройки Для Точек С Цветовыми Перепадами
+ssp_oi_property_min_points_number = Минимальное Количество Точек
+ssp_oi_property_min_points_density = Минимальная Плотность Точек
+ssp_oi_property_min_symbol_height = Минимальная Высота Символа (в % от Полной Высоты Видео Кадра)
+ssp_oi_property_min_symbol_density = Минимальная Плотность Символа (в % от Его Размера)
+ssp_oi_property_min_vedges_points_density = Минимальная плотность точек VEdges
+ssp_oi_property_min_nedges_points_density = Минимальная плотность точек NEdges
+ssp_oi_property_min_sum_multiple_color_difference = Минимальная Сумма Цветовых Различий
+ssp_oi_group_tertiary_image_processing = Третичная Обработка Изображений
+ssp_oi_property_min_vedges_points_density_per_half_line = Минимальная плотность точек VEdges (на половину линии)
+ssp_oi_property_min_hedges_points_density_per_half_line = Минимальная плотность точек HEdges (на половину линии)
+ssp_oi_property_min_nedges_points_density_per_half_line = Минимальная плотность точек NEdges (на половину линии)
+ssp_oim_group_ocr_settings = OCR настройки
+ssp_oim_property_clear_images_logical = Логическая Очистка Текстовых Изображений;(не используйте для иероглифов или арабских субтитров)
+ssp_oim_property_clear_rgbimages_after_search_subtitles = Очистить Текстовые Изображения после поиска субтитров
+ssp_oim_property_using_isaimages_for_getting_txt_areas = Использовать ISAImages для определения зоны расположения текста
+ssp_oim_property_using_ilaimages_for_getting_txt_areas = Использовать ILAImages для определения зоны расположения текста
+label_ILA_images_for_getting_txt_symbols_areas = Использовать ILAImages для определения зоны расположения текстовых символов
+label_use_ILA_images_before_clear_txt_images_from_borders = Использовать ILAImages перед очисткой Текстовых Изображений от границ
+ssp_oim_property_validate_and_compare_cleared_txt_images = (не реализовано) Проверка И Сравнение Очищенных Текстовых Изображений
+ssp_oim_property_dont_delete_unrecognized_images_first = Не Удалять Нераспознанные Изображения (первично)
+ssp_oim_property_dont_delete_unrecognized_images_second = Не Удалять Нераспознанные Изображения (вторично)
+ssp_oim_property_default_string_for_empty_sub = Строка по умолчанию для нераспознанного изображения
+ssp_oim_group_settings_for_multiframe_image_processing = Настройки Для Многопоточной Обработки Изображений
+ssp_oim_sub_group_settings_for_sub_detection = Настройки Для Обнаружения Субтитров
+ssp_oim_property_threads = Количество Параллельных Потоков;(Для Запуска Поиска)
+ssp_ocr_threads = Количество Параллельных Потоков;(Для Создания Очищенных Текстовых Изображений)
+ssp_oim_property_sub_frames_length = Минимальная Длительность Субтитров (В Количистве Видео Кадров)
+ssp_oim_property_use_ILA_images_for_search_subtitles = Использовать ILAImages для поиска субтитров
+ssp_oim_property_use_ISA_images_for_search_subtitles = Анализировать ISAImages на наличие субтитров
+ssp_oim_property_replace_ISA_by_filtered_version = Заменить ISAImages отфильтрованной версией
+ssp_oim_property_max_dl_down = Максимальная разница яркости снизу для создания IL-изображения
+ssp_oim_property_max_dl_up = Максимальная разница яркости сверху для создания IL-изображения
+ssp_oim_sub_group_settings_for_comparing_subs = Настройки Для Сравнения Субтитров
+ssp_oim_property_vedges_points_line_error = Допустимое Отклонение VEdges точек в линии
+ssp_oim_property_ila_points_line_error = Допустимое Отклонение ILA точек в линии
+ssp_oim_sub_group_settings_for_checking_sub = Настройки Для Проверки Субтитров
+ssp_oim_property_text_percent = Процент Текста
+ssp_oim_property_min_text_length = Минимальная Длина Текста
+ssp_oim_property_use_gradient_images_for_clear_txt_images = Использовать Градиентные Изображения Для Очистки Текстовых Изображений
+ssp_oim_property_use_ILA_images_for_clear_txt_images = Использовать ILAImages Для Очистки Текстовых Изображений
+ssp_oim_property_clear_txt_images_by_main_color = Очищать Текстовые Изображения По Основному Найденному Цвету
+ssp_oi_property_moderate_threshold_for_scaled_image = Средний Порог Для Увеличенных Изображений
+ssp_oim_property_remove_wide_symbols = Удалять слишком широкие символы;(не используйте для арабских или рукописных субтитров)
+ssp_hw_device = FFMPEG HW Устройства
+label_filter_descr = FFMPEG Видео фильтры
+label_settings_file = Текущий Файл Настроек
+label_playback_sound = Воспроизводить Звук По Завершению Задач
+label_border_is_darker = Границы Символов Темнее Цвета Символов
+label_extend_by_grey_color = Расширять по чёрно-белому представлению;(попробуйте использовать в случае субтитров с нестабильной яркостью)
+label_allow_min_luminance = Минимальная разрешённая яркость;(используется только при включенной сверху опцией)
+ssp_oim_sub_group_settings_for_update_video_color = Настройки Для Изменения Цвета В Видео
+label_video_contrast = Видео Контраст
+label_video_gamma = Видео Гамма
+label_pixel_color = Цвет Пикселя;(Щелкните Левой Кнопкой Мыши В Видео Окне)
+label_use_filter_color = Использовать (Основную) Цветовую Фильтрацию (Для Поиска Текста);(Используйте 'Ctrl+Enter', чтобы добавить новую строку);(Нажмите и удерживайте кнопку 'T'/'R'/'Y'/'U' в Видео Окне для проверки)
+label_use_outline_filter_color = Использовать Контурную Цветовую Фильтрацию (Для Поиска Границ Текста);(Используйте 'Ctrl+Enter', чтобы добавить новую строку);(Нажмите и удерживайте кнопку 'T'/'R'/'I'/'U' в Видео Окне для проверки)
+label_dL_color = dL по умолчанию для RGB и Lab цветовых фильтров
+label_dA_color = dA по умолчанию для Lab цветовых фильтров
+label_dB_color = dB по умолчанию для Lab цветовых фильтров
+label_combine_to_single_cluster = Объединять В Один Кластер;(может быть использовано в случае нескольких цветов в одной текстовой строке)
diff --git a/backend/subfinder/macos/settings/general.cfg b/backend/subfinder/macos/settings/general.cfg
new file mode 100644
index 0000000..6bd601a
--- /dev/null
+++ b/backend/subfinder/macos/settings/general.cfg
@@ -0,0 +1,127 @@
+prefered_locale = eng
+vsf_is_maximized = 0
+vsf_x = -1
+vsf_y = -1
+vsf_w = -1
+vsf_h = -1
+process_affinity_mask = -1
+main_text_font = default
+main_text_font_bold = 0
+main_text_font_italic = 0
+main_text_font_underline = 0
+main_text_font_size = -1
+buttons_text_font = default
+buttons_text_font_bold = 1
+buttons_text_font_italic = 0
+buttons_text_font_underline = 0
+buttons_text_font_size = -1
+main_text_colour = 0,0,0
+main_text_ctls_background_colour = 255,255,255
+main_buttons_colour = 252,252,252
+main_buttons_colour_focused = 242,242,242
+main_buttons_colour_selected = 211,211,211
+main_buttons_border_colour = 196,196,196
+main_labels_background_colour = 127,255,0
+main_frame_background_colour = 171,171,171
+notebook_colour = 240,240,240
+notebook_panels_colour = 170,170,170
+grid_line_colour = 0,0,0
+grid_gropes_colour = 0,255,255
+grid_sub_gropes_colour = 255,215,0
+grid_debug_settings_colour = 200,200,200
+test_result_label_colour = 127,255,212
+video_image_box_background_colour = 125,125,125
+video_image_box_border_colour = 215,228,242
+video_image_box_title_colour = 255,255,225
+video_box_time_colour = 0,0,0
+video_box_time_text_colour = 255,255,255
+video_box_separating_line_colour = 255,255,255
+video_box_separating_line_border_colour = 0,0,0
+dont_delete_unrecognized_images1 = 0
+dont_delete_unrecognized_images2 = 1
+generate_cleared_text_images_on_test = 1
+dump_debug_images = 0
+dump_debug_second_filtration_images = 0
+clear_test_images_folder = 1
+show_transformed_images_only = 0
+use_ocl = 1
+use_cuda_gpu = 0
+use_filter_color = none
+use_outline_filter_color = none
+dL_color = 40
+dA_color = 30
+dB_color = 30
+combine_to_single_cluster = 0
+cuda_kmeans_initial_loop_iterations = 20
+cuda_kmeans_loop_iterations = 30
+cpu_kmeans_initial_loop_iterations = 20
+cpu_kmeans_loop_iterations = 30
+moderate_threshold_for_scaled_image = 0.25
+moderate_threshold = 0.25
+moderate_threshold_for_NEdges = 0.25
+segment_width = 8
+segment_height = 3
+minimum_segments_count = 2
+min_sum_color_diff = 0
+between_text_distace = 0.07
+text_centre_offset = 0.2
+image_scale_for_clear_image = 4
+use_ISA_images = 1
+use_ILA_images = 1
+use_ILA_images_for_getting_txt_symbols_areas = 0
+use_ILA_images_before_clear_txt_images_from_borders = 0
+use_gradient_images_for_clear_txt_images = 1
+clear_txt_images_by_main_color = 1
+use_ILA_images_for_clear_txt_images = 1
+min_points_number = 30
+min_points_density = 0.3
+min_symbol_height = 0.02
+min_symbol_density = 0.2
+min_NEdges_points_density = 0.2
+threads = -1
+ocr_threads = -1
+sub_frame_length = 8
+text_percent = 0.3
+min_text_len_in_percent = 0.022
+vedges_points_line_error = 0.3
+ila_points_line_error = 0.3
+video_contrast = 1
+video_gamma = 1
+clear_txt_folders = 1
+join_subs_and_correct_time = 1
+clear_image_logical = 0
+clean_rgb_images_after_run = 0
+min_sub_duration = 0
+def_string_for_empty_sub = [sub_duration]
+txt_dw = 5
+txt_dy = 5
+use_ISA_images_for_search_subtitles = 1
+use_ILA_images_for_search_subtitles = 1
+replace_ISA_by_filtered_version = 1
+max_dl_down = 20
+max_dl_up = 40
+remove_wide_symbols = 0
+hw_device = cpu
+filter_descr = none
+text_alignment = 0
+save_each_substring_separately = 0
+save_scaled_images = 1
+playback_sound = 0
+border_is_darker = 1
+extend_by_grey_color = 0
+allow_min_luminance = 100
+bottom_video_image_percent_end = 0
+top_video_image_percent_end = 0.3
+left_video_image_percent_end = 0
+right_video_image_percent_end = 1
+toolbar_bitmaps_transparent_colour = 192,192,192
+ocr_join_images_clear_dir = 1
+ocr_join_images_join_rgb_images = 0
+ocr_join_images_use_txt_images_data_for_join_rgb_images = 1
+ocr_join_images_split_line = [sub_id]
+ocr_join_images_split_line_font_size = -1
+ocr_join_images_split_line_font_bold = 1
+ocr_join_images_sub_id_format = [%d]
+ocr_join_images_sub_search_by_id_format = \[%d\](.*?)\[\d+\]
+ocr_join_images_scale = 1
+ocr_join_images_max_number = 50
\ No newline at end of file
diff --git a/backend/subfinder/windows/VideoSubFinderWXW.exe b/backend/subfinder/windows/VideoSubFinderWXW.exe
new file mode 100644
index 0000000..3234c13
Binary files /dev/null and b/backend/subfinder/windows/VideoSubFinderWXW.exe differ
diff --git a/backend/subfinder/windows/avcodec-58.dll b/backend/subfinder/windows/avcodec-58.dll
new file mode 100644
index 0000000..cd120d4
Binary files /dev/null and b/backend/subfinder/windows/avcodec-58.dll differ
diff --git a/backend/subfinder/windows/avdevice-58.dll b/backend/subfinder/windows/avdevice-58.dll
new file mode 100644
index 0000000..6609349
Binary files /dev/null and b/backend/subfinder/windows/avdevice-58.dll differ
diff --git a/backend/subfinder/windows/avfilter-7.dll b/backend/subfinder/windows/avfilter-7.dll
new file mode 100644
index 0000000..21f6cf3
Binary files /dev/null and b/backend/subfinder/windows/avfilter-7.dll differ
diff --git a/backend/subfinder/windows/avformat-58.dll b/backend/subfinder/windows/avformat-58.dll
new file mode 100644
index 0000000..dcc948f
Binary files /dev/null and b/backend/subfinder/windows/avformat-58.dll differ
diff --git a/backend/subfinder/windows/avutil-56.dll b/backend/subfinder/windows/avutil-56.dll
new file mode 100644
index 0000000..b90eee5
Binary files /dev/null and b/backend/subfinder/windows/avutil-56.dll differ
diff --git a/backend/subfinder/windows/bitmaps/left_na.bmp b/backend/subfinder/windows/bitmaps/left_na.bmp
new file mode 100644
index 0000000..a30b40d
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/left_na.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/left_od.bmp b/backend/subfinder/windows/bitmaps/left_od.bmp
new file mode 100644
index 0000000..3c26b88
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/left_od.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/right_na.bmp b/backend/subfinder/windows/bitmaps/right_na.bmp
new file mode 100644
index 0000000..3511274
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/right_na.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/right_od.bmp b/backend/subfinder/windows/bitmaps/right_od.bmp
new file mode 100644
index 0000000..3e3ce81
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/right_od.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/sb_la.bmp b/backend/subfinder/windows/bitmaps/sb_la.bmp
new file mode 100644
index 0000000..5bb65be
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/sb_la.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/sb_lc.bmp b/backend/subfinder/windows/bitmaps/sb_lc.bmp
new file mode 100644
index 0000000..d92e411
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/sb_lc.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/sb_ra.bmp b/backend/subfinder/windows/bitmaps/sb_ra.bmp
new file mode 100644
index 0000000..d55a475
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/sb_ra.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/sb_rc.bmp b/backend/subfinder/windows/bitmaps/sb_rc.bmp
new file mode 100644
index 0000000..609256d
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/sb_rc.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/sb_t.bmp b/backend/subfinder/windows/bitmaps/sb_t.bmp
new file mode 100644
index 0000000..ecdd46d
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/sb_t.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/tb_pause.bmp b/backend/subfinder/windows/bitmaps/tb_pause.bmp
new file mode 100644
index 0000000..2a15732
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/tb_pause.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/tb_run.bmp b/backend/subfinder/windows/bitmaps/tb_run.bmp
new file mode 100644
index 0000000..69253ad
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/tb_run.bmp differ
diff --git a/backend/subfinder/windows/bitmaps/tb_stop.bmp b/backend/subfinder/windows/bitmaps/tb_stop.bmp
new file mode 100644
index 0000000..d73a638
Binary files /dev/null and b/backend/subfinder/windows/bitmaps/tb_stop.bmp differ
diff --git a/backend/subfinder/windows/concrt140.dll b/backend/subfinder/windows/concrt140.dll
new file mode 100644
index 0000000..87dd779
Binary files /dev/null and b/backend/subfinder/windows/concrt140.dll differ
diff --git a/backend/subfinder/windows/cudart64_110.dll b/backend/subfinder/windows/cudart64_110.dll
new file mode 100644
index 0000000..6e795cf
Binary files /dev/null and b/backend/subfinder/windows/cudart64_110.dll differ
diff --git a/backend/subfinder/windows/finished.wav b/backend/subfinder/windows/finished.wav
new file mode 100644
index 0000000..d6e8baa
Binary files /dev/null and b/backend/subfinder/windows/finished.wav differ
diff --git a/backend/subfinder/windows/msvcp140.dll b/backend/subfinder/windows/msvcp140.dll
new file mode 100644
index 0000000..5e5117a
Binary files /dev/null and b/backend/subfinder/windows/msvcp140.dll differ
diff --git a/backend/subfinder/windows/nppc64_11.dll b/backend/subfinder/windows/nppc64_11.dll
new file mode 100644
index 0000000..064adce
Binary files /dev/null and b/backend/subfinder/windows/nppc64_11.dll differ
diff --git a/backend/subfinder/windows/nppicc64_11.dll b/backend/subfinder/windows/nppicc64_11.dll
new file mode 100644
index 0000000..3abe17b
Binary files /dev/null and b/backend/subfinder/windows/nppicc64_11.dll differ
diff --git a/backend/subfinder/windows/nppig64_11.dll b/backend/subfinder/windows/nppig64_11.dll
new file mode 100644
index 0000000..0859df5
Binary files /dev/null and b/backend/subfinder/windows/nppig64_11.dll differ
diff --git a/backend/subfinder/windows/opencv_videoio_ffmpeg430_64.dll b/backend/subfinder/windows/opencv_videoio_ffmpeg430_64.dll
new file mode 100644
index 0000000..af1ae6a
Binary files /dev/null and b/backend/subfinder/windows/opencv_videoio_ffmpeg430_64.dll differ
diff --git a/backend/subfinder/windows/opencv_world430.dll b/backend/subfinder/windows/opencv_world430.dll
new file mode 100644
index 0000000..2e47847
Binary files /dev/null and b/backend/subfinder/windows/opencv_world430.dll differ
diff --git a/backend/subfinder/windows/postproc-55.dll b/backend/subfinder/windows/postproc-55.dll
new file mode 100644
index 0000000..5692b48
Binary files /dev/null and b/backend/subfinder/windows/postproc-55.dll differ
diff --git a/backend/subfinder/windows/previous_video.inf b/backend/subfinder/windows/previous_video.inf
new file mode 100644
index 0000000..05936eb
--- /dev/null
+++ b/backend/subfinder/windows/previous_video.inf
@@ -0,0 +1,4 @@
+C:\Users\fangyao\Downloads\test.mp4
+0
+53766
+0
\ No newline at end of file
diff --git a/backend/subfinder/windows/settings/eng/locale.cfg b/backend/subfinder/windows/settings/eng/locale.cfg
new file mode 100644
index 0000000..d7d24fe
--- /dev/null
+++ b/backend/subfinder/windows/settings/eng/locale.cfg
@@ -0,0 +1,102 @@
+label_text_alignment = Text Alignment
+ocr_label_msd_text = Min Sub Duration
+ocr_label_jsact_text = Join Subs And Correct Time
+ocr_label_clear_txt_folders = Clear TXT Folders Before Run
+ocr_button_ccti_text = Create Cleared TXTImages
+ocr_button_csftr_text = Create Sub From TXTResults
+ocr_button_cesfcti_text = Create Empty Sub From Cleared TXTImages
+ocr_button_ces_text = Create Empty Sub From RGBImages
+ocr_button_join_text = Join TXTImages
+ocr_button_test_text = Test
+ocr_label_save_each_substring_separately = Save Each Substring Separately
+ocr_label_save_scaled_images = Save Scaled Images
+ssp_label_parameters_influencing_image_processing = Parameters Influencing Image Processing
+ssp_label_ocl_and_multiframe_image_stream_processing = OCR and Multiframe Image Stream Processing
+ssp_oi_group_global_image_processing_settings = Global Image Processing Settings
+ssp_oi_property_use_ocl = Use OCL In OpenCV
+ssp_oi_property_use_cuda_gpu = Use CUDA GPU Acceleration
+ssp_oi_property_image_scale_for_clear_image = Image Scale For Clear Image 
+ssp_oi_property_cpu_kmeans_initial_loop_iterations = CPU kmeans initial loop iterations 
+ssp_oi_property_cpu_kmeans_loop_iterations = CPU kmeans loop iterations 
+ssp_oi_property_cuda_kmeans_initial_loop_iterations = CUDA kmeans initial loop iterations 
+ssp_oi_property_cuda_kmeans_loop_iterations = CUDA kmeans loop iterations 
+ssp_oi_property_generate_cleared_text_images_on_test = Generate Cleared Text Images On Test Button
+ssp_oi_property_dump_debug_images = Dump Debug Images
+ssp_oi_property_dump_debug_second_filtration_images = Dump Debug Secondary Processing Images
+ssp_oi_property_clear_test_images_folder = Clear Test Images Folder
+ssp_oi_property_show_transformed_images_only = Show Transformed Images Only
+ssp_oi_group_initial_image_processing = Initial Image Processing
+ssp_oi_sub_group_settings_for_sobel_operators = Settings For Sobel Operators
+ssp_oi_property_moderate_threshold = Moderate Threshold 
+ssp_oi_property_moderate_nedges_threshold = Moderate NEdges Threshold 
+ssp_oi_sub_group_settings_for_color_filtering = Settings For Color Filtering
+ssp_oi_property_segment_width = Line Segment Width 
+ssp_oi_property_min_segments_count = Min Segments Count 
+ssp_oi_property_min_sum_color_difference = Min Sum Color Difference 
+ssp_oi_group_secondary_image_processing = Secondary Image Processing
+ssp_oi_sub_group_settings_for_linear_filtering = Settings For Linear Filtering
+ssp_oi_property_line_height = Line Segment Height 
+ssp_oi_property_max_between_text_distance = Max Between Text Distance 
+ssp_oi_property_max_text_center_offset = Max Text Offset 
+ssp_oi_property_max_text_center_percent_offset = Max Text Center Percent Offset 
+ssp_oi_sub_group_settings_for_color_border_points = Settings For Color Border Points
+ssp_oi_property_min_points_number = Min Points Number 
+ssp_oi_property_min_points_density = Min Points Density 
+ssp_oi_property_min_symbol_height = Min Symbol Height (in % to Full Image Height) 
+ssp_oi_property_min_symbol_density = Min Symbol Density (in % to Its Size) 
+ssp_oi_property_min_vedges_points_density = Min VEdges points density 
+ssp_oi_property_min_nedges_points_density = Min NEdges points density 
+ssp_oi_property_min_sum_multiple_color_difference = Min Sum Multiple Color Difference 
+ssp_oi_group_tertiary_image_processing = Tertiary Image Processing 
+ssp_oi_property_min_vedges_points_density_per_half_line = Min VEdges points density (per half line) 
+ssp_oi_property_min_hedges_points_density_per_half_line = Min HEdges points density (per half line) 
+ssp_oi_property_min_nedges_points_density_per_half_line = Min NEdges points density (per half line) 
+ssp_oim_group_ocr_settings = OCR settings
+ssp_oim_property_clear_images_logical = Clear Images Logical;(don't use on Hieroglyph or Arabic subs)
+ssp_oim_property_clear_rgbimages_after_search_subtitles = Clear RGBImages after search subtitles 
+ssp_oim_property_using_isaimages_for_getting_txt_areas = Use ISAImages for getting TXT areas 
+ssp_oim_property_using_ilaimages_for_getting_txt_areas = Use ILAImages for getting TXT areas 
+label_ILA_images_for_getting_txt_symbols_areas = Use ILAImages for getting TXT symbols areas 
+label_use_ILA_images_before_clear_txt_images_from_borders = Use ILAImages before clear TXT images from borders 
+ssp_oim_property_validate_and_compare_cleared_txt_images = (NotRealized) Validate And Compare Cleared TXTImages 
+ssp_oim_property_dont_delete_unrecognized_images_first = Don't Delete Unrecognized Images (First) 
+ssp_oim_property_dont_delete_unrecognized_images_second = Don't Delete Unrecognized Images (Second) 
+ssp_oim_property_default_string_for_empty_sub = Default string for empty sub 
+ssp_oim_group_settings_for_multiframe_image_processing = Settings For Multi-Frame Image Processing
+ssp_oim_sub_group_settings_for_sub_detection = Settings For Sub Detection
+ssp_oim_property_threads = Number Of Parallel Tasks;(For Run Search)
+ssp_ocr_threads = Number Of Parallel Tasks;(For Create Cleared TXTImages)
+ssp_oim_property_sub_frames_length = Sub Frames Length 
+ssp_oim_property_use_ILA_images_for_search_subtitles = Use ILAImages for search subtitles
+ssp_oim_property_use_ISA_images_for_search_subtitles = Analyze ISAImages for sub presence
+ssp_oim_property_replace_ISA_by_filtered_version = Replace ISAImages by filtered version
+ssp_oim_property_max_dl_down = Max luminance diff from down for IL image generation
+ssp_oim_property_max_dl_up = Max luminance diff from up for IL image generation
+ssp_oim_sub_group_settings_for_comparing_subs = Settings For Comparing Subs
+ssp_oim_property_vedges_points_line_error = VEdges Points line error 
+ssp_oim_property_ila_points_line_error = ILA Points line error 
+ssp_oim_sub_group_settings_for_checking_sub = Settings For Checking Sub
+ssp_oim_property_text_percent = Text Percent 
+ssp_oim_property_min_text_length = Min Text Length 
+ssp_oim_property_use_gradient_images_for_clear_txt_images = Use Gradient Images For Clear TXTImages 
+ssp_oim_property_use_ILA_images_for_clear_txt_images = Use ILAImages For Clear TXTImages 
+ssp_oim_property_clear_txt_images_by_main_color = Clear TXTImages By Main Color 
+ssp_oi_property_moderate_threshold_for_scaled_image = Moderate Threshold For Scaled Image 
+ssp_oim_property_remove_wide_symbols = Remove too wide symbols;(don't use for Arabic or handwritten subs)
+ssp_hw_device = FFMPEG HW Devices
+label_filter_descr = FFMPEG Video Filters
+label_settings_file = Current Settings File
+label_playback_sound = Playback Sound On Task Finished
+label_border_is_darker = Characters Border Is Darker
+label_extend_by_grey_color = Extend By Grey Color;(try to use in case of subs with unstable luminance)
+label_allow_min_luminance = Allow Min Luminance;(used only if "Extend By Grey Color" is set)
+ssp_oim_sub_group_settings_for_update_video_color = Settings For Update Video Color
+label_video_contrast = Video Contrast
+label_video_gamma = Video Gamma
+label_pixel_color = Pixel Color;(By 'Left Mouse Click' in Video Box)
+label_use_filter_color = Use Filter Colors;(Use 'Ctrl+Enter' for add New Line);(Press and hold 'T'/'R'/'Y'/'U' button in Video Box for check)
+label_use_outline_filter_color = Use Outline Filter Colors;(Use 'Ctrl+Enter' for add New Line);(Press and hold 'T'/'R'/'I'/'U' button in Video Box for check)
+label_dL_color = default dL For RGB and Lab Filter Colors
+label_dA_color = default dA For Lab Filter Colors
+label_dB_color = default dB For Lab Filter Colors
+label_combine_to_single_cluster = Combine To Single Cluster;(can be used in case of multiple colors in single line)
diff --git a/backend/subfinder/windows/settings/general.cfg b/backend/subfinder/windows/settings/general.cfg
new file mode 100644
index 0000000..5e96574
--- /dev/null
+++ b/backend/subfinder/windows/settings/general.cfg
@@ -0,0 +1,82 @@
+prefered_locale = eng
+ocr_join_txt_images_split_line = [begin_time] --> [end_time]
+process_affinity_mask = -1
+fount_size_lbl = 10
+fount_size_btn = 13
+dont_delete_unrecognized_images1 = 0
+dont_delete_unrecognized_images2 = 1
+generate_cleared_text_images_on_test = 1
+dump_debug_images = 0
+dump_debug_second_filtration_images = 0
+clear_test_images_folder = 1
+show_transformed_images_only = 0
+use_ocl = 1
+use_cuda_gpu = 0
+use_filter_color = none
+use_outline_filter_color = none
+dL_color = 40
+dA_color = 30
+dB_color = 30
+combine_to_single_cluster = 0
+cuda_kmeans_initial_loop_iterations = 20
+cuda_kmeans_loop_iterations = 30
+cpu_kmeans_initial_loop_iterations = 20
+cpu_kmeans_loop_iterations = 30
+moderate_threshold_for_scaled_image = 0.25
+moderate_threshold = 0.25
+moderate_threshold_for_NEdges = 0.25
+segment_width = 8
+segment_height = 3
+minimum_segments_count = 2
+min_sum_color_diff = 0
+between_text_distace = 0.07
+text_centre_offset = 0.2
+image_scale_for_clear_image = 4
+use_ISA_images = 1
+use_ILA_images = 1
+use_ILA_images_for_getting_txt_symbols_areas = 0
+use_ILA_images_before_clear_txt_images_from_borders = 0
+use_gradient_images_for_clear_txt_images = 1
+clear_txt_images_by_main_color = 1
+use_ILA_images_for_clear_txt_images = 1
+min_points_number = 30
+min_points_density = 0.3
+min_symbol_height = 0.02
+min_symbol_density = 0.2
+min_NEdges_points_density = 0.2
+threads = -1
+ocr_threads = -1
+sub_frame_length = 6
+text_percent = 0.3
+min_text_len_in_percent = 0.022
+vedges_points_line_error = 0.3
+ila_points_line_error = 0.3
+video_contrast = 1
+video_gamma = 1
+clear_txt_folders = 1
+join_subs_and_correct_time = 1
+clear_image_logical = 0
+clean_rgb_images_after_run = 0
+def_string_for_empty_sub = sub duration: %sub_duration%
+min_sub_duration = 0
+txt_dw = 5
+txt_dy = 5
+use_ISA_images_for_search_subtitles = 1
+use_ILA_images_for_search_subtitles = 1
+replace_ISA_by_filtered_version = 1
+max_dl_down = 20
+max_dl_up = 40
+remove_wide_symbols = 0
+hw_device = cpu
+filter_descr = none
+text_alignment = Center
+save_each_substring_separately = 0
+save_scaled_images = 1
+playback_sound = 0
+border_is_darker = 1
+extend_by_grey_color = 0
+allow_min_luminance = 100
+bottom_video_image_percent_end = 0
+top_video_image_percent_end = 0.3
+left_video_image_percent_end = 0
+right_video_image_percent_end = 1
diff --git a/backend/subfinder/windows/swresample-3.dll b/backend/subfinder/windows/swresample-3.dll
new file mode 100644
index 0000000..51134cf
Binary files /dev/null and b/backend/subfinder/windows/swresample-3.dll differ
diff --git a/backend/subfinder/windows/swscale-5.dll b/backend/subfinder/windows/swscale-5.dll
new file mode 100644
index 0000000..40e591e
Binary files /dev/null and b/backend/subfinder/windows/swscale-5.dll differ
diff --git a/backend/subfinder/windows/vcruntime140.dll b/backend/subfinder/windows/vcruntime140.dll
new file mode 100644
index 0000000..5d5b81d
Binary files /dev/null and b/backend/subfinder/windows/vcruntime140.dll differ
diff --git a/backend/subfinder/windows/vcruntime140_1.dll b/backend/subfinder/windows/vcruntime140_1.dll
new file mode 100644
index 0000000..3a02196
Binary files /dev/null and b/backend/subfinder/windows/vcruntime140_1.dll differ
diff --git a/backend/sushi/__init__.py b/backend/sushi/__init__.py
new file mode 100644
index 0000000..5bf2cc9
--- /dev/null
+++ b/backend/sushi/__init__.py
@@ -0,0 +1,699 @@
+import bisect
+from itertools import takewhile, chain
+import logging
+import operator
+import os
+
+import numpy as np
+
+from . import chapters
+from .common import SushiError, get_extension, format_time, ensure_static_collection
+from .demux import Timecodes, Demuxer
+from . import keyframes
+from .subs import AssScript, SrtScript
+from .wav import WavStream
+
+
+try:
+    import matplotlib.pyplot as plt
+    plot_enabled = True
+except ImportError:
+    plot_enabled = False
+
+
+ALLOWED_ERROR = 0.01
+MAX_GROUP_STD = 0.025
+VERSION = '0.6.0'
+
+
+def abs_diff(a, b):
+    return abs(a - b)
+
+
+def interpolate_nones(data, points):
+    data = ensure_static_collection(data)
+    values_lookup = {p: v for p, v in zip(points, data) if v is not None}
+    if not values_lookup:
+        return []
+
+    zero_points = {p for p, v in zip(points, data) if v is None}
+    if not zero_points:
+        return data
+
+    data_list = sorted(values_lookup.items())
+    zero_points = sorted(x for x in zero_points if x not in values_lookup)
+
+    out = np.interp(x=zero_points,
+                    xp=list(map(operator.itemgetter(0), data_list)),
+                    fp=list(map(operator.itemgetter(1), data_list)))
+
+    values_lookup.update(zip(zero_points, out))
+
+    return [
+        values_lookup[point] if value is None else value
+        for point, value in zip(points, data)
+    ]
+
+
+# todo: implement this as a running median
+def running_median(values, window_size):
+    if window_size % 2 != 1:
+        raise SushiError('Median window size should be odd')
+    half_window = window_size // 2
+    medians = []
+    items_count = len(values)
+    for idx in range(items_count):
+        radius = min(half_window, idx, items_count - idx - 1)
+        med = np.median(values[idx - radius:idx + radius + 1])
+        medians.append(med)
+    return medians
+
+
+def smooth_events(events, radius):
+    if not radius:
+        return
+    window_size = radius * 2 + 1
+    shifts = [e.shift for e in events]
+    smoothed = running_median(shifts, window_size)
+    for event, new_shift in zip(events, smoothed):
+        event.set_shift(new_shift, event.diff)
+
+
+def detect_groups(events_iter):
+    events_iter = iter(events_iter)
+    groups_list = [[next(events_iter)]]
+    for event in events_iter:
+        if abs_diff(event.shift, groups_list[-1][-1].shift) > ALLOWED_ERROR:
+            groups_list.append([])
+        groups_list[-1].append(event)
+    return groups_list
+
+
+def groups_from_chapters(events, times):
+    logging.info('Chapter start points: {0}'.format([format_time(t) for t in times]))
+    groups = [[]]
+    chapter_times = iter(times[1:] + [36000000000])  # very large event at the end
+    current_chapter = next(chapter_times)
+
+    for event in events:
+        if event.end > current_chapter:
+            groups.append([])
+            while event.end > current_chapter:
+                current_chapter = next(chapter_times)
+
+        groups[-1].append(event)
+
+    groups = [g for g in groups if g]  # non-empty groups
+    # check if we have any groups where every event is linked
+    # for example a chapter with only comments inside
+    broken_groups = [group for group in groups if not any(e for e in group if not e.linked)]
+    if broken_groups:
+        for group in broken_groups:
+            for event in group:
+                parent = event.get_link_chain_end()
+                parent_group = next(group for group in groups if parent in group)
+                parent_group.append(event)
+            del group[:]
+        groups = [g for g in groups if g]
+        # re-sort the groups again since we might break the order when inserting linked events
+        # sorting everything again is far from optimal but python sorting is very fast for sorted arrays anyway
+        for group in groups:
+            group.sort(key=lambda event: event.start)
+
+    return groups
+
+
+def split_broken_groups(groups):
+    correct_groups = []
+    broken_found = False
+    for g in groups:
+        std = np.std([e.shift for e in g])
+        if std > MAX_GROUP_STD:
+            logging.warn('Shift is not consistent between {0} and {1}, most likely chapters are wrong (std: {2}). '
+                         'Switching to automatic grouping.'.format(format_time(g[0].start), format_time(g[-1].end),
+                                                                   std))
+            correct_groups.extend(detect_groups(g))
+            broken_found = True
+        else:
+            correct_groups.append(g)
+
+    if broken_found:
+        groups_iter = iter(correct_groups)
+        correct_groups = [list(next(groups_iter))]
+        for group in groups_iter:
+            if abs_diff(correct_groups[-1][-1].shift, group[0].shift) >= ALLOWED_ERROR \
+                    or np.std([e.shift for e in group + correct_groups[-1]]) >= MAX_GROUP_STD:
+                correct_groups.append([])
+
+            correct_groups[-1].extend(group)
+    return correct_groups
+
+
+def fix_near_borders(events):
+    """
+    We assume that all lines with diff greater than 5 * (median diff across all events) are broken
+    """
+    def fix_border(event_list, median_diff):
+        last_ten_diff = np.median([x.diff for x in event_list[:10]], overwrite_input=True)
+        diff_limit = min(last_ten_diff, median_diff)
+        broken = []
+        for event in event_list:
+            if not 0.2 < (event.diff / diff_limit) < 5:
+                broken.append(event)
+            else:
+                for x in broken:
+                    x.link_event(event)
+                return len(broken)
+        return 0
+
+    median_diff = np.median([x.diff for x in events], overwrite_input=True)
+
+    fixed_count = fix_border(events, median_diff)
+    if fixed_count:
+        logging.info('Fixing {0} border events right after {1}'.format(fixed_count, format_time(events[0].start)))
+
+    fixed_count = fix_border(list(reversed(events)), median_diff)
+    if fixed_count:
+        logging.info('Fixing {0} border events right before {1}'.format(fixed_count, format_time(events[-1].end)))
+
+
+def get_distance_to_closest_kf(timestamp, keyframes):
+    idx = bisect.bisect_left(keyframes, timestamp)
+    if idx == 0:
+        kf = keyframes[0]
+    elif idx == len(keyframes):
+        kf = keyframes[-1]
+    else:
+        before = keyframes[idx - 1]
+        after = keyframes[idx]
+        kf = after if after - timestamp < timestamp - before else before
+    return kf - timestamp
+
+
+def find_keyframe_shift(group, src_keytimes, dst_keytimes, src_timecodes, dst_timecodes, max_kf_distance):
+    def get_distance(src_distance, dst_distance, limit):
+        if abs(dst_distance) > limit:
+            return None
+        shift = dst_distance - src_distance
+        return shift if abs(shift) < limit else None
+
+    src_start = get_distance_to_closest_kf(group[0].start, src_keytimes)
+    src_end = get_distance_to_closest_kf(group[-1].end + src_timecodes.get_frame_size(group[-1].end), src_keytimes)
+
+    dst_start = get_distance_to_closest_kf(group[0].shifted_start, dst_keytimes)
+    dst_end = get_distance_to_closest_kf(group[-1].shifted_end + dst_timecodes.get_frame_size(group[-1].end), dst_keytimes)
+
+    snapping_limit_start = src_timecodes.get_frame_size(group[0].start) * max_kf_distance
+    snapping_limit_end = src_timecodes.get_frame_size(group[0].end) * max_kf_distance
+
+    return (get_distance(src_start, dst_start, snapping_limit_start),
+            get_distance(src_end, dst_end, snapping_limit_end))
+
+
+def find_keyframes_distances(event, src_keytimes, dst_keytimes, timecodes, max_kf_distance):
+    def find_keyframe_distance(src_time, dst_time):
+        src = get_distance_to_closest_kf(src_time, src_keytimes)
+        dst = get_distance_to_closest_kf(dst_time, dst_keytimes)
+        snapping_limit = timecodes.get_frame_size(src_time) * max_kf_distance
+
+        if abs(src) < snapping_limit and abs(dst) < snapping_limit and abs(src - dst) < snapping_limit:
+            return dst - src
+        return 0
+
+    ds = find_keyframe_distance(event.start, event.shifted_start)
+    de = find_keyframe_distance(event.end, event.shifted_end)
+    return ds, de
+
+
+def snap_groups_to_keyframes(events, chapter_times, max_ts_duration, max_ts_distance, src_keytimes, dst_keytimes,
+                             src_timecodes, dst_timecodes, max_kf_distance, kf_mode):
+    if not max_kf_distance:
+        return
+
+    groups = merge_short_lines_into_groups(events, chapter_times, max_ts_duration, max_ts_distance)
+
+    if kf_mode == 'all' or kf_mode == 'shift':
+        #  step 1: snap events without changing their duration. Useful for some slight audio imprecision correction
+        shifts = []
+        times = []
+        for group in groups:
+            shifts.extend(find_keyframe_shift(group, src_keytimes, dst_keytimes, src_timecodes, dst_timecodes, max_kf_distance))
+            times.extend((group[0].shifted_start, group[-1].shifted_end))
+
+        shifts = interpolate_nones(shifts, times)
+        if shifts:
+            mean_shift = np.mean(shifts)
+            shifts = zip(*[iter(shifts)] * 2)
+
+            logging.info('Group {0}-{1} corrected by {2}'.format(format_time(events[0].start), format_time(events[-1].end), mean_shift))
+            for group, (start_shift, end_shift) in zip(groups, shifts):
+                if abs(start_shift - end_shift) > 0.001 and len(group) > 1:
+                    actual_shift = min(start_shift, end_shift, key=lambda x: abs(x - mean_shift))
+                    logging.warning("Typesetting group at {0} had different shift at start/end points ({1} and {2}). Shifting by {3}."
+                                    .format(format_time(group[0].start), start_shift, end_shift, actual_shift))
+                    for e in group:
+                        e.adjust_shift(actual_shift)
+                else:
+                    for e in group:
+                        e.adjust_additional_shifts(start_shift, end_shift)
+
+    if kf_mode == 'all' or kf_mode == 'snap':
+        # step 2: snap start/end times separately
+        for group in groups:
+            if len(group) > 1:
+                pass  # we don't snap typesetting
+            start_shift, end_shift = find_keyframes_distances(group[0], src_keytimes, dst_keytimes, src_timecodes, max_kf_distance)
+            if abs(start_shift) > 0.01 or abs(end_shift) > 0.01:
+                logging.info('Snapping {0} to keyframes, start time by {1}, end: {2}'.format(format_time(group[0].start), start_shift, end_shift))
+                group[0].adjust_additional_shifts(start_shift, end_shift)
+
+
+def average_shifts(events):
+    events = [e for e in events if not e.linked]
+    shifts = [x.shift for x in events]
+    weights = [1 - x.diff for x in events]
+    avg = np.average(shifts, weights=weights)
+    for e in events:
+        e.set_shift(avg, e.diff)
+    return avg
+
+
+def merge_short_lines_into_groups(events, chapter_times, max_ts_duration, max_ts_distance):
+    search_groups = []
+    chapter_times = iter(chapter_times[1:] + [100000000])
+    next_chapter = next(chapter_times)
+    events = ensure_static_collection(events)
+
+    processed = set()
+    for idx, event in enumerate(events):
+        if idx in processed:
+            continue
+
+        while event.end > next_chapter:
+            next_chapter = next(chapter_times)
+
+        if event.duration > max_ts_duration:
+            search_groups.append([event])
+            processed.add(idx)
+        else:
+            group = [event]
+            group_end = event.end
+            i = idx + 1
+            while i < len(events) and abs(group_end - events[i].start) < max_ts_distance:
+                if events[i].end < next_chapter and events[i].duration <= max_ts_duration:
+                    processed.add(i)
+                    group.append(events[i])
+                    group_end = max(group_end, events[i].end)
+                i += 1
+
+            search_groups.append(group)
+
+    return search_groups
+
+
+def prepare_search_groups(events, source_duration, chapter_times, max_ts_duration, max_ts_distance):
+    last_unlinked = None
+    for idx, event in enumerate(events):
+        if event.is_comment:
+            try:
+                event.link_event(events[idx + 1])
+            except IndexError:
+                event.link_event(last_unlinked)
+            continue
+        if (event.start + event.duration / 2.0) > source_duration:
+            logging.info('Event time outside of audio range, ignoring: %s', event)
+            event.link_event(last_unlinked)
+            continue
+        elif event.end == event.start:
+            logging.info('{0}: skipped because zero duration'.format(format_time(event.start)))
+            try:
+                event.link_event(events[idx + 1])
+            except IndexError:
+                event.link_event(last_unlinked)
+            continue
+
+        # link lines with start and end times identical to some other event
+        # assuming scripts are sorted by start time so we don't search the entire collection
+        def same_start(x):
+            return event.start == x.start
+        processed = next((x for x in takewhile(same_start, reversed(events[:idx])) if not x.linked and x.end == event.end), None)
+        if processed:
+            event.link_event(processed)
+        else:
+            last_unlinked = event
+
+    events = (e for e in events if not e.linked)
+
+    search_groups = merge_short_lines_into_groups(events, chapter_times, max_ts_duration, max_ts_distance)
+
+    # link groups contained inside other groups to the larger group
+    passed_groups = []
+    for idx, group in enumerate(search_groups):
+        try:
+            other = next(x for x in reversed(search_groups[:idx])
+                         if x[0].start <= group[0].start
+                         and x[-1].end >= group[-1].end)
+            for event in group:
+                event.link_event(other[0])
+        except StopIteration:
+            passed_groups.append(group)
+    return passed_groups
+
+
+def calculate_shifts(src_stream, dst_stream, groups_list, normal_window, max_window, rewind_thresh):
+    def log_shift(state):
+        logging.info('{0}-{1}: shift: {2:0.10f}, diff: {3:0.10f}'
+                     .format(format_time(state["start_time"]), format_time(state["end_time"]), state["shift"], state["diff"]))
+
+    def log_uncommitted(state, shift, left_side_shift, right_side_shift, search_offset):
+        logging.debug('{0}-{1}: shift: {2:0.5f} [{3:0.5f}, {4:0.5f}], search offset: {5:0.6f}'
+                      .format(format_time(state["start_time"]), format_time(state["end_time"]),
+                              shift, left_side_shift, right_side_shift, search_offset))
+
+    small_window = 1.5
+    idx = 0
+    committed_states = []
+    uncommitted_states = []
+    window = normal_window
+    while idx < len(groups_list):
+        search_group = groups_list[idx]
+        tv_audio = src_stream.get_substream(search_group[0].start, search_group[-1].end)
+        original_time = search_group[0].start
+        group_state = {"start_time": search_group[0].start, "end_time": search_group[-1].end, "shift": None, "diff": None}
+        last_committed_shift = committed_states[-1]["shift"] if committed_states else 0
+        diff = new_time = None
+
+        if not uncommitted_states:
+            if original_time + last_committed_shift > dst_stream.duration_seconds:
+                # event outside of audio range, all events past it are also guaranteed to fail
+                for g in groups_list[idx:]:
+                    committed_states.append({"start_time": g[0].start, "end_time": g[-1].end, "shift": None, "diff": None})
+                    logging.info("{0}-{1}: outside of audio range".format(format_time(g[0].start), format_time(g[-1].end)))
+                break
+
+            if small_window < window:
+                diff, new_time = dst_stream.find_substream(tv_audio, original_time + last_committed_shift, small_window)
+
+            if new_time is not None and abs_diff(new_time - original_time, last_committed_shift) <= ALLOWED_ERROR:
+                # fastest case - small window worked, commit the group immediately
+                group_state.update({"shift": new_time - original_time, "diff": diff})
+                committed_states.append(group_state)
+                log_shift(group_state)
+                if window != normal_window:
+                    logging.info("Going back to window {0} from {1}".format(normal_window, window))
+                    window = normal_window
+                idx += 1
+                continue
+
+        left_audio_half, right_audio_half = np.split(tv_audio, [len(tv_audio[0]) // 2], axis=1)
+        right_half_offset = len(left_audio_half[0]) / float(src_stream.sample_rate)
+        terminate = False
+        # searching from last committed shift
+        if original_time + last_committed_shift < dst_stream.duration_seconds:
+            diff, new_time = dst_stream.find_substream(tv_audio, original_time + last_committed_shift, window)
+            left_side_time = dst_stream.find_substream(left_audio_half, original_time + last_committed_shift, window)[1]
+            right_side_time = dst_stream.find_substream(right_audio_half, original_time + last_committed_shift + right_half_offset, window)[1] - right_half_offset
+            terminate = abs_diff(left_side_time, right_side_time) <= ALLOWED_ERROR and abs_diff(new_time, left_side_time) <= ALLOWED_ERROR
+            log_uncommitted(group_state, new_time - original_time, left_side_time - original_time,
+                            right_side_time - original_time, last_committed_shift)
+
+        if not terminate and uncommitted_states and uncommitted_states[-1]["shift"] is not None \
+                and original_time + uncommitted_states[-1]["shift"] < dst_stream.duration_seconds:
+            start_offset = uncommitted_states[-1]["shift"]
+            diff, new_time = dst_stream.find_substream(tv_audio, original_time + start_offset, window)
+            left_side_time = dst_stream.find_substream(left_audio_half, original_time + start_offset, window)[1]
+            right_side_time = dst_stream.find_substream(right_audio_half, original_time + start_offset + right_half_offset, window)[1] - right_half_offset
+            terminate = abs_diff(left_side_time, right_side_time) <= ALLOWED_ERROR and abs_diff(new_time, left_side_time) <= ALLOWED_ERROR
+            log_uncommitted(group_state, new_time - original_time, left_side_time - original_time,
+                            right_side_time - original_time, start_offset)
+
+        shift = new_time - original_time
+        if not terminate:
+            # we aren't back on track yet - add this group to uncommitted
+            group_state.update({"shift": shift, "diff": diff})
+            uncommitted_states.append(group_state)
+            idx += 1
+            if rewind_thresh == len(uncommitted_states) and window < max_window:
+                logging.warn("Detected possibly broken segment starting at {0}, increasing the window from {1} to {2}"
+                             .format(format_time(uncommitted_states[0]["start_time"]), window, max_window))
+                window = max_window
+                idx = len(committed_states)
+                del uncommitted_states[:]
+            continue
+
+        # we're back on track - apply current shift to all broken events
+        if uncommitted_states:
+            logging.warning("Events from {0} to {1} will most likely be broken!".format(
+                format_time(uncommitted_states[0]["start_time"]),
+                format_time(uncommitted_states[-1]["end_time"])))
+
+        uncommitted_states.append(group_state)
+        for state in uncommitted_states:
+            state.update({"shift": shift, "diff": diff})
+            log_shift(state)
+        committed_states.extend(uncommitted_states)
+        del uncommitted_states[:]
+        idx += 1
+
+    for state in uncommitted_states:
+        log_shift(state)
+
+    for idx, (search_group, group_state) in enumerate(zip(groups_list, chain(committed_states, uncommitted_states))):
+        if group_state["shift"] is None:
+            for group in reversed(groups_list[:idx]):
+                link_to = next((x for x in reversed(group) if not x.linked), None)
+                if link_to:
+                    for e in search_group:
+                        e.link_event(link_to)
+                    break
+        else:
+            for e in search_group:
+                e.set_shift(group_state["shift"], group_state["diff"])
+
+
+def check_file_exists(path, file_title):
+    if path and not os.path.exists(path):
+        raise SushiError("{0} file doesn't exist".format(file_title))
+
+
+def format_full_path(temp_dir, base_path, postfix):
+    if temp_dir:
+        return os.path.join(temp_dir, os.path.basename(base_path) + postfix)
+    else:
+        return base_path + postfix
+
+
+def create_directory_if_not_exists(path):
+    if path and not os.path.exists(path):
+        os.makedirs(path)
+
+
+def run(args):
+    ignore_chapters = args.chapters_file is not None and args.chapters_file.lower() == 'none'
+    write_plot = plot_enabled and args.plot_path
+    if write_plot:
+        plt.clf()
+        plt.ylabel('Shift, seconds')
+        plt.xlabel('Event index')
+
+    # first part should do all possible validation and should NOT take significant amount of time
+    check_file_exists(args.source, 'Source')
+    check_file_exists(args.destination, 'Destination')
+    check_file_exists(args.src_timecodes, 'Source timecodes')
+    check_file_exists(args.dst_timecodes, 'Source timecodes')
+    check_file_exists(args.script_file, 'Script')
+
+    if not ignore_chapters:
+        check_file_exists(args.chapters_file, 'Chapters')
+    if args.src_keyframes not in ('auto', 'make'):
+        check_file_exists(args.src_keyframes, 'Source keyframes')
+    if args.dst_keyframes not in ('auto', 'make'):
+        check_file_exists(args.dst_keyframes, 'Destination keyframes')
+
+    if (args.src_timecodes and args.src_fps) or (args.dst_timecodes and args.dst_fps):
+        raise SushiError('Both fps and timecodes file cannot be specified at the same time')
+
+    src_demuxer = Demuxer(args.source)
+    dst_demuxer = Demuxer(args.destination)
+
+    if src_demuxer.is_wav and not args.script_file:
+        raise SushiError("Script file isn't specified")
+
+    if (args.src_keyframes and not args.dst_keyframes) or (args.dst_keyframes and not args.src_keyframes):
+        raise SushiError('Either none or both of src and dst keyframes should be provided')
+
+    create_directory_if_not_exists(args.temp_dir)
+
+    # selecting source audio
+    if src_demuxer.is_wav:
+        src_audio_path = args.source
+    else:
+        src_audio_path = format_full_path(args.temp_dir, args.source, '.sushi.wav')
+        src_demuxer.set_audio(stream_idx=args.src_audio_idx, output_path=src_audio_path, sample_rate=args.sample_rate)
+
+    # selecting destination audio
+    if dst_demuxer.is_wav:
+        dst_audio_path = args.destination
+    else:
+        dst_audio_path = format_full_path(args.temp_dir, args.destination, '.sushi.wav')
+        dst_demuxer.set_audio(stream_idx=args.dst_audio_idx, output_path=dst_audio_path, sample_rate=args.sample_rate)
+
+    # selecting source subtitles
+    if args.script_file:
+        src_script_path = args.script_file
+    else:
+        stype = src_demuxer.get_subs_type(args.src_script_idx)
+        src_script_path = format_full_path(args.temp_dir, args.source, '.sushi' + stype)
+        src_demuxer.set_script(stream_idx=args.src_script_idx, output_path=src_script_path)
+
+    script_extension = get_extension(src_script_path)
+    if script_extension not in ('.ass', '.srt'):
+        raise SushiError('Unknown script type')
+
+    # selection destination subtitles
+    if args.output_script:
+        dst_script_path = args.output_script
+        dst_script_extension = get_extension(args.output_script)
+        if dst_script_extension != script_extension:
+            raise SushiError("Source and destination script file types don't match ({0} vs {1})"
+                             .format(script_extension, dst_script_extension))
+    else:
+        dst_script_path = format_full_path(args.temp_dir, args.destination, '.sushi' + script_extension)
+
+    # selecting chapters
+    if args.grouping and not ignore_chapters:
+        if args.chapters_file:
+            if get_extension(args.chapters_file) == '.xml':
+                chapter_times = chapters.get_xml_start_times(args.chapters_file)
+            else:
+                chapter_times = chapters.get_ogm_start_times(args.chapters_file)
+        elif not src_demuxer.is_wav:
+            chapter_times = src_demuxer.chapters
+            output_path = format_full_path(args.temp_dir, src_demuxer.path, ".sushi.chapters.txt")
+            src_demuxer.set_chapters(output_path)
+        else:
+            chapter_times = []
+    else:
+        chapter_times = []
+
+    # selecting keyframes and timecodes
+    if args.src_keyframes:
+        def select_keyframes(file_arg, demuxer):
+            auto_file = format_full_path(args.temp_dir, demuxer.path, '.sushi.keyframes.txt')
+            if file_arg in ('auto', 'make'):
+                if file_arg == 'make' or not os.path.exists(auto_file):
+                    if not demuxer.has_video:
+                        raise SushiError("Cannot make keyframes for {0} because it doesn't have any video!"
+                                         .format(demuxer.path))
+                    demuxer.set_keyframes(output_path=auto_file)
+                return auto_file
+            else:
+                return file_arg
+
+        def select_timecodes(external_file, fps_arg, demuxer):
+            if external_file:
+                return external_file
+            elif fps_arg:
+                return None
+            elif demuxer.has_video:
+                path = format_full_path(args.temp_dir, demuxer.path, '.sushi.timecodes.txt')
+                demuxer.set_timecodes(output_path=path)
+                return path
+            else:
+                raise SushiError('Fps, timecodes or video files must be provided if keyframes are used')
+
+        src_keyframes_file = select_keyframes(args.src_keyframes, src_demuxer)
+        dst_keyframes_file = select_keyframes(args.dst_keyframes, dst_demuxer)
+        src_timecodes_file = select_timecodes(args.src_timecodes, args.src_fps, src_demuxer)
+        dst_timecodes_file = select_timecodes(args.dst_timecodes, args.dst_fps, dst_demuxer)
+
+    # after this point nothing should fail so it's safe to start slow operations
+    # like running the actual demuxing
+    src_demuxer.demux()
+    dst_demuxer.demux()
+
+    try:
+        if args.src_keyframes:
+            src_timecodes = Timecodes.cfr(args.src_fps) if args.src_fps else Timecodes.from_file(src_timecodes_file)
+            src_keytimes = [src_timecodes.get_frame_time(f) for f in keyframes.parse_keyframes(src_keyframes_file)]
+
+            dst_timecodes = Timecodes.cfr(args.dst_fps) if args.dst_fps else Timecodes.from_file(dst_timecodes_file)
+            dst_keytimes = [dst_timecodes.get_frame_time(f) for f in keyframes.parse_keyframes(dst_keyframes_file)]
+
+        script = AssScript.from_file(src_script_path) if script_extension == '.ass' else SrtScript.from_file(src_script_path)
+        script.sort_by_time()
+
+        src_stream = WavStream(src_audio_path, sample_rate=args.sample_rate, sample_type=args.sample_type)
+        dst_stream = WavStream(dst_audio_path, sample_rate=args.sample_rate, sample_type=args.sample_type)
+
+        search_groups = prepare_search_groups(script.events,
+                                              source_duration=src_stream.duration_seconds,
+                                              chapter_times=chapter_times,
+                                              max_ts_duration=args.max_ts_duration,
+                                              max_ts_distance=args.max_ts_distance)
+
+        calculate_shifts(src_stream, dst_stream, search_groups,
+                         normal_window=args.window,
+                         max_window=args.max_window,
+                         rewind_thresh=args.rewind_thresh if args.grouping else 0)
+
+        events = script.events
+
+        if write_plot:
+            plt.plot([x.shift for x in events], label='From audio')
+
+        if args.grouping:
+            if not ignore_chapters and chapter_times:
+                groups = groups_from_chapters(events, chapter_times)
+                for g in groups:
+                    fix_near_borders(g)
+                    smooth_events([x for x in g if not x.linked], args.smooth_radius)
+                groups = split_broken_groups(groups)
+            else:
+                fix_near_borders(events)
+                smooth_events([x for x in events if not x.linked], args.smooth_radius)
+                groups = detect_groups(events)
+
+            if write_plot:
+                plt.plot([x.shift for x in events], label='Borders fixed')
+
+            for g in groups:
+                start_shift = g[0].shift
+                end_shift = g[-1].shift
+                avg_shift = average_shifts(g)
+                logging.info('Group (start: {0}, end: {1}, lines: {2}), '
+                             'shifts (start: {3}, end: {4}, average: {5})'
+                             .format(format_time(g[0].start), format_time(g[-1].end), len(g), start_shift, end_shift,
+                                     avg_shift))
+
+            if args.src_keyframes:
+                for e in (x for x in events if x.linked):
+                    e.resolve_link()
+                for g in groups:
+                    snap_groups_to_keyframes(g, chapter_times, args.max_ts_duration, args.max_ts_distance, src_keytimes,
+                                             dst_keytimes, src_timecodes, dst_timecodes, args.max_kf_distance, args.kf_mode)
+        else:
+            fix_near_borders(events)
+            if write_plot:
+                plt.plot([x.shift for x in events], label='Borders fixed')
+
+            if args.src_keyframes:
+                for e in (x for x in events if x.linked):
+                    e.resolve_link()
+                snap_groups_to_keyframes(events, chapter_times, args.max_ts_duration, args.max_ts_distance, src_keytimes,
+                                         dst_keytimes, src_timecodes, dst_timecodes, args.max_kf_distance, args.kf_mode)
+
+        for event in events:
+            event.apply_shift()
+
+        script.save_to_file(dst_script_path)
+
+        if write_plot:
+            plt.plot([x.shift + (x._start_shift + x._end_shift) / 2.0 for x in events], label='After correction')
+            plt.legend(fontsize=5, frameon=False, fancybox=False)
+            plt.savefig(args.plot_path, dpi=300)
+
+    finally:
+        if args.cleanup:
+            src_demuxer.cleanup()
+            dst_demuxer.cleanup()
diff --git a/backend/sushi/__main__.py b/backend/sushi/__main__.py
new file mode 100644
index 0000000..47582fd
--- /dev/null
+++ b/backend/sushi/__main__.py
@@ -0,0 +1,155 @@
+import argparse
+import logging
+import os
+import sys
+import time
+
+# Use absolute imports to support pyinstaller
+# https://github.com/pyinstaller/pyinstaller/issues/2560
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from sushi import run, VERSION
+from sushi.common import SushiError
+
+if sys.platform == 'win32':
+    try:
+        import colorama
+        colorama.init()
+        console_colors_supported = True
+    except ImportError:
+        console_colors_supported = False
+else:
+    console_colors_supported = True
+
+
+class ColoredLogFormatter(logging.Formatter):
+    bold_code = "\033[1m"
+    reset_code = "\033[0m"
+    grey_code = "\033[30m\033[1m"
+
+    error_format = "{bold}ERROR: %(message)s{reset}".format(bold=bold_code, reset=reset_code)
+    warn_format = "{bold}WARNING: %(message)s{reset}".format(bold=bold_code, reset=reset_code)
+    debug_format = "{grey}%(message)s{reset}".format(grey=grey_code, reset=reset_code)
+    default_format = "%(message)s"
+
+    def format(self, record):
+        if record.levelno == logging.DEBUG:
+            self._fmt = self.debug_format
+        elif record.levelno == logging.WARN:
+            self._fmt = self.warn_format
+        elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
+            self._fmt = self.error_format
+        else:
+            self._fmt = self.default_format
+
+        return super(ColoredLogFormatter, self).format(record)
+
+
+def create_arg_parser():
+    parser = argparse.ArgumentParser(description='Sushi - Automatic Subtitle Shifter')
+
+    parser.add_argument('--window', default=10, type=int, metavar='<size>', dest='window',
+                        help='Search window size. [%(default)s]')
+    parser.add_argument('--max-window', default=30, type=int, metavar='<size>', dest='max_window',
+                        help="Maximum search size Sushi is allowed to use when trying to recover from errors. [%(default)s]")
+    parser.add_argument('--rewind-thresh', default=5, type=int, metavar='<events>', dest='rewind_thresh',
+                        help="Number of consecutive errors Sushi has to encounter to consider results broken "
+                             "and retry with larger window. Set to 0 to disable. [%(default)s]")
+    parser.add_argument('--no-grouping', action='store_false', dest='grouping',
+                        help="Don't events into groups before shifting. Also disables error recovery.")
+    parser.add_argument('--max-kf-distance', default=2, type=float, metavar='<frames>', dest='max_kf_distance',
+                        help='Maximum keyframe snapping distance. [%(default)s]')
+    parser.add_argument('--kf-mode', default='all', choices=['shift', 'snap', 'all'], dest='kf_mode',
+                        help='Keyframes-based shift correction/snapping mode. [%(default)s]')
+    parser.add_argument('--smooth-radius', default=3, type=int, metavar='<events>', dest='smooth_radius',
+                        help='Radius of smoothing median filter. [%(default)s]')
+
+    # 10 frames at 23.976
+    parser.add_argument('--max-ts-duration', default=1001.0 / 24000.0 * 10, type=float, metavar='<seconds>',
+                        dest='max_ts_duration',
+                        help='Maximum duration of a line to be considered typesetting. [%(default).3f]')
+    # 10 frames at 23.976
+    parser.add_argument('--max-ts-distance', default=1001.0 / 24000.0 * 10, type=float, metavar='<seconds>',
+                        dest='max_ts_distance',
+                        help='Maximum distance between two adjacent typesetting lines to be merged. [%(default).3f]')
+
+    # deprecated/test options, do not use
+    parser.add_argument('--test-shift-plot', default=None, dest='plot_path', help=argparse.SUPPRESS)
+    parser.add_argument('--sample-type', default='uint8', choices=['float32', 'uint8'], dest='sample_type',
+                        help=argparse.SUPPRESS)
+
+    parser.add_argument('--sample-rate', default=12000, type=int, metavar='<rate>', dest='sample_rate',
+                        help='Downsampled audio sample rate. [%(default)s]')
+
+    parser.add_argument('--src-audio', default=None, type=int, metavar='<id>', dest='src_audio_idx',
+                        help='Audio stream index of the source video')
+    parser.add_argument('--src-script', default=None, type=int, metavar='<id>', dest='src_script_idx',
+                        help='Script stream index of the source video')
+    parser.add_argument('--dst-audio', default=None, type=int, metavar='<id>', dest='dst_audio_idx',
+                        help='Audio stream index of the destination video')
+    # files
+    parser.add_argument('--no-cleanup', action='store_false', dest='cleanup',
+                        help="Don't delete demuxed streams")
+    parser.add_argument('--temp-dir', default=None, dest='temp_dir', metavar='<string>',
+                        help='Specify temporary folder to use when demuxing stream.')
+    parser.add_argument('--chapters', default=None, dest='chapters_file', metavar='<filename>',
+                        help="XML or OGM chapters to use instead of any found in the source. 'none' to disable.")
+    parser.add_argument('--script', default=None, dest='script_file', metavar='<filename>',
+                        help='Subtitle file path to use instead of any found in the source')
+
+    parser.add_argument('--dst-keyframes', default=None, dest='dst_keyframes', metavar='<filename>',
+                        help='Destination keyframes file')
+    parser.add_argument('--src-keyframes', default=None, dest='src_keyframes', metavar='<filename>',
+                        help='Source keyframes file')
+    parser.add_argument('--dst-fps', default=None, type=float, dest='dst_fps', metavar='<fps>',
+                        help='Fps of the destination video. Must be provided if keyframes are used.')
+    parser.add_argument('--src-fps', default=None, type=float, dest='src_fps', metavar='<fps>',
+                        help='Fps of the source video. Must be provided if keyframes are used.')
+    parser.add_argument('--dst-timecodes', default=None, dest='dst_timecodes', metavar='<filename>',
+                        help='Timecodes file to use instead of making one from the destination (when possible)')
+    parser.add_argument('--src-timecodes', default=None, dest='src_timecodes', metavar='<filename>',
+                        help='Timecodes file to use instead of making one from the source (when possible)')
+
+    parser.add_argument('--src', required=True, dest="source", metavar='<filename>',
+                        help='Source audio/video')
+    parser.add_argument('--dst', required=True, dest="destination", metavar='<filename>',
+                        help='Destination audio/video')
+    parser.add_argument('-o', '--output', default=None, dest='output_script', metavar='<filename>',
+                        help='Output script')
+
+    parser.add_argument('-v', '--verbose', default=False, dest='verbose', action='store_true',
+                        help='Enable verbose logging')
+    parser.add_argument('--version', action='version', version=VERSION)
+
+    return parser
+
+
+def parse_args_and_run(cmd_keys):
+    def format_arg(arg):
+        return arg if ' ' not in arg else '"{0}"'.format(arg)
+
+    args = create_arg_parser().parse_args(cmd_keys)
+    handler = logging.StreamHandler()
+    if console_colors_supported and hasattr(sys.stderr, 'isatty') and sys.stderr.isatty():
+        # enable colors
+        handler.setFormatter(ColoredLogFormatter())
+    else:
+        handler.setFormatter(logging.Formatter(fmt=ColoredLogFormatter.default_format))
+    logging.root.addHandler(handler)
+    logging.root.setLevel(logging.DEBUG if args.verbose else logging.INFO)
+
+    logging.info("Sushi's running with arguments: {0}".format(' '.join(map(format_arg, cmd_keys))))
+    start_time = time.time()
+    run(args)
+    logging.info('Done in {0}s'.format(time.time() - start_time))
+
+
+def main():
+    try:
+        parse_args_and_run(sys.argv[1:])
+    except SushiError as e:
+        logging.critical(e.message)
+        sys.exit(2)
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/backend/sushi/chapters.py b/backend/sushi/chapters.py
new file mode 100644
index 0000000..56a239f
--- /dev/null
+++ b/backend/sushi/chapters.py
@@ -0,0 +1,37 @@
+import re
+from . import common
+
+
+def parse_times(times):
+    result = []
+    for t in times:
+        hours, minutes, seconds = list(map(float, t.split(':')))
+        result.append(hours * 3600 + minutes * 60 + seconds)
+
+    result.sort()
+    if result[0] != 0:
+        result.insert(0, 0)
+    return result
+
+
+def parse_xml_start_times(text):
+    times = re.findall(r'<ChapterTimeStart>(\d+:\d+:\d+\.\d+)</ChapterTimeStart>', text)
+    return parse_times(times)
+
+
+def get_xml_start_times(path):
+    return parse_xml_start_times(common.read_all_text(path))
+
+
+def parse_ogm_start_times(text):
+    times = re.findall(r'CHAPTER\d+=(\d+:\d+:\d+\.\d+)', text, flags=re.IGNORECASE)
+    return parse_times(times)
+
+
+def get_ogm_start_times(path):
+    return parse_ogm_start_times(common.read_all_text(path))
+
+
+def format_ogm_chapters(start_times):
+    return "\n".join("CHAPTER{0:02}={1}\nCHAPTER{0:02}NAME=".format(idx+1, common.format_srt_time(start).replace(',', '.'))
+                     for idx, start in enumerate(start_times)) + "\n"
\ No newline at end of file
diff --git a/backend/sushi/common.py b/backend/sushi/common.py
new file mode 100644
index 0000000..82a0428
--- /dev/null
+++ b/backend/sushi/common.py
@@ -0,0 +1,42 @@
+import os
+
+
+class SushiError(Exception):
+    pass
+
+
+def get_extension(path):
+    return (os.path.splitext(path)[1]).lower()
+
+
+def read_all_text(path):
+    with open(path) as file:
+        return file.read()
+
+
+def ensure_static_collection(value):
+    if isinstance(value, (set, list, tuple)):
+        return value
+    return list(value)
+
+
+def format_srt_time(seconds):
+    cs = round(seconds * 1000)
+    return '{0:02d}:{1:02d}:{2:02d},{3:03d}'.format(
+        int(cs // 3600000),
+        int((cs // 60000) % 60),
+        int((cs // 1000) % 60),
+        int(cs % 1000))
+
+
+def format_time(seconds):
+    cs = round(seconds * 100)
+    return '{0}:{1:02d}:{2:02d}.{3:02d}'.format(
+        int(cs // 360000),
+        int((cs // 6000) % 60),
+        int((cs // 100) % 60),
+        int(cs % 100))
+
+
+def clip(value, minimum, maximum):
+    return max(min(value, maximum), minimum)
\ No newline at end of file
diff --git a/backend/sushi/demux.py b/backend/sushi/demux.py
new file mode 100644
index 0000000..51eae44
--- /dev/null
+++ b/backend/sushi/demux.py
@@ -0,0 +1,358 @@
+import os
+import re
+import subprocess
+from collections import namedtuple
+import logging
+import bisect
+
+import imageio_ffmpeg
+from .common import SushiError, get_extension
+from . import chapters
+
+MediaStreamInfo = namedtuple('MediaStreamInfo', ['id', 'info', 'default', 'title'])
+SubtitlesStreamInfo = namedtuple('SubtitlesStreamInfo', ['id', 'info', 'type', 'default', 'title'])
+MediaInfo = namedtuple('MediaInfo', ['video', 'audio', 'subtitles', 'chapters'])
+ffmpeg_path = imageio_ffmpeg.get_ffmpeg_exe()
+
+class FFmpeg(object):
+    @staticmethod
+    def get_info(path):
+        try:
+            # text=True is an alias for universal_newlines since 3.7
+            process = subprocess.Popen([ffmpeg_path, '-hide_banner', '-i', path], stderr=subprocess.PIPE, universal_newlines=True)
+            out, err = process.communicate()
+            process.wait()
+            return err
+        except OSError as e:
+            if e.errno == 2:
+                raise SushiError("Couldn't invoke ffmpeg, check that it's installed")
+            raise
+
+    @staticmethod
+    def demux_file(input_path, **kwargs):
+        args = [ffmpeg_path, '-hide_banner', '-i', input_path, '-y']
+
+        audio_stream = kwargs.get('audio_stream', None)
+        audio_path = kwargs.get('audio_path', None)
+        audio_rate = kwargs.get('audio_rate', None)
+        if audio_stream is not None:
+            args.extend(('-map', '0:{0}'.format(audio_stream)))
+            if audio_rate:
+                args.extend(('-ar', str(audio_rate)))
+            args.extend(('-ac', '1', '-acodec', 'pcm_s16le', audio_path))
+
+        script_stream = kwargs.get('script_stream', None)
+        script_path = kwargs.get('script_path', None)
+        if script_stream is not None:
+            args.extend(('-map', '0:{0}'.format(script_stream), script_path))
+
+        video_stream = kwargs.get('video_stream', None)
+        timecodes_path = kwargs.get('timecodes_path', None)
+        if timecodes_path is not None:
+            args.extend(('-map', '0:{0}'.format(video_stream), '-f', 'mkvtimestamp_v2', timecodes_path))
+
+        logging.info('ffmpeg args: {0}'.format(' '.join(('"{0}"' if ' ' in a else '{0}').format(a) for a in args)))
+        try:
+            subprocess.call(args)
+        except OSError as e:
+            if e.errno == 2:
+                raise SushiError("Couldn't invoke ffmpeg, check that it's installed")
+            raise
+
+    @staticmethod
+    def _get_audio_streams(info):
+        streams = re.findall(r'Stream\s\#0:(\d+).*?Audio:\s*(.*?(?:\((default)\))?)\s*?(?:\(forced\))?\r?\n'
+                             r'(?:\s*Metadata:\s*\r?\n'
+                             r'\s*title\s*:\s*(.*?)\r?\n)?',
+                             info, flags=re.VERBOSE)
+        return [MediaStreamInfo(int(x[0]), x[1], x[2] != '', x[3]) for x in streams]
+
+    @staticmethod
+    def _get_video_streams(info):
+        streams = re.findall(r'Stream\s\#0:(\d+).*?Video:\s*(.*?(?:\((default)\))?)\s*?(?:\(forced\))?\r?\n'
+                             r'(?:\s*Metadata:\s*\r?\n'
+                             r'\s*title\s*:\s*(.*?)\r?\n)?',
+                             info, flags=re.VERBOSE)
+        return [MediaStreamInfo(int(x[0]), x[1], x[2] != '', x[3]) for x in streams]
+
+    @staticmethod
+    def _get_chapters_times(info):
+        return list(map(float, re.findall(r'Chapter #0.\d+: start (\d+\.\d+)', info)))
+
+    @staticmethod
+    def _get_subtitles_streams(info):
+        maps = {
+            'ssa': '.ass',
+            'ass': '.ass',
+            'subrip': '.srt'
+        }
+
+        streams = re.findall(r'Stream\s\#0:(\d+).*?Subtitle:\s*((\w*)\s*?(?:\((default)\))?\s*?(?:\(forced\))?)\r?\n'
+                             r'(?:\s*Metadata:\s*\r?\n'
+                             r'\s*title\s*:\s*(.*?)\r?\n)?',
+                             info, flags=re.VERBOSE)
+        return [SubtitlesStreamInfo(int(x[0]), x[1], maps.get(x[2], x[2]), x[3] != '', x[4].strip()) for x in streams]
+
+    @classmethod
+    def get_media_info(cls, path):
+        info = cls.get_info(path)
+        video_streams = cls._get_video_streams(info)
+        audio_streams = cls._get_audio_streams(info)
+        subs_streams = cls._get_subtitles_streams(info)
+        chapter_times = cls._get_chapters_times(info)
+        return MediaInfo(video_streams, audio_streams, subs_streams, chapter_times)
+
+
+class MkvToolnix(object):
+    @classmethod
+    def extract_timecodes(cls, mkv_path, stream_idx, output_path):
+        args = ['mkvextract', 'timecodes_v2', mkv_path, '{0}:{1}'.format(stream_idx, output_path)]
+        subprocess.call(args)
+
+
+class SCXviD(object):
+    @classmethod
+    def make_keyframes(cls, video_path, log_path):
+        try:
+            ffmpeg_process = subprocess.Popen([ffmpeg_path, '-i', video_path,
+                                               '-f', 'yuv4mpegpipe',
+                                               '-vf', 'scale=640:360',
+                                               '-pix_fmt', 'yuv420p',
+                                               '-vsync', 'drop', '-'],
+                                              stdout=subprocess.PIPE)
+        except OSError as e:
+            if e.errno == 2:
+                raise SushiError("Couldn't invoke ffmpeg, check that it's installed")
+            raise
+
+        try:
+            scxvid_process = subprocess.Popen(['SCXvid', log_path], stdin=ffmpeg_process.stdout)
+        except OSError as e:
+            ffmpeg_process.kill()
+            if e.errno == 2:
+                raise SushiError("Couldn't invoke scxvid, check that it's installed")
+            raise
+        scxvid_process.wait()
+
+
+class Timecodes(object):
+    def __init__(self, times, default_fps):
+        super(Timecodes, self).__init__()
+        self.times = times
+        self.default_frame_duration = 1.0 / default_fps if default_fps else None
+
+    def get_frame_time(self, number):
+        try:
+            return self.times[number]
+        except IndexError:
+            if not self.default_frame_duration:
+                return self.get_frame_time(len(self.times) - 1)
+            if self.times:
+                return self.times[-1] + (self.default_frame_duration) * (number - len(self.times) + 1)
+            else:
+                return number * self.default_frame_duration
+
+    def get_frame_number(self, timestamp):
+        if (not self.times or self.times[-1] < timestamp) and self.default_frame_duration:
+            return int((timestamp - sum(self.times)) / self.default_frame_duration)
+        return bisect.bisect_left(self.times, timestamp)
+
+    def get_frame_size(self, timestamp):
+        try:
+            number = bisect.bisect_left(self.times, timestamp)
+        except Exception:
+            return self.default_frame_duration
+
+        c = self.get_frame_time(number)
+
+        if number == len(self.times):
+            p = self.get_frame_time(number - 1)
+            return c - p
+        else:
+            n = self.get_frame_time(number + 1)
+            return n - c
+
+    @classmethod
+    def _convert_v1_to_v2(cls, default_fps, overrides):
+        # start, end, fps
+        overrides = [(int(x[0]), int(x[1]), float(x[2])) for x in overrides]
+        if not overrides:
+            return []
+
+        fps = [default_fps] * (overrides[-1][1] + 1)
+        for o in overrides:
+            fps[o[0]:o[1] + 1] = [o[2]] * (o[1] - o[0] + 1)
+
+        v2 = [0]
+        for d in (1.0 / f for f in fps):
+            v2.append(v2[-1] + d)
+        return v2
+
+    @classmethod
+    def parse(cls, text):
+        lines = text.splitlines()
+        if not lines:
+            return []
+        first = lines[0].lower().lstrip()
+        if first.startswith('# timecode format v2') or first.startswith('# timestamp format v2'):
+            tcs = [float(x) / 1000.0 for x in lines[1:]]
+            return Timecodes(tcs, None)
+        elif first.startswith('# timecode format v1'):
+            default = float(lines[1].lower().replace('assume ', ""))
+            overrides = (x.split(',') for x in lines[2:])
+            return Timecodes(cls._convert_v1_to_v2(default, overrides), default)
+        else:
+            raise SushiError('This timecodes format is not supported')
+
+    @classmethod
+    def from_file(cls, path):
+        with open(path) as file:
+            return cls.parse(file.read())
+
+    @classmethod
+    def cfr(cls, fps):
+        class CfrTimecodes(object):
+            def __init__(self, fps):
+                self.frame_duration = 1.0 / fps
+
+            def get_frame_time(self, number):
+                return number * self.frame_duration
+
+            def get_frame_size(self, timestamp):
+                return self.frame_duration
+
+            def get_frame_number(self, timestamp):
+                return int(timestamp / self.frame_duration)
+
+        return CfrTimecodes(fps)
+
+
+class Demuxer(object):
+    def __init__(self, path):
+        super(Demuxer, self).__init__()
+        self._path = path
+        self._is_wav = get_extension(self._path) == '.wav'
+        self._mi = None if self._is_wav else FFmpeg.get_media_info(self._path)
+        self._demux_audio = self._demux_subs = self._make_timecodes = self._make_keyframes = self._write_chapters = False
+
+    @property
+    def is_wav(self):
+        return self._is_wav
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def chapters(self):
+        if self.is_wav:
+            return []
+        return self._mi.chapters
+
+    @property
+    def has_video(self):
+        return not self.is_wav and self._mi.video
+
+    def set_audio(self, stream_idx, output_path, sample_rate):
+        self._audio_stream = self._select_stream(self._mi.audio, stream_idx, 'audio')
+        self._audio_output_path = output_path
+        self._audio_sample_rate = sample_rate
+        self._demux_audio = True
+
+    def set_script(self, stream_idx, output_path):
+        self._script_stream = self._select_stream(self._mi.subtitles, stream_idx, 'subtitles')
+        self._script_output_path = output_path
+        self._demux_subs = True
+
+    def set_timecodes(self, output_path):
+        self._timecodes_output_path = output_path
+        self._make_timecodes = True
+
+    def set_chapters(self, output_path):
+        self._write_chapters = True
+        self._chapters_output_path = output_path
+
+    def set_keyframes(self, output_path):
+        self._keyframes_output_path = output_path
+        self._make_keyframes = True
+
+    def get_subs_type(self, stream_idx):
+        return self._select_stream(self._mi.subtitles, stream_idx, 'subtitles').type
+
+    def demux(self):
+        if self._write_chapters:
+            with open(self._chapters_output_path, "w") as output_file:
+                output_file.write(chapters.format_ogm_chapters(self.chapters))
+
+        if self._make_keyframes:
+            SCXviD.make_keyframes(self._path, self._keyframes_output_path)
+
+        ffargs = {}
+        if self._demux_audio:
+            ffargs['audio_stream'] = self._audio_stream.id
+            ffargs['audio_path'] = self._audio_output_path
+            ffargs['audio_rate'] = self._audio_sample_rate
+        if self._demux_subs:
+            ffargs['script_stream'] = self._script_stream.id
+            ffargs['script_path'] = self._script_output_path
+
+        if self._make_timecodes:
+            def set_ffmpeg_timecodes():
+                ffargs['video_stream'] = self._mi.video[0].id
+                ffargs['timecodes_path'] = self._timecodes_output_path
+
+            if get_extension(self._path).lower() == '.mkv':
+                try:
+                    MkvToolnix.extract_timecodes(self._path,
+                                                 stream_idx=self._mi.video[0].id,
+                                                 output_path=self._timecodes_output_path)
+                except OSError as e:
+                    if e.errno == 2:
+                        set_ffmpeg_timecodes()
+                    else:
+                        raise
+            else:
+                set_ffmpeg_timecodes()
+
+        if ffargs:
+            FFmpeg.demux_file(self._path, **ffargs)
+
+    def cleanup(self):
+        if self._demux_audio:
+            os.remove(self._audio_output_path)
+        if self._demux_subs:
+            os.remove(self._script_output_path)
+        if self._make_timecodes:
+            os.remove(self._timecodes_output_path)
+        if self._write_chapters:
+            os.remove(self._chapters_output_path)
+
+    @classmethod
+    def _format_stream(cls, stream):
+        return '{0}{1}: {2}'.format(stream.id, ' (%s)' % stream.title if stream.title else '', stream.info)
+
+    @classmethod
+    def _format_streams_list(cls, streams):
+        return '\n'.join(map(cls._format_stream, streams))
+
+    def _select_stream(self, streams, chosen_idx, name):
+        if not streams:
+            raise SushiError('No {0} streams found in {1}'.format(name, self._path))
+        if chosen_idx is None:
+            if len(streams) > 1:
+                default_track = next((s for s in streams if s.default), None)
+                if default_track:
+                    logging.warning('Using default track {0} in {1} because there are multiple candidates'
+                                    .format(self._format_stream(default_track), self._path))
+                    return default_track
+                raise SushiError('More than one {0} stream found in {1}.'
+                                 'You need to specify the exact one to demux. Here are all candidates:\n'
+                                 '{2}'.format(name, self._path, self._format_streams_list(streams)))
+            return streams[0]
+
+        try:
+            return next(x for x in streams if x.id == chosen_idx)
+        except StopIteration:
+            raise SushiError("Stream with index {0} doesn't exist in {1}.\n"
+                             "Here are all that do:\n"
+                             "{2}".format(chosen_idx, self._path, self._format_streams_list(streams)))
\ No newline at end of file
diff --git a/backend/sushi/keyframes.py b/backend/sushi/keyframes.py
new file mode 100644
index 0000000..7c38513
--- /dev/null
+++ b/backend/sushi/keyframes.py
@@ -0,0 +1,16 @@
+from .common import SushiError, read_all_text
+
+
+def parse_scxvid_keyframes(text):
+    return [i - 3 for i, line in enumerate(text.splitlines()) if line and line[0] == 'i']
+
+
+def parse_keyframes(path):
+    text = read_all_text(path)
+    if '# XviD 2pass stat file' in text:
+        frames = parse_scxvid_keyframes(text)
+    else:
+        raise SushiError('Unsupported keyframes type')
+    if 0 not in frames:
+        frames.insert(0, 0)
+    return frames
\ No newline at end of file
diff --git a/backend/sushi/regression-tests.py b/backend/sushi/regression-tests.py
new file mode 100644
index 0000000..5481992
--- /dev/null
+++ b/backend/sushi/regression-tests.py
@@ -0,0 +1,214 @@
+from contextlib import contextmanager
+import json
+import logging
+import os
+import gc
+import sys
+import resource
+import re
+import subprocess
+import argparse
+
+from .common import format_time
+from .demux import Timecodes
+from .subs import AssScript
+from .wav import WavStream
+
+
+root_logger = logging.getLogger('')
+
+
+def strip_tags(text):
+    return re.sub(r'{.*?}', " ", text)
+
+
+@contextmanager
+def set_file_logger(path):
+    handler = logging.FileHandler(path, mode='a')
+    handler.setLevel(logging.DEBUG)
+    handler.setFormatter(logging.Formatter('%(message)s'))
+    root_logger.addHandler(handler)
+    try:
+        yield
+    finally:
+        root_logger.removeHandler(handler)
+
+
+def compare_scripts(ideal_path, test_path, timecodes, test_name, expected_errors):
+    ideal_script = AssScript.from_file(ideal_path)
+    test_script = AssScript.from_file(test_path)
+    if len(test_script.events) != len(ideal_script.events):
+        logging.critical("Script length didn't match: {0} in ideal vs {1} in test. Test {2}".format(
+            len(ideal_script.events), len(test_script.events), test_name)
+        )
+        return False
+    ideal_script.sort_by_time()
+    test_script.sort_by_time()
+    failed = 0
+    ft = format_time
+    for idx, (ideal, test) in enumerate(zip(ideal_script.events, test_script.events)):
+        ideal_start_frame = timecodes.get_frame_number(ideal.start)
+        ideal_end_frame = timecodes.get_frame_number(ideal.end)
+
+        test_start_frame = timecodes.get_frame_number(test.start)
+        test_end_frame = timecodes.get_frame_number(test.end)
+
+        if ideal_start_frame != test_start_frame and ideal_end_frame != test_end_frame:
+            logging.debug('{0}: start and end time failed at "{1}". {2}-{3} vs {4}-{5}'.format(
+                idx, strip_tags(ideal.text), ft(ideal.start), ft(ideal.end), ft(test.start), ft(test.end))
+            )
+            failed += 1
+        elif ideal_end_frame != test_end_frame:
+            logging.debug(
+                '{0}: end time failed at "{1}". {2} vs {3}'.format(
+                    idx, strip_tags(ideal.text), ft(ideal.end), ft(test.end))
+            )
+            failed += 1
+        elif ideal_start_frame != test_start_frame:
+            logging.debug(
+                '{0}: start time failed at "{1}". {2} vs {3}'.format(
+                    idx, strip_tags(ideal.text), ft(ideal.start), ft(test.start))
+            )
+            failed += 1
+
+    logging.info('Total lines: {0}, good: {1}, failed: {2}'.format(len(ideal_script.events), len(ideal_script.events) - failed, failed))
+
+    if failed > expected_errors:
+        logging.critical('Got more failed lines than expected ({0} actual vs {1} expected)'.format(failed, expected_errors))
+        return False
+    elif failed < expected_errors:
+        logging.critical('Got less failed lines than expected ({0} actual vs {1} expected)'.format(failed, expected_errors))
+        return False
+    else:
+        logging.critical('Met expectations')
+        return True
+
+
+def run_test(base_path, plots_path, test_name, params):
+    def safe_add_key(args, key, name):
+        if name in params:
+            args.extend((key, str(params[name])))
+
+    def safe_add_path(args, folder, key, name):
+        if name in params:
+            args.extend((key, os.path.join(folder, params[name])))
+
+    logging.info('Testing "{0}"'.format(test_name))
+
+    folder = os.path.join(base_path, params['folder'])
+
+    cmd = ["sushi"]
+
+    safe_add_path(cmd, folder, '--src', 'src')
+    safe_add_path(cmd, folder, '--dst', 'dst')
+    safe_add_path(cmd, folder, '--src-keyframes', 'src-keyframes')
+    safe_add_path(cmd, folder, '--dst-keyframes', 'dst-keyframes')
+    safe_add_path(cmd, folder, '--src-timecodes', 'src-timecodes')
+    safe_add_path(cmd, folder, '--dst-timecodes', 'dst-timecodes')
+    safe_add_path(cmd, folder, '--script', 'script')
+    safe_add_path(cmd, folder, '--chapters', 'chapters')
+    safe_add_path(cmd, folder, '--src-script', 'src-script')
+    safe_add_path(cmd, folder, '--dst-script', 'dst-script')
+    safe_add_key(cmd, '--max-kf-distance', 'max-kf-distance')
+    safe_add_key(cmd, '--max-ts-distance', 'max-ts-distance')
+    safe_add_key(cmd, '--max-ts-duration', 'max-ts-duration')
+
+    output_path = os.path.join(folder, params['dst']) + '.sushi.test.ass'
+    cmd.extend(('-o', output_path))
+    if plots_path:
+        cmd.extend(('--test-shift-plot', os.path.join(plots_path, '{0}.png'.format(test_name))))
+
+    log_path = os.path.join(folder, 'sushi_test.log')
+
+    with open(log_path, "w") as log_file:
+        try:
+            subprocess.call(cmd, stderr=log_file, stdout=log_file)
+        except Exception as e:
+            logging.critical('Sushi failed on test "{0}": {1}'.format(test_name, e.message))
+            return False
+
+    with set_file_logger(log_path):
+        ideal_path = os.path.join(folder, params['ideal'])
+        try:
+            timecodes = Timecodes.from_file(os.path.join(folder, params['dst-timecodes']))
+        except KeyError:
+            timecodes = Timecodes.cfr(params['fps'])
+
+        return compare_scripts(ideal_path, output_path, timecodes, test_name, params['expected_errors'])
+
+
+def run_wav_test(test_name, file_path, params):
+    gc.collect(2)
+
+    before = resource.getrusage(resource.RUSAGE_SELF)
+    _ = WavStream(file_path, params.get('sample_rate', 12000), params.get('sample_type', 'uint8'))
+    after = resource.getrusage(resource.RUSAGE_SELF)
+
+    total_time = (after.ru_stime - before.ru_stime) + (after.ru_utime - before.ru_utime)
+    ram_difference = (after.ru_maxrss - before.ru_maxrss) / 1024.0 / 1024.0
+
+    if 'max_time' in params and total_time > params['max_time']:
+        logging.critical('Loading "{0}" took too much time: {1} vs {2} seconds'
+                         .format(test_name, total_time, params['max_time']))
+        return False
+    if 'max_memory' in params and ram_difference > params['max_memory']:
+        logging.critical('Loading "{0}" consumed too much RAM: {1} vs {2}'
+                         .format(test_name, ram_difference, params['max_memory']))
+        return False
+    return True
+
+
+def create_arg_parser():
+    parser = argparse.ArgumentParser(description='Sushi regression testing util')
+
+    parser.add_argument('--only', dest="run_only", nargs="*", metavar='<test names>',
+                        help='Test names to run')
+    parser.add_argument('-c', '--conf', default="tests.json", dest='conf_path', metavar='<filename>',
+                        help='Config file path')
+
+    return parser
+
+
+def run():
+    root_logger.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(logging.Formatter('%(message)s'))
+    root_logger.addHandler(console_handler)
+
+    args = create_arg_parser().parse_args()
+
+    try:
+        with open(args.conf_path) as file:
+            config = json.load(file)
+    except IOError as e:
+        logging.critical(e)
+        sys.exit(2)
+
+    def should_run(name):
+        return not args.run_only or name in args.run_only
+
+    failed = ran = 0
+    for test_name, params in config.get('tests', {}).items():
+        if not should_run(test_name):
+            continue
+        if not params.get('disabled', False):
+            ran += 1
+            if not run_test(config['basepath'], config['plots'], test_name, params):
+                failed += 1
+            logging.info('')
+        else:
+            logging.warn('Test "{0}" disabled'.format(test_name))
+
+    if should_run("wavs"):
+        for test_name, params in config.get('wavs', {}).items():
+            ran += 1
+            if not run_wav_test(test_name, os.path.join(config['basepath'], params['file']), params):
+                failed += 1
+            logging.info('')
+
+    logging.info('Ran {0} tests, {1} failed'.format(ran, failed))
+
+
+if __name__ == '__main__':
+    run()
\ No newline at end of file
diff --git a/backend/sushi/run.bat b/backend/sushi/run.bat
new file mode 100644
index 0000000..ebd2469
--- /dev/null
+++ b/backend/sushi/run.bat
@@ -0,0 +1,4 @@
+cd /d %~dp0
+CALL conda activate Sushi
+python run.py %*
+pause
\ No newline at end of file
diff --git a/backend/sushi/subs.py b/backend/sushi/subs.py
new file mode 100644
index 0000000..fe8008d
--- /dev/null
+++ b/backend/sushi/subs.py
@@ -0,0 +1,275 @@
+import codecs
+import os
+import re
+import collections
+import chardet
+
+from .common import SushiError, format_time, format_srt_time
+
+
+def _parse_ass_time(string):
+    hours, minutes, seconds = map(float, string.split(':'))
+    return hours * 3600 + minutes * 60 + seconds
+
+
+class ScriptEventBase(object):
+    def __init__(self, source_index, start, end, text):
+        self.source_index = source_index
+        self.start = start
+        self.end = end
+        self.text = text
+
+        self._shift = 0
+        self._diff = 1
+        self._linked_event = None
+        self._start_shift = 0
+        self._end_shift = 0
+
+    @property
+    def shift(self):
+        return self._linked_event.shift if self.linked else self._shift
+
+    @property
+    def diff(self):
+        return self._linked_event.diff if self.linked else self._diff
+
+    @property
+    def duration(self):
+        return self.end - self.start
+
+    @property
+    def shifted_end(self):
+        return self.end + self.shift + self._end_shift
+
+    @property
+    def shifted_start(self):
+        return self.start + self.shift + self._start_shift
+
+    def apply_shift(self):
+        self.start = self.shifted_start
+        self.end = self.shifted_end
+
+    def set_shift(self, shift, audio_diff):
+        assert not self.linked, 'Cannot set shift of a linked event'
+        self._shift = shift
+        self._diff = audio_diff
+
+    def adjust_additional_shifts(self, start_shift, end_shift):
+        assert not self.linked, 'Cannot apply additional shifts to a linked event'
+        self._start_shift += start_shift
+        self._end_shift += end_shift
+
+    def get_link_chain_end(self):
+        return self._linked_event.get_link_chain_end() if self.linked else self
+
+    def link_event(self, other):
+        assert other.get_link_chain_end() is not self, 'Circular link detected'
+        self._linked_event = other
+
+    def resolve_link(self):
+        assert self.linked, 'Cannot resolve unlinked events'
+        self._shift = self._linked_event.shift
+        self._diff = self._linked_event.diff
+        self._linked_event = None
+
+    @property
+    def linked(self):
+        return self._linked_event is not None
+
+    def adjust_shift(self, value):
+        assert not self.linked, 'Cannot adjust time of linked events'
+        self._shift += value
+
+
+class ScriptBase(object):
+    def __init__(self, events):
+        self.events = events
+
+    def sort_by_time(self):
+        self.events.sort(key=lambda x: x.start)
+
+
+class SrtEvent(ScriptEventBase):
+    is_comment = False
+    style = None
+
+    EVENT_REGEX = re.compile(r"""
+                               (\d+?)\s+? # line-number
+                               (\d{1,2}:\d{1,2}:\d{1,2},\d+)\s-->\s(\d{1,2}:\d{1,2}:\d{1,2},\d+).  # timestamp
+                               (.+?) # actual text
+                           (?= # lookahead for the next line or end of the file
+                               (?:\d+?\s+? # line-number
+                               \d{1,2}:\d{1,2}:\d{1,2},\d+\s-->\s\d{1,2}:\d{1,2}:\d{1,2},\d+) # timestamp
+                               |$
+                           )""", flags=re.VERBOSE | re.DOTALL)
+
+    @classmethod
+    def from_string(cls, text):
+        match = cls.EVENT_REGEX.match(text)
+        start = cls.parse_time(match.group(2))
+        end = cls.parse_time(match.group(3))
+        return SrtEvent(int(match.group(1)), start, end, match.group(4).strip())
+
+    def __str__(self):
+        return '{0}\n{1} --> {2}\n{3}'.format(self.source_index, self._format_time(self.start),
+                                              self._format_time(self.end), self.text)
+
+    @staticmethod
+    def parse_time(time_string):
+        return _parse_ass_time(time_string.replace(',', '.'))
+
+    @staticmethod
+    def _format_time(seconds):
+        return format_srt_time(seconds)
+
+
+class SrtScript(ScriptBase):
+    @classmethod
+    def from_file(cls, path):
+        try:
+            with codecs.open(path, encoding='utf-8-sig') as script:
+                text = script.read()
+                events_list = [SrtEvent(
+                    source_index=int(match.group(1)),
+                    start=SrtEvent.parse_time(match.group(2)),
+                    end=SrtEvent.parse_time(match.group(3)),
+                    text=match.group(4).strip()
+                ) for match in SrtEvent.EVENT_REGEX.finditer(text)]
+                return cls(events_list)
+        except IOError:
+            raise SushiError("Script {0} not found".format(path))
+
+    def save_to_file(self, path):
+        text = '\n\n'.join(map(str, self.events))
+        with codecs.open(path, encoding='utf-8', mode='w') as script:
+            script.write(text)
+
+
+class AssEvent(ScriptEventBase):
+    def __init__(self, text, position=0):
+        kind, _, rest = text.partition(':')
+        split = [x.strip() for x in rest.split(',', 9)]
+
+        super(AssEvent, self).__init__(
+            source_index=position,
+            start=_parse_ass_time(split[1]),
+            end=_parse_ass_time(split[2]),
+            text=split[9]
+        )
+        self.kind = kind
+        self.is_comment = self.kind.lower() == 'comment'
+        self.layer = split[0]
+        self.style = split[3]
+        self.name = split[4]
+        self.margin_left = split[5]
+        self.margin_right = split[6]
+        self.margin_vertical = split[7]
+        self.effect = split[8]
+
+    def __str__(self):
+        return '{0}: {1},{2},{3},{4},{5},{6},{7},{8},{9},{10}'.format(self.kind, self.layer,
+                                                                      self._format_time(self.start),
+                                                                      self._format_time(self.end),
+                                                                      self.style, self.name,
+                                                                      self.margin_left, self.margin_right,
+                                                                      self.margin_vertical, self.effect,
+                                                                      self.text)
+
+    @staticmethod
+    def _format_time(seconds):
+        return format_time(seconds)
+
+
+class AssScript(ScriptBase):
+    def __init__(self, script_info, styles, events, other):
+        super(AssScript, self).__init__(events)
+        self.script_info = script_info
+        self.styles = styles
+        self.other = other
+
+    @classmethod
+    def from_file(cls, path):
+        script_info, styles, events = [], [], []
+        other_sections = collections.OrderedDict()
+
+        def parse_script_info_line(line):
+            if line.startswith('Format:'):
+                return
+            script_info.append(line)
+
+        def parse_styles_line(line):
+            if line.startswith('Format:'):
+                return
+            styles.append(line)
+
+        def parse_event_line(line):
+            if line.startswith('Format:'):
+                return
+            events.append(AssEvent(line, position=len(events) + 1))
+
+        def create_generic_parse(section_name):
+            if section_name in other_sections:
+                raise SushiError("Duplicate section detected, invalid script?")
+            other_sections[section_name] = []
+            return other_sections[section_name].append
+
+        parse_function = None
+
+        try:
+            rawdata = open(path, 'rb').read()
+            result = chardet.detect(rawdata)
+            print(result)
+            with codecs.open(path, encoding=result['encoding']) as script:
+                for line_idx, line in enumerate(script):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    low = line.lower()
+                    if low == '[script info]':
+                        parse_function = parse_script_info_line
+                    elif low == '[v4+ styles]':
+                        parse_function = parse_styles_line
+                    elif low == '[events]':
+                        parse_function = parse_event_line
+                    elif re.match(r'\[.+?\]', low):
+                        parse_function = create_generic_parse(line)
+                    elif not parse_function:
+                        raise SushiError("That's some invalid ASS script")
+                    else:
+                        try:
+                            parse_function(line)
+                        except Exception as e:
+                            raise SushiError("That's some invalid ASS script: {0} [line {1}]".format(e.message, line_idx))
+        except IOError:
+            raise SushiError("Script {0} not found".format(path))
+        return cls(script_info, styles, events, other_sections)
+
+    def save_to_file(self, path):
+        # if os.path.exists(path):
+        #     raise RuntimeError('File %s already exists' % path)
+        lines = []
+        if self.script_info:
+            lines.append('[Script Info]')
+            lines.extend(self.script_info)
+            lines.append('')
+
+        if self.styles:
+            lines.append('[V4+ Styles]')
+            lines.append('Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding')
+            lines.extend(self.styles)
+            lines.append('')
+
+        if self.events:
+            events = sorted(self.events, key=lambda x: x.source_index)
+            lines.append('[Events]')
+            lines.append('Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text')
+            lines.extend(map(str, events))
+
+        if self.other:
+            for section_name, section_lines in self.other.items():
+                lines.append('')
+                lines.append(section_name)
+                lines.extend(section_lines)
+
+        with codecs.open(path, encoding='utf-8-sig', mode='w') as script:
+            script.write(str(os.linesep).join(lines))
\ No newline at end of file
diff --git a/backend/sushi/sushi.bat b/backend/sushi/sushi.bat
new file mode 100644
index 0000000..7d63602
--- /dev/null
+++ b/backend/sushi/sushi.bat
@@ -0,0 +1,8 @@
+cd /d %~dp0
+CALL conda activate Sushi
+ffmpeg -i %1 %1.wav
+ffmpeg -i %2 %2.wav
+python sushi.py --src %1.wav --dst %2.wav --script %3
+del /Q /F %1.wav
+del /Q /F %2.wav
+rem pause
\ No newline at end of file
diff --git a/backend/sushi/sushi_main.py b/backend/sushi/sushi_main.py
new file mode 100644
index 0000000..3300aa5
--- /dev/null
+++ b/backend/sushi/sushi_main.py
@@ -0,0 +1,72 @@
+# -*- coding: UTF-8 -*-
+import sys
+import os
+import re
+from pathlib import Path
+from .__main__ import parse_args_and_run
+
+def subtitle_sync(argv, opts=None):
+    videos = []
+    isAss = False
+    if len(argv) < 3:
+        print("参数不足, 程序退出")
+        exit()
+    for arg in argv:
+        if re.search('\\.(ass)$', arg, flags=re.I) is not None:
+            subtitle = arg
+            isAss = True
+        elif re.search('\\.(srt)$', arg, flags=re.I) is not None:
+            subtitle = arg
+        else:
+            videos.append(arg)
+    print(("字幕文件:", subtitle))
+    if subtitle is None:
+        print("未找到字幕文件, 程序退出")
+        exit()
+
+    if os.path.getsize(videos[0]) > os.path.getsize(videos[1]):
+        bdVideo = videos[0]
+        hdVideo = videos[1]
+    else:
+        bdVideo = videos[1]
+        hdVideo = videos[0]
+    print(("HD:", hdVideo))
+    print(("BD:", bdVideo))
+
+    temp_dir = None
+    if opts is not None:
+        if "temp" in opts:
+            temp_dir = opts["temp"]
+
+    if temp_dir is not None:
+        hdWav = os.path.join(temp_dir, os.path.basename(hdVideo) + '.wav')
+        bdWav = os.path.join(temp_dir, os.path.basename(bdVideo) + '.wav')
+        Path(temp_dir).mkdir(parents=True, exist_ok=True)
+    else:
+        hdWav = hdVideo + '.wav'
+        bdWav = bdVideo + '.wav'
+
+    os.system('ffmpeg -y -i "{0}" "{1}"'.format(hdVideo, hdWav))
+    os.system('ffmpeg -y -i "{0}" "{1}"'.format(bdVideo, bdWav))
+
+    (prefix, sep, suffix) = bdVideo.rpartition('.')
+
+    if isAss:
+        output = re.sub('\\.' + suffix + '$', ".ass", bdVideo, flags= re.I)
+    else:
+        output = re.sub('\\.' + suffix + '$', ".srt", bdVideo, flags= re.I)
+
+    parse_args_and_run([
+        "--src", hdWav,
+        "--dst", bdWav,
+        "--script", subtitle,
+        "--output", output,
+    ])
+
+    os.remove(hdWav)
+    os.remove(bdWav)
+    print(("finish", output))
+
+if __name__ == '__main__':
+    subtitle_sync(sys.argv[1:], None)
+
diff --git a/backend/sushi/wav.py b/backend/sushi/wav.py
new file mode 100644
index 0000000..c3cc9b1
--- /dev/null
+++ b/backend/sushi/wav.py
@@ -0,0 +1,190 @@
+import logging
+import cv2
+import numpy as np
+from chunk import Chunk
+import struct
+import math
+from time import time
+import os.path
+
+from .common import SushiError, clip
+from functools import reduce
+
+WAVE_FORMAT_PCM = 0x0001
+WAVE_FORMAT_EXTENSIBLE = 0xFFFE
+
+
+class DownmixedWavFile(object):
+    _file = None
+
+    def __init__(self, path):
+        super(DownmixedWavFile, self).__init__()
+        self._file = open(path, 'rb')
+        try:
+            riff = Chunk(self._file, bigendian=False)
+            if riff.getname() != b'RIFF':
+                raise SushiError('File does not start with RIFF id')
+            if riff.read(4) != b'WAVE':
+                raise SushiError('Not a WAVE file')
+
+            fmt_chunk_read = False
+            data_chink_read = False
+            file_size = os.path.getsize(path)
+
+            while True:
+                try:
+                    chunk = Chunk(self._file, bigendian=False)
+                except EOFError:
+                    break
+
+                if chunk.getname() == b'fmt ':
+                    self._read_fmt_chunk(chunk)
+                    fmt_chunk_read = True
+                elif chunk.getname() == b'data':
+                    if file_size > 0xFFFFFFFF:
+                        # large broken wav
+                        self.frames_count = (file_size - self._file.tell()) // self.frame_size
+                    else:
+                        self.frames_count = chunk.chunksize // self.frame_size
+                    data_chink_read = True
+                    break
+                chunk.skip()
+            if not fmt_chunk_read or not data_chink_read:
+                raise SushiError('Invalid WAV file')
+        except Exception:
+            self.close()
+            raise
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if self._file:
+            self._file.close()
+            self._file = None
+
+    def readframes(self, count):
+        if not count:
+            return ''
+        data = self._file.read(count * self.frame_size)
+        if self.sample_width == 2:
+            unpacked = np.frombuffer(data, dtype=np.int16)
+        elif self.sample_width == 3:
+            raw_bytes = np.ndarray(len(data), 'int8', data)
+            unpacked = np.zeros(len(data) / 3, np.int16)
+            unpacked.view(dtype='int8')[0::2] = raw_bytes[1::3]
+            unpacked.view(dtype='int8')[1::2] = raw_bytes[2::3]
+        else:
+            raise SushiError('Unsupported sample width: {0}'.format(self.sample_width))
+
+        unpacked = unpacked.astype('float32')
+
+        if self.channels_count == 1:
+            return unpacked
+        else:
+            min_length = len(unpacked) // self.channels_count
+            real_length = len(unpacked) / float(self.channels_count)
+            if min_length != real_length:
+                logging.error("Length of audio channels didn't match. This might result in broken output")
+
+            channels = (unpacked[i::self.channels_count] for i in range(self.channels_count))
+            data = reduce(lambda a, b: a[:min_length] + b[:min_length], channels)
+            data /= float(self.channels_count)
+            return data
+
+    def _read_fmt_chunk(self, chunk):
+        wFormatTag, self.channels_count, self.framerate, dwAvgBytesPerSec, wBlockAlign = struct.unpack('<HHLLH',
+                                                                                                       chunk.read(14))
+        if wFormatTag == WAVE_FORMAT_PCM or wFormatTag == WAVE_FORMAT_EXTENSIBLE:  # ignore the rest
+            bits_per_sample = struct.unpack('<H', chunk.read(2))[0]
+            self.sample_width = (bits_per_sample + 7) // 8
+        else:
+            raise SushiError('unknown format: {0}'.format(wFormatTag))
+        self.frame_size = self.channels_count * self.sample_width
+
+
+class WavStream(object):
+    READ_CHUNK_SIZE = 1  # one second, seems to be the fastest
+    PADDING_SECONDS = 10
+
+    def __init__(self, path, sample_rate=12000, sample_type='uint8'):
+        if sample_type not in ('float32', 'uint8'):
+            raise SushiError('Unknown sample type of WAV stream, must be uint8 or float32')
+
+        stream = DownmixedWavFile(path)
+        total_seconds = stream.frames_count / float(stream.framerate)
+        downsample_rate = sample_rate / float(stream.framerate)
+
+        self.sample_count = math.ceil(total_seconds * sample_rate)
+        self.sample_rate = sample_rate
+        # pre-allocating the data array and some place for padding
+        self.data = np.empty((1, int(self.PADDING_SECONDS * 2 * stream.framerate + self.sample_count)), np.float32)
+        self.padding_size = 10 * stream.framerate
+        before_read = time()
+        try:
+            seconds_read = 0
+            samples_read = self.padding_size
+            while seconds_read < total_seconds:
+                data = stream.readframes(int(self.READ_CHUNK_SIZE * stream.framerate))
+                new_length = int(round(len(data) * downsample_rate))
+
+                dst_view = self.data[0][samples_read:samples_read + new_length]
+
+                if downsample_rate != 1:
+                    data = data.reshape((1, len(data)))
+                    data = cv2.resize(data, (new_length, 1), interpolation=cv2.INTER_NEAREST)[0]
+
+                np.copyto(dst_view, data, casting='no')
+                samples_read += new_length
+                seconds_read += self.READ_CHUNK_SIZE
+
+            # padding the audio from both sides
+            self.data[0][0:self.padding_size].fill(self.data[0][self.padding_size])
+            self.data[0][-self.padding_size:].fill(self.data[0][-self.padding_size - 1])
+
+            # normalizing
+            # also clipping the stream by 3*median value from both sides of zero
+            max_value = np.median(self.data[self.data >= 0], overwrite_input=True) * 3
+            min_value = np.median(self.data[self.data <= 0], overwrite_input=True) * 3
+
+            np.clip(self.data, min_value, max_value, out=self.data)
+
+            self.data -= min_value
+            self.data /= (max_value - min_value)
+
+            if sample_type == 'uint8':
+                self.data *= 255.0
+                self.data += 0.5
+                self.data = self.data.astype('uint8')
+
+        except Exception as e:
+            raise SushiError('Error while loading {0}: {1}'.format(path, e))
+        finally:
+            stream.close()
+        logging.info('Done reading WAV {0} in {1}s'.format(path, time() - before_read))
+
+    @property
+    def duration_seconds(self):
+        return self.sample_count / self.sample_rate
+
+    def get_substream(self, start, end):
+        start_off = self._get_sample_for_time(start)
+        end_off = self._get_sample_for_time(end)
+        return self.data[:, start_off:end_off]
+
+    def _get_sample_for_time(self, timestamp):
+        # this function gets REAL sample for time, taking padding into account
+        return int(self.sample_rate * timestamp) + self.padding_size
+
+    def find_substream(self, pattern, window_center, window_size):
+        start_time = clip(window_center - window_size, -self.PADDING_SECONDS, self.duration_seconds)
+        end_time = clip(window_center + window_size, 0, self.duration_seconds + self.PADDING_SECONDS)
+
+        start_sample = self._get_sample_for_time(start_time)
+        end_sample = self._get_sample_for_time(end_time) + len(pattern[0])
+
+        search_source = self.data[:, start_sample:end_sample]
+        result = cv2.matchTemplate(search_source, pattern, cv2.TM_SQDIFF_NORMED)
+        min_idx = result.argmin(axis=1)[0]
+
+        return result[0][min_idx], start_time + (min_idx / float(self.sample_rate))
\ No newline at end of file
diff --git a/backend/tools/NotoSansCJK-Bold.otf b/backend/tools/NotoSansCJK-Bold.otf
new file mode 100644
index 0000000..7f666dd
Binary files /dev/null and b/backend/tools/NotoSansCJK-Bold.otf differ
diff --git a/backend/tools/__init__.py b/backend/tools/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/backend/tools/concurrent/__init__.py b/backend/tools/concurrent/__init__.py
new file mode 100644
index 0000000..d7c1bc7
--- /dev/null
+++ b/backend/tools/concurrent/__init__.py
@@ -0,0 +1 @@
+from .task_manager import TaskExecutor, Future
\ No newline at end of file
diff --git a/backend/tools/concurrent/future.py b/backend/tools/concurrent/future.py
new file mode 100644
index 0000000..e52e107
--- /dev/null
+++ b/backend/tools/concurrent/future.py
@@ -0,0 +1,248 @@
+from typing import List, Optional, Callable, Iterable, Sized, Tuple, Union
+
+from PySide6.QtCore import QObject, Signal, QMutex, QSemaphore
+
+
+class FutureError(BaseException):
+    pass
+
+
+class FutureFailed(FutureError):
+    def __init__(self, _exception: Optional[BaseException]):
+        super().__init__()
+        self.exception = _exception
+
+    def __repr__(self):
+        return f"FutureFailed({self.exception})"
+
+    def __str__(self):
+        return f"FutureFailed({self.exception})"
+
+
+class GatheredFutureFailed(FutureError):
+    def __init__(self, failures: List[Tuple['Future', BaseException]]):
+        super().__init__()
+        self.failures = failures
+
+    def __repr__(self):
+        return f"GatheredFutureFailed({self.failures})"
+
+    def __str__(self):
+        return f"GatheredFutureFailed({self.failures})"
+
+    def __iter__(self):
+        return iter(self.failures)
+
+    def __len__(self):
+        return len(self.failures)
+
+
+class FutureCancelled(FutureError):
+    def __init__(self):
+        super().__init__()
+
+    def __repr__(self):
+        return f"FutureCanceled()"
+
+    def __str__(self):
+        return f"FutureCanceled()"
+
+
+class Future(QObject):
+    result = Signal(object)  # self
+    done = Signal(object)  # self
+    failed = Signal(object)  # self
+    partialDone = Signal(object)  # child future
+    childrenDone = Signal(object)  # self
+
+    def __init__(self, semaphore=0):
+        super().__init__()
+        self._taskID = None
+        self._failedCallback = lambda e: None
+        self._done = False
+        self._failed = False
+        self._result = None
+        self._exception = None
+        self._children = []
+        self._counter = 0
+        self._parent = None
+        self._callback = lambda _: None
+        self._mutex = QMutex()
+        self._extra = {}
+        self._semaphore = QSemaphore(semaphore)
+
+    def __onChildDone(self, childFuture: 'Future') -> None:
+        self._mutex.lock()
+        if childFuture.isFailed():
+            self._failed = True
+        self._counter += 1
+        self.partialDone.emit(childFuture)
+        try:
+            idx = getattr(childFuture, "_idx")
+            self._result[idx] = childFuture._result
+            self._mutex.unlock()
+        except AttributeError:
+            self._mutex.unlock()
+            raise RuntimeError(
+                "Invalid child future: please ensure that the child future is created by method 'Future.setChildren'")
+
+        if self._counter == len(self._children):
+            if self._failed:  # set failed
+                l = []
+
+                for i, child in enumerate(self._children):
+                    if isinstance(e := child.getException(), FutureError):
+                        l.append((self._children[i], e))
+
+                self.setFailed(GatheredFutureFailed(l))
+            else:
+                self.setResult(self._result)
+
+    def __setChildren(self, children: List['Future']) -> None:
+        self._children = children
+        self._result = [None] * len(children)
+
+        for i, fut in enumerate(self._children):
+            setattr(fut, f"_idx", i)
+            fut.childrenDone.connect(self.__onChildDone)
+            fut._parent = self
+
+        for i, fut in enumerate(self._children):  # check if child is done
+            if fut.isDone():
+                self.__onChildDone(fut)
+
+    def setResult(self, result) -> None:
+        """
+        :param result: The result to set
+        :return: None
+
+        do not set result in thread pool,or it may not set correctly
+        please use in main thread,or use signal-slot to set result !!!
+        """
+        if self._done:
+            raise RuntimeError("Future already done")
+
+        self._result = result
+        self._done = True
+
+        if self._parent:
+            self.childrenDone.emit(self)
+
+        if self._callback:
+            self._callback(result)
+
+        self.result.emit(result)
+        self.done.emit(self)
+
+    def setFailed(self, exception) -> None:
+        """
+        :param exception: The exception to set
+        :return: None
+        """
+        if self._done:
+            raise RuntimeError("Future already done")
+
+        self._exception = FutureFailed(exception)
+        self._done = True
+        self._failed = True
+
+        if self._parent:
+            self.childrenDone.emit(self)
+
+        if self._failedCallback:
+            self._failedCallback(self)
+
+        self.failed.emit(self._exception)
+        self.done.emit(self)
+
+    def setCallback(self, callback: Callable[[object, ], None]) -> None:
+        self._callback = callback
+
+    def setFailedCallback(self, callback: Callable[['Future', ], None]) -> None:
+        self._failedCallback = lambda e: callback(self)
+
+    def hasException(self) -> bool:
+        if self._children:
+            return any([fut.hasException() for fut in self._children])
+        else:
+            return self._exception is not None
+
+    def hasChildren(self) -> bool:
+        return bool(self._children)
+
+    def getException(self) -> Optional[BaseException]:
+        return self._exception
+
+    def setTaskID(self, _id: int) -> None:
+        self._taskID = _id
+
+    def getTaskID(self) -> int:
+        return self._taskID
+
+    def getChildren(self) -> List['Future']:
+        return self._children
+
+    @staticmethod
+    def gather(futures: {Iterable, Sized}) -> 'Future':
+        """
+        :param futures: An iterable of Future objects
+        :return: A Future object that will be done when all futures are done
+        """
+        future = Future()
+        future.__setChildren(futures)
+        return future
+
+    @property
+    def semaphore(self):
+        return self._semaphore
+
+    def wait(self):
+        if self.hasChildren():
+            for child in self.getChildren():
+                child.wait()
+        else:
+            self.semaphore.acquire(1)
+
+    def synchronize(self):
+        self.wait()
+
+    def isDone(self) -> bool:
+        return self._done
+
+    def isFailed(self) -> bool:
+        return self._failed
+
+    def getResult(self) -> Union[object, List[object]]:
+        return self._result
+
+    def setExtra(self, key, value):
+        self._extra[key] = value
+
+    def getExtra(self, key):
+        return self._extra.get(key, None)
+
+    def hasExtra(self, key):
+        return key in self._extra
+
+    def then(self, onSuccess: Callable, onFailed: Callable = None, onFinished : Callable = None):
+        self.result.connect(onSuccess)
+
+        if onFailed:
+            self.failed.connect(onFailed)
+
+        if onFinished:
+            self.done.connect(onFinished)
+
+        return self
+
+    def __getattr__(self, item):
+        return self.getExtra(item)
+
+    def __repr__(self):
+        return f"Future:({self._result})"
+
+    def __str__(self):
+        return f"Future({self._result})"
+
+    def __eq__(self, other):
+        return self._result == other._result
\ No newline at end of file
diff --git a/backend/tools/concurrent/task.py b/backend/tools/concurrent/task.py
new file mode 100644
index 0000000..bb42331
--- /dev/null
+++ b/backend/tools/concurrent/task.py
@@ -0,0 +1,48 @@
+import functools
+from typing import Optional
+
+from PySide6.QtCore import QObject, Signal, QRunnable
+
+from .future import Future
+
+
+class WorkerSignal(QObject):
+    finished = Signal(object)
+
+
+class BaseTask(QRunnable):
+    def __init__(self, _id: int, future: Future):
+        super().__init__()
+        self._signal = WorkerSignal()  # Signal(object)
+        self._future = future
+        self._id = _id
+        self._exception: Optional[BaseException] = None
+        self._semaphore = future.semaphore
+
+    @property
+    def finished(self):
+        return self._signal.finished
+
+    @property
+    def signal(self):
+        return self._signal
+
+    def _taskDone(self, **data):
+        for d in data.items():
+            self._future.setExtra(*d)
+        self._signal.finished.emit(self._future)
+        self._semaphore.release(1)
+
+
+class Task(BaseTask):
+    def __init__(self, _id: int, future: Future, target: functools.partial, args, kwargs):
+        super().__init__(_id=_id, future=future)
+        self._target = target
+        self._kwargs = kwargs
+        self._args = args
+
+    def run(self) -> None:
+        try:
+            self._taskDone(result=self._target(*self._args, **self._kwargs))
+        except Exception as exception:
+            self._taskDone(exception=exception)
\ No newline at end of file
diff --git a/backend/tools/concurrent/task_manager.py b/backend/tools/concurrent/task_manager.py
new file mode 100644
index 0000000..23943a4
--- /dev/null
+++ b/backend/tools/concurrent/task_manager.py
@@ -0,0 +1,111 @@
+import functools
+import warnings
+from typing import Dict, List, Callable
+
+from PySide6 import QtCore
+from PySide6.QtCore import QThreadPool, QObject, QRunnable
+
+from .future import Future, FutureCancelled
+from .task import BaseTask, Task
+
+
+def cpu_count():
+    return 8
+
+
+class BaseTaskExecutor(QObject):
+    def __init__(self, useGlobalThreadPool=True):
+        super().__init__()
+        self.useGlobalThreadPool = useGlobalThreadPool
+
+        if useGlobalThreadPool:
+            self.threadPool = QThreadPool.globalInstance()
+        else:
+            self.threadPool = QThreadPool()
+            self.threadPool.setMaxThreadCount(2 * cpu_count())  # IO-Bound = 2*N, CPU-Bound = N + 1
+
+        self.taskMap = {}
+        self.tasks: Dict[int, BaseTask] = {}
+        self.taskCounter = 0
+
+    def deleteLater(self) -> None:
+        if not self.useGlobalThreadPool:
+            self.threadPool.clear()
+            self.threadPool.waitForDone()
+            self.threadPool.deleteLater()
+
+        super().deleteLater()
+
+    def _taskRun(self, task: BaseTask, future: Future, **kwargs):
+        self.tasks[self.taskCounter] = task
+        future.setTaskID(self.taskCounter)
+        task.signal.finished.connect(self._taskDone, type=QtCore.Qt.ConnectionType.QueuedConnection)
+        self.threadPool.start(task)
+        self.taskCounter += 1
+
+    def _taskDone(self, fut: Future):
+        """
+        need manually set Future.setFailed() or Future.setResult() to be called!!!
+        """
+        self.tasks.pop(fut.getTaskID())
+        if isinstance(e := fut.getExtra("exception"), Exception):
+            fut.setFailed(e)
+        else:
+            fut.setResult(fut.getExtra("result"))
+
+    def _taskCancel(self, fut: Future):
+        stack: List[Future] = [fut]
+        while stack:
+            f = stack.pop()
+
+            if not f.hasChildren() and not f.isDone():
+                self._taskSingleCancel(f)
+                f.setFailed(FutureCancelled())
+
+            stack.extend(f.getChildren())
+
+    def _taskSingleCancel(self, fut: Future):
+        _id = fut.getTaskID()
+        taskRef: BaseTask = self.tasks[_id]
+
+        if taskRef is not None:
+            try:
+                taskRef.setAutoDelete(False)
+                self.threadPool.cancel(taskRef)
+                taskRef.setAutoDelete(True)
+            except RuntimeError:
+                print("wrapped C/C++ object of type FetchImageTask has been deleted")
+
+        del taskRef
+
+    def cancelTask(self, fut: Future):
+        warnings.warn("BaseTaskExecutor.cancelTask: 目前好像不能正常工作...", DeprecationWarning)
+        self._taskCancel(fut)
+
+
+class TaskExecutor(BaseTaskExecutor):
+
+    globalInstance = None
+
+    def asyncRun(self, target: Callable, *args, **kwargs) -> Future:
+        future = Future()
+        task = Task(
+            _id=self.taskCounter,
+            future=future,
+            target=target if target is functools.partial else functools.partial(target),
+            args=args,
+            kwargs=kwargs
+        )
+        self._taskRun(task, future)
+        return future
+
+    @classmethod
+    def instance(cls):
+        if cls.globalInstance is None:
+            cls.globalInstance = TaskExecutor()
+
+        return cls.globalInstance
+
+    @classmethod
+    def runTask(cls, task: Callable, *args, **kwargs) -> Future:
+        return cls.instance().asyncRun(task, *args, **kwargs)
\ No newline at end of file
diff --git a/backend/tools/constant.py b/backend/tools/constant.py
new file mode 100644
index 0000000..63c85fd
--- /dev/null
+++ b/backend/tools/constant.py
@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+# 默认字幕出现的大致区域
+class SubtitleArea(Enum):
+    # 字幕区域出现在下半部分
+    LOWER_PART = 0
+    # 字幕区域出现在上半部分
+    UPPER_PART = 1
+    # 不知道字幕区域可能出现的位置
+    UNKNOWN = 2
+    # 明确知道字幕区域出现的位置
+    # CUSTOM = 3
+
+
+class BackgroundColor(Enum):
+    # 字幕背景
+    WHITE = 0
+    DARK = 1
+    UNKNOWN = 2
+
+
+class VideoSubFinderDecoder(Enum):
+    OPENCV = "OpenCV"
+    FFMPEG = "FFmpeg"
+
+BGR_COLOR_GREEN = (0, 0xff, 0)
+BGR_COLOR_BLUE = (0xff, 0, 0)
+BGR_COLOR_RED = (0, 0, 0xff)
+BGR_COLOR_WHITE = (0xff, 0xff, 0xff)
diff --git a/backend/tools/hardware_accelerator.py b/backend/tools/hardware_accelerator.py
new file mode 100644
index 0000000..a01bbe7
--- /dev/null
+++ b/backend/tools/hardware_accelerator.py
@@ -0,0 +1,94 @@
+from backend.config import tr
+import paddle
+
+class HardwareAccelerator:
+
+    # 类变量，用于存储单例实例
+    _instance = None
+
+    @classmethod
+    def instance(cls):
+        """获取单例实例"""
+        if cls._instance is None:
+            cls._instance = HardwareAccelerator()
+            cls._instance.initialize()
+        return cls._instance
+
+    def __init__(self):
+        self.__cuda = False
+        self.__onnx_providers = []
+        self.__enabled = True
+
+    def initialize(self):
+        self.check_paddle()
+        self.check_onnx()
+
+    def check_paddle(self):
+        # 如果paddlepaddle编译了gpu的版本
+        if paddle.is_compiled_with_cuda():
+        # 查看是否有可用的gpu
+            if len(paddle.static.cuda_places()) > 0:
+                # 如果有GPU则使用GPU
+                self.__cuda = True
+
+    def check_onnx(self):
+        if self.__cuda:
+            return
+        try:
+            import onnxruntime as ort
+            available_providers = ort.get_available_providers()
+            for provider in available_providers:
+                if provider in [
+                    "CPUExecutionProvider"
+                ]:
+                    continue
+                if provider not in [
+                    "DmlExecutionProvider",         # DirectML，适用于 Windows GPU
+                    "ROCMExecutionProvider",        # AMD ROCm
+                    "MIGraphXExecutionProvider",    # AMD MIGraphX
+                    "VitisAIExecutionProvider",     # AMD VitisAI，适用于 RyzenAI & Windows, 实测和DirectML性能似乎差不多
+                    "OpenVINOExecutionProvider",    # Intel GPU
+                    "MetalExecutionProvider",       # Apple macOS
+                    "CoreMLExecutionProvider",      # Apple macOS
+                    "CUDAExecutionProvider",        # Nvidia GPU
+                ]:
+                    print(tr['Main']['OnnxExectionProviderNotSupportedSkipped'].format(provider))
+                    continue
+                print(tr['Main']['OnnxExecutionProviderDetected'].format(provider))
+                self.__onnx_providers.append(provider)
+        except ModuleNotFoundError as e:
+            print(tr['Main']['OnnxRuntimeNotInstall'])
+
+    def has_accelerator(self):
+        if not self.__enabled:
+            return False
+        return self.__cuda or len(self.__onnx_providers) > 0
+
+    @property
+    def accelerator_name(self):
+        if not self.__enabled:
+            return "CPU"
+        if self.__cuda:
+            return "GPU"
+        elif len(self.__onnx_providers) > 0:
+            return ", ".join(self.__onnx_providers)
+        else:
+            return "CPU"
+
+    @property
+    def onnx_providers(self):
+        if not self.__enabled:
+            return []
+        return self.__onnx_providers
+
+    def has_cuda(self):
+        if not self.__enabled:
+            return False
+        return self.__cuda
+    
+    def set_enabled(self, enable):
+        self.__enabled = enable
+
+        
+
+    
\ No newline at end of file
diff --git a/backend/tools/makedist.py b/backend/tools/makedist.py
new file mode 100644
index 0000000..b00ab27
--- /dev/null
+++ b/backend/tools/makedist.py
@@ -0,0 +1,56 @@
+import argparse
+import os
+from qpt.executor import CreateExecutableModule as CEM
+from qpt.modules.cuda import CopyCUDAPackage
+from qpt.smart_opt import set_default_pip_source
+from qpt.kernel.qinterpreter import PYPI_PIP_SOURCE
+from qpt.modules.package import CustomPackage, DEFAULT_DEPLOY_MODE
+
+
+def main():
+    WORK_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    LAUNCH_PATH = os.path.join(WORK_DIR, 'gui.py')
+    SAVE_PATH = os.path.join(os.path.dirname(WORK_DIR), 'vse_out')
+    ICON_PATH = os.path.join(WORK_DIR, "design", "vse.ico")
+
+    # 解析命令行参数
+    parser = argparse.ArgumentParser(description="打包程序")
+    parser.add_argument(
+        "--cuda",
+        nargs="?",                # 可选参数值
+        const="11.8",             # 如果只写 --cuda，默认值是 10.2
+        default=None,             # 不写 --cuda，则为 None
+        help="是否包含CUDA模块，可指定版本，如 --cuda 或 --cuda=11.8"
+    )
+
+    args = parser.parse_args()
+
+    sub_modules = []
+
+    if args.cuda == "10.2":
+        sub_modules.append(CustomPackage("paddlepaddle-gpu==2.5.2.post102", deploy_mode=DEFAULT_DEPLOY_MODE, find_links="https://www.paddlepaddle.org.cn/whl/windows/mkl/avx/stable.html"))
+        sub_modules.append(CopyCUDAPackage(cuda_version=args.cuda))
+        sub_modules.append(CustomPackage("numpy==1.26.4", deploy_mode=DEFAULT_DEPLOY_MODE))
+    elif args.cuda == "11.8":
+        sub_modules.append(CustomPackage("paddlepaddle-gpu==3.0.0", deploy_mode=DEFAULT_DEPLOY_MODE, find_links=PYPI_PIP_SOURCE, opts="--index-url https://www.paddlepaddle.org.cn/packages/stable/cu118/ "))
+    elif args.cuda == "12.6":
+        sub_modules.append(CustomPackage("paddlepaddle-gpu==3.0.0", deploy_mode=DEFAULT_DEPLOY_MODE, find_links=PYPI_PIP_SOURCE, opts="--index-url https://www.paddlepaddle.org.cn/packages/stable/cu126/ "))
+
+    if os.getenv("QPT_Action") == "True":
+        set_default_pip_source(PYPI_PIP_SOURCE)
+
+    module = CEM(
+        work_dir=WORK_DIR,
+        launcher_py_path=LAUNCH_PATH,
+        save_path=SAVE_PATH,
+        icon=ICON_PATH,
+        hidden_terminal=False,
+        requirements_file="./requirements.txt",
+        sub_modules=sub_modules,
+    )
+
+    module.make()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/backend/tools/ocr.py b/backend/tools/ocr.py
new file mode 100644
index 0000000..8d98f22
--- /dev/null
+++ b/backend/tools/ocr.py
@@ -0,0 +1,130 @@
+import os
+from backend.config import *
+import importlib
+from paddleocr import PaddleOCR
+from backend.tools.hardware_accelerator import HardwareAccelerator
+from backend.tools.paddle_model_config import PaddleModelConfig
+
+# 加载文本检测+识别模型
+class OcrRecogniser:
+    def __init__(self):
+        self.recogniser = None
+        # 占位，应该由main.py初始化
+        self.hardware_accelerator = HardwareAccelerator()
+
+    @staticmethod
+    def y_round(y):
+        y_min = y + 10 - y % 10
+        y_max = y - y % 10
+        if abs(y - y_min) < abs(y - y_max):
+            return y_min
+        else:
+            return y_max
+
+    def predict(self, image):
+        if not self.recogniser:
+            self.recogniser = self.init_model()
+
+        # PaddleOCR 3.x: 使用 predict_iter 获取结果
+        results = list(self.recogniser.predict_iter(image))
+        if not results:
+            return [], []
+
+        res = results[0]
+        dt_polys = res.get('dt_polys', [])
+        rec_texts = res.get('rec_texts', [])
+        rec_scores = res.get('rec_scores', [])
+
+        if len(dt_polys) == 0:
+            return [], []
+
+        # 将 dt_polys (numpy array, shape (N, points, 2)) 转换为旧的 dt_box 格式
+        # 旧格式: [[(x1,y1),(x2,y2),(x3,y3),(x4,y4)], ...]
+        dt_box = []
+        coordinate_list = []
+        for poly in dt_polys:
+            points = [(int(p[0]), int(p[1])) for p in poly]
+            # 取 AABB 用于排序
+            xs = [p[0] for p in points]
+            ys = [p[1] for p in points]
+            xmin, xmax = min(xs), max(xs)
+            ymin, ymax = min(ys), max(ys)
+            coordinate_list.append([xmin, xmax, ymin, ymax])
+            dt_box.append(points)
+
+        # 将 rec_texts + rec_scores 转换为旧的 rec_res 格式
+        rec_res = [(text, float(score)) for text, score in zip(rec_texts, rec_scores)]
+
+        # 计算有多少行字幕，将每行字幕最小的ymin值放入lines
+        lines = []
+        for i in coordinate_list:
+            rounded_y = self.y_round(i[2])
+            if not any(abs(rounded_y - line_y) <= 10 for line_y in lines):
+                lines.append(rounded_y)
+        lines = sorted(lines)
+
+        for i in coordinate_list:
+            for j in lines:
+                if abs(j - self.y_round(i[2])) <= 10:
+                    i[2] = j
+
+        to_rank_res = list(zip(coordinate_list, rec_res, dt_box))
+        # 用sorted替代冒泡排序：先按ymin，再按xmin
+        ranked_res = sorted(to_rank_res, key=lambda x: (x[0][2], x[0][0]))
+        # 重建 dt_box 和 rec_res（排序后）
+        sorted_dt_box = []
+        sorted_rec_res = []
+        for coord, rec, box in ranked_res:
+            # 将 coordinate 转换回 4 点格式
+            xmin, xmax, ymin, ymax = coord
+            sorted_dt_box.append([(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)])
+            sorted_rec_res.append(rec)
+
+        return sorted_dt_box, sorted_rec_res
+
+    def init_model(self):
+        model_config = PaddleModelConfig(self.hardware_accelerator)
+
+        # PaddleOCR 3.x 使用 device 参数替代 use_gpu
+        if self.hardware_accelerator.has_cuda():
+            device = 'gpu:0'
+        else:
+            device = 'cpu'
+
+        kwargs = dict(
+            text_detection_model_dir=model_config.DET_MODEL_PATH,
+            text_recognition_model_dir=model_config.REC_MODEL_PATH,
+            use_doc_orientation_classify=False,
+            use_doc_unwarping=False,
+            use_textline_orientation=False,
+            text_rec_score_thresh=0,
+            device=device,
+        )
+        if model_config.DET_MODEL_NAME:
+            kwargs['text_detection_model_name'] = model_config.DET_MODEL_NAME
+        if model_config.REC_MODEL_NAME:
+            kwargs['text_recognition_model_name'] = model_config.REC_MODEL_NAME
+
+        return PaddleOCR(**kwargs)
+
+
+def get_coordinates(dt_box):
+    """
+    从返回的检测框中获取坐标
+    :param dt_box 检测框返回结果
+    :return list 坐标点列表
+    """
+    coordinate_list = list()
+    if isinstance(dt_box, list):
+        for i in dt_box:
+            i = list(i)
+            (x1, y1) = int(i[0][0]), int(i[0][1])
+            (x2, y2) = int(i[1][0]), int(i[1][1])
+            (x3, y3) = int(i[2][0]), int(i[2][1])
+            (x4, y4) = int(i[3][0]), int(i[3][1])
+            xmin = max(x1, x4)
+            xmax = min(x2, x3)
+            ymin = max(y1, y2)
+            ymax = min(y3, y4)
+            coordinate_list.append((xmin, xmax, ymin, ymax))
+    return coordinate_list
diff --git a/backend/tools/paddle_model_config.py b/backend/tools/paddle_model_config.py
new file mode 100644
index 0000000..986ff21
--- /dev/null
+++ b/backend/tools/paddle_model_config.py
@@ -0,0 +1,152 @@
+import os
+from backend.config import BASE_DIR, config
+
+
+class PaddleModelConfig:
+    def __init__(self, hardware_accelerator):
+        self.hardware_accelerator = hardware_accelerator
+        # 设置识别语言
+        self.REC_CHAR_TYPE = config.language.value
+
+        # 模型文件目录
+        self.MODEL_BASE = os.path.join(BASE_DIR, 'models')
+        # 模型版本 V5
+        self.MODEL_VERSION = 'V5'
+        # V5模型默认图形识别的shape为3, 48, 320
+        self.REC_IMAGE_SHAPE = '3,48,320'
+        # 初始化模型路径
+        self.REC_MODEL_PATH = None
+        self.DET_MODEL_PATH = None
+        self.DET_MODEL_NAME = None
+        self.REC_MODEL_NAME = None
+
+        # 语言组定义
+        self.LATIN_LANG = [
+            'af', 'az', 'bs', 'cs', 'cy', 'da', 'de', 'es', 'et', 'fr', 'ga', 'hr',
+            'hu', 'id', 'is', 'it', 'ku', 'la', 'lt', 'lv', 'mi', 'ms', 'mt', 'nl',
+            'no', 'oc', 'pi', 'pl', 'pt', 'ro', 'rs_latin', 'sk', 'sl', 'sq', 'sv',
+            'sw', 'tl', 'tr', 'uz', 'vi', 'latin', 'german', 'french',
+            'fi', 'eu', 'gl', 'lb', 'rm', 'ca', 'qu',
+        ]
+        self.ARABIC_LANG = ['ar', 'fa', 'ug', 'ur', 'ps', 'sd', 'bal']
+        self.CYRILLIC_LANG = [
+            'ru', 'rs_cyrillic', 'be', 'bg', 'uk', 'mn', 'abq', 'ady', 'kbd', 'ava',
+            'dar', 'inh', 'che', 'lbe', 'lez', 'tab', 'cyrillic',
+            'sr', 'kk', 'ky', 'tg', 'mk', 'tt', 'cv', 'ba', 'mhr', 'mo',
+            'udm', 'kv', 'os', 'bua', 'xal', 'tyv', 'sah', 'kaa',
+        ]
+        self.DEVANAGARI_LANG = [
+            'hi', 'mr', 'ne', 'bh', 'mai', 'ang', 'bho', 'mah', 'sck', 'new', 'gom',
+            'sa', 'bgc', 'devanagari',
+        ]
+        self.OTHER_LANG = [
+            'ch', 'japan', 'korean', 'en', 'ta', 'kn', 'te', 'ka',
+            'chinese_cht',
+        ]
+        self.MULTI_LANG = (self.LATIN_LANG + self.ARABIC_LANG + self.CYRILLIC_LANG
+                           + self.DEVANAGARI_LANG + self.OTHER_LANG)
+
+        # 如果设置了识别文本语言类型，则设置为对应的语言
+        if self.REC_CHAR_TYPE in self.MULTI_LANG:
+            resolved = self._resolve_models()
+            if resolved:
+                self.MODEL_VERSION = 'V5'
+                self.DET_MODEL_PATH, self.REC_MODEL_PATH, self.DET_MODEL_NAME, self.REC_MODEL_NAME = resolved
+
+    def _get_v5_rec_model_name(self, lang):
+        """
+        根据语言获取V5识别模型目录名
+        参考: https://www.paddleocr.ai/main/version3.x/algorithm/PP-OCRv5/PP-OCRv5_multi_languages.html
+        """
+        if lang in ('ch', 'chinese_cht', 'japan'):
+            return 'PP-OCRv5_server_rec_infer'
+        elif lang == 'en':
+            return 'PP-OCRv5_server_rec_infer'
+        elif lang == 'korean':
+            return 'korean_PP-OCRv5_mobile_rec_infer'
+        elif lang in self.LATIN_LANG:
+            return 'latin_PP-OCRv5_mobile_rec_infer'
+        elif lang in self.ARABIC_LANG:
+            return 'arabic_PP-OCRv5_mobile_rec_infer'
+        elif lang in self.CYRILLIC_LANG:
+            return 'cyrillic_PP-OCRv5_mobile_rec_infer'
+        elif lang in self.DEVANAGARI_LANG:
+            return 'devanagari_PP-OCRv5_mobile_rec_infer'
+        elif lang == 'th':
+            return 'th_PP-OCRv5_mobile_rec_infer'
+        elif lang == 'el':
+            return 'el_PP-OCRv5_mobile_rec_infer'
+        elif lang == 'ta':
+            return 'ta_PP-OCRv5_mobile_rec_infer'
+        elif lang == 'te':
+            return 'te_PP-OCRv5_mobile_rec_infer'
+        return None
+
+    @staticmethod
+    def _read_model_name_from_yaml(model_dir):
+        """从 inference.yml 中读取 Global.model_name"""
+        yaml_path = os.path.join(model_dir, 'inference.yml')
+        if not os.path.exists(yaml_path):
+            return None
+        try:
+            with open(yaml_path, 'r', encoding='utf-8') as f:
+                in_global = False
+                for line in f:
+                    stripped = line.strip()
+                    if stripped == 'Global:':
+                        in_global = True
+                        continue
+                    if in_global:
+                        if stripped and not stripped.startswith('#') and ':' in stripped:
+                            if stripped.startswith('model_name:'):
+                                return stripped.split(':', 1)[1].strip().strip('"').strip("'")
+                        # 遇到下一个顶级 section 则退出
+                        if stripped and not stripped.startswith('model_name') and not stripped.startswith(' ') and stripped.endswith(':'):
+                            break
+        except Exception:
+            pass
+        return None
+
+    def _resolve_models(self):
+        """
+        解析 V5 模型路径，返回 (det_model_path, rec_model_path, det_model_name, rec_model_name) 或 None
+        """
+        v5_base = os.path.join(self.MODEL_BASE, 'V5')
+
+        # 快速模式优先使用 mobile 模型，否则使用 server 模型
+        if config.mode.value == 'fast':
+            det_model_path = os.path.join(v5_base, 'PP-OCRv5_mobile_det_infer')
+            if not os.path.exists(det_model_path):
+                det_model_path = os.path.join(v5_base, 'PP-OCRv5_server_det_infer')
+        else:
+            det_model_path = os.path.join(v5_base, 'PP-OCRv5_server_det_infer')
+        if not os.path.exists(det_model_path):
+            return None
+
+        det_model_name = self._read_model_name_from_yaml(det_model_path)
+
+        # 快速模式：中文(简/繁)、英文、日文使用通用 mobile 模型，其他语言使用对应的专用模型
+        if config.mode.value == 'fast' and self.REC_CHAR_TYPE in ('ch', 'chinese_cht', 'en', 'japan'):
+            rec_model_path = os.path.join(v5_base, 'PP-OCRv5_mobile_rec_infer')
+            if os.path.exists(rec_model_path):
+                rec_model_name = self._read_model_name_from_yaml(rec_model_path)
+                return det_model_path, rec_model_path, det_model_name, rec_model_name
+            # mobile 不存在则 fallback 到按语言选择
+
+        # 获取识别模型
+        rec_model_dir_name = self._get_v5_rec_model_name(self.REC_CHAR_TYPE)
+        if rec_model_dir_name is None:
+            return None
+
+        rec_model_path = os.path.join(v5_base, f'{rec_model_dir_name}_infer'
+                                      if not rec_model_dir_name.endswith('_infer')
+                                      else rec_model_dir_name)
+
+        if not os.path.exists(rec_model_path):
+            rec_model_path = os.path.join(v5_base, rec_model_dir_name)
+
+        if not os.path.exists(rec_model_path):
+            return None
+
+        rec_model_name = self._read_model_name_from_yaml(rec_model_path)
+        return det_model_path, rec_model_path, det_model_name, rec_model_name
diff --git a/backend/tools/process_manager.py b/backend/tools/process_manager.py
new file mode 100644
index 0000000..7d4642c
--- /dev/null
+++ b/backend/tools/process_manager.py
@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+"""
+@desc: 进程管理器，用于管理和终止子进程
+"""
+import weakref
+import signal
+import os
+import platform
+import logging
+import atexit
+import subprocess
+import concurrent.futures
+
+class ProcessManager:
+    """
+    进程管理器类，用于管理子进程的生命周期
+    使用弱引用避免内存泄漏
+    """
+    _instance = None
+    
+    @classmethod
+    def instance(cls):
+        """单例模式获取实例"""
+        if cls._instance is None:
+            cls._instance = ProcessManager()
+        return cls._instance
+    
+    def __init__(self):
+        """初始化进程管理器"""
+        self.processes = {}
+        self.logger = logging.getLogger(__name__)
+        
+        # 注册退出处理函数
+        atexit.register(self.terminate_all)
+    
+    def add_process(self, process, name=None):
+        """
+        添加进程到管理器
+        
+        Args:
+            process: 要添加的进程对象 (subprocess.Popen实例)
+            name: 进程名称，如果不提供则使用进程ID
+        """
+        if process is None:
+            return
+            
+        process_id = name or f"Process:{id(process)}"
+        self.processes[process_id] = process
+        print(f"Added process: {process_id}, PID: {process.pid if hasattr(process, 'pid') else 'unknown'}")
+        return process_id
+
+    def add_pid(self, pid, name=None):
+        process_id = name or f"Pid:{pid}"
+        self.processes[process_id] = pid
+        print(f"Added process: {process_id}, PID: {pid}")
+        return process_id
+    
+    def remove_process(self, process_id):
+        """
+        从管理器中移除进程
+        
+        Args:
+            process_id: 进程ID或名称
+        """
+        if process_id in self.processes:
+            del self.processes[process_id]
+            print(f"Removed process: {process_id}")
+            return True
+        return False
+    
+    def terminate_all(self):
+        """并发终止所有管理的进程"""
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = []
+            for process_id, process in list(self.processes.items()):
+                if isinstance(process, int):
+                    futures.append(executor.submit(self.terminate_by_pid, process))
+                else:
+                    futures.append(executor.submit(self.terminate_by_process, process))
+            
+            # 等待所有终止操作完成
+            concurrent.futures.wait(futures)
+        
+        # 清空进程字典
+        self.processes.clear()
+    
+    def terminate_by_process(self, process):
+        if process is None:
+            return
+        try:
+            print(f"Terminating process: pid: {process.pid}")
+            if hasattr(process, 'poll') and process.poll() is not None:
+                # 进程已经结束，直接返回
+                return
+                
+            # 进程还在运行
+            process.terminate()
+            if hasattr(process, 'join'):
+                try:
+                    process.join(timeout=3)
+                except:
+                    pass
+            if hasattr(process, 'wait'):
+                try:
+                    process.wait(timeout=3)
+                except:
+                    pass
+            # 进程未能正常终止，尝试强制终止
+            if hasattr(process, 'kill'):
+                process.kill()
+        except Exception as e:
+            # print(f"Error terminating process: {str(e)}")
+            pass
+        self.terminate_by_pid(process.pid)
+
+    def terminate_by_pid(self, pid):
+        try:
+            # 使用系统命令强制终止进程
+            if platform.system() == 'Windows':
+                subprocess.run(['taskkill', '/F', '/T', '/PID', str(pid)], 
+                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=3)
+            else:
+                subprocess.run(['pkill', '-9', '-P', str(pid)], 
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=2)
+                subprocess.run(['kill', '-9', str(pid)], 
+                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=3)
+        except Exception as e:
+            print(f"Error forcibly terminating process with PID {pid}: {str(e)}")
\ No newline at end of file
diff --git a/backend/tools/python_runner.py b/backend/tools/python_runner.py
new file mode 100644
index 0000000..da5b228
--- /dev/null
+++ b/backend/tools/python_runner.py
@@ -0,0 +1,169 @@
+import sys
+import subprocess
+import threading
+from typing import Optional, Callable, List, Any
+
+from .process_manager import ProcessManager
+
+class AsyncPythonRunner:
+    def __init__(self):
+        """初始化异步Python运行器"""
+        self.process: Optional[subprocess.Popen] = None
+        self._output_threads: List[threading.Thread] = []
+        self._monitor_thread: Optional[threading.Thread] = None
+        self.returncode: Optional[int] = None
+        self._stdout_callbacks: List[Callable[[str], Any]] = []
+        self._stderr_callbacks: List[Callable[[str], Any]] = []
+        self._exit_callbacks: List[Callable[[int], Any]] = []
+
+    def register_callback(self, 
+                        stdout: Callable[[str], Any] = None,
+                        stderr: Callable[[str], Any] = None,
+                        complete: Callable[[int], Any] = None):
+        """注册回调函数"""
+        if stdout:
+            self._stdout_callbacks.append(stdout)
+        if stderr:
+            self._stderr_callbacks.append(stderr)
+        if complete:
+            self._exit_callbacks.append(complete)
+
+    def _notify_callbacks(self, 
+                        stream_type: str, 
+                        content: str):
+        """通知已注册的回调"""
+        if stream_type == 'stdout':
+            for callback in self._stdout_callbacks:
+                callback(content)
+        elif stream_type == 'stderr':
+            for callback in self._stderr_callbacks:
+                callback(content)
+
+    def start(self, 
+             script_path: str,
+             args: List[str] = None,
+             python_args: List[str] = None,
+             cwd: str = None):
+        """
+        启动子进程
+        :param script_path: 要执行的Python脚本路径
+        :param args: 传递给脚本的参数
+        :param python_args: 传递给Python解释器的参数
+        :param cwd: 设置工作目录
+        """
+        if self.process is not None:
+            raise RuntimeError("Process is already running")
+        
+        python_path = sys.executable
+        cmd = [python_path]
+        # 添加Python解释器参数
+        if python_args:
+            cmd.extend(python_args)
+        
+        # 添加脚本路径和参数
+        cmd.append(script_path)
+        if args:
+            cmd.extend(args)
+        
+        # 启动子进程
+        self.process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            encoding='utf-8',
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            cwd=cwd
+        )
+        
+        # 启动输出读取线程
+        self._start_reader_thread('stdout', self.process.stdout)
+        self._start_reader_thread('stderr', self.process.stderr)
+        
+        # 启动监控线程
+        self._monitor_thread = threading.Thread(
+            target=self._monitor_process,
+            daemon=True
+        )
+        self._monitor_thread.start()
+
+    def _start_reader_thread(self, 
+                           stream_type: str, 
+                           stream):
+        """启动输出读取线程"""
+        def reader():
+            for line in iter(stream.readline, ''):
+                self._notify_callbacks(stream_type, line)
+            stream.close()
+        
+        thread = threading.Thread(
+            target=reader,
+            daemon=True
+        )
+        thread.start()
+        self._output_threads.append(thread)
+
+    def _monitor_process(self):
+        """监控进程状态"""
+        self.returncode = self.process.wait()
+        for callback in self._exit_callbacks:
+            callback(self.returncode)
+
+    def is_running(self) -> bool:
+        """检查子进程是否在运行"""
+        return self.returncode is None
+
+    def stop(self):
+        """停止子进程"""
+        if self.process:
+            ProcessManager.instance().terminate_by_pid(self.process.pid)
+        self.process = None
+
+    def wait(self, timeout: float = None) -> bool:
+        """等待进程结束"""
+        if self._monitor_thread:
+            self._monitor_thread.join(timeout)
+            return not self._monitor_thread.is_alive()
+        return True
+
+# 使用示例
+if __name__ == "__main__":
+    def on_stdout(line: str):
+        print(f"[STDOUT] {line}", end='')
+
+    def on_stderr(line: str):
+        print(f"[STDERR] {line}", end='', file=sys.stderr)
+
+    def on_exit(code: int):
+        print(f"\n[EXIT] Process finished with code {code}")
+
+    # 创建运行器
+    runner = AsyncPythonRunner()
+    
+    # 注册回调
+    runner.register_callback(
+        stdout=on_stdout,
+        stderr=on_stderr,
+        complete=on_exit
+    )
+    
+    # 启动脚本 (带参数示例)
+    runner.start(
+        script_path="path/to/your_script.py",
+        args=["--param1", "value1", "--flag"],
+        python_args=["-u"]  # 无缓冲模式
+    )
+    
+    # 主线程继续执行其他任务...
+    try:
+        while runner.is_running():
+            # 模拟其他工作
+            threading.Event().wait(0.5)
+    except KeyboardInterrupt:
+        print("\nStopping process...")
+        runner.stop()
+    
+    # 等待进程结束
+    runner.wait()
+    print("Main thread exiting")
\ No newline at end of file
diff --git a/backend/tools/reformat.py b/backend/tools/reformat.py
new file mode 100644
index 0000000..b4fb89d
--- /dev/null
+++ b/backend/tools/reformat.py
@@ -0,0 +1,220 @@
+# -*- coding: UTF-8 -*-
+"""
+@author: eritpchy
+@file  : reformat.py
+@time  : 2021/12/17 15:43
+@desc  : 将连起来的英文单词切分
+"""
+import json
+import os
+import sys
+import traceback
+import pysrt
+import wordsegment as ws
+import re
+
+def execute(path, lang='en'):
+    try:
+        print(f"Starting to process subtitle file: {path}, language: {lang}")
+        
+        # fix "RecursionError: maximum recursion depth exceeded in comparison" in wordsegment.segment call
+        if sys.getrecursionlimit() < 100000:
+            sys.setrecursionlimit(100000)
+
+        # Check if file exists
+        if not os.path.exists(path):
+            print(f"Error: Subtitle file does not exist: {path}")
+            return False
+
+        wordsegment = ws.Segmenter()
+        wordsegment.load()
+        
+        try:
+            subs = pysrt.open(path)
+        except Exception as e:
+            print(f"Error: Failed to open subtitle file: {str(e)}")
+            print(traceback.format_exc())
+            return False
+            
+        verb_forms = ["I'm", "you're", "he's", "she's", "we're", "it's", "isn't", "aren't", "they're", "there's", "wasn't",
+                    "weren't", "I've", "you've", "we've", "they've", "hasn't", "haven't", "I'd", "you'd", "he'd", "she'd",
+                    "it'd", "we'd", "they'd", "doesn't", "don't", "didn't", "I'll", "you'll", "he'll", "she'll", "we'll",
+                    "they'll", "there'll", "there'd", "can't", "couldn't", "daren't", "hadn't", "mightn't", "mustn't",
+                    "needn't", "oughtn't", "shan't", "shouldn't", "usedn't", "won't", "wouldn't", "that's", "what's", "it'll"]
+        verb_form_map = {}
+
+        typo_map_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'configs', 'typoMap.json')
+        try:
+            with open(typo_map_path, 'r', encoding='utf-8') as load_f:
+                typo_map = json.load(load_f)
+        except Exception as e:
+            print(f"Error: Failed to load typoMap.json: {str(e)}")
+            print(traceback.format_exc())
+            typo_map = {}
+
+        for verb in verb_forms:
+            verb_form_map[verb.replace("'", "").lower()] = verb
+
+        def format_seg_list(seg_list):
+            new_seg = []
+            for seg in seg_list:
+                if seg in verb_form_map:
+                    new_seg.append([seg, verb_form_map[seg]])
+                else:
+                    new_seg.append([seg])
+            return new_seg
+
+        def typo_fix(text):
+            for k, v in typo_map.items():
+                try:
+                    text = re.sub(re.compile(k, re.I), v, text)
+                except Exception as e:
+                    print(f"Warning: Regex replacement failed: {k} -> {v}, error: {str(e)}")
+            return text
+
+        # 逆向过滤seg
+        def remove_invalid_segment(seg, text):
+            try:
+                seg_len = len(seg)
+                span = None
+                new_seg = []
+                for i in range(seg_len - 1, -1, -1):
+                    s = seg[i]
+                    if len(s) > 1:
+                        regex = re.compile(f"({s[0]}|{s[1]})", re.I)
+                    else:
+                        regex = re.compile(f"({s[0]})", re.I)
+                    try:
+                        ss = [(i) for i in re.finditer(regex, text)][-1]
+                    except IndexError:
+                        ss = None
+                    if ss is None:
+                        continue
+                    text = text[:ss.span()[0]]
+                    if span is None:
+                        span = ss.span()
+                        new_seg.append(s)
+                        continue
+                    if span > ss.span():
+                        new_seg.append(s)
+                        span = ss.span()
+                return list(reversed(new_seg))
+            except Exception as e:
+                print(f"Error: remove_invalid_segment failed: {str(e)}")
+                print(traceback.format_exc())
+                return []
+
+        modified_count = 0
+        for index, sub in enumerate(subs):
+            try:
+                if not hasattr(sub, 'text') or not sub.text:
+                    continue
+                    
+                original_text = sub.text
+                sub.text = typo_fix(sub.text)
+                
+                # Limit text length to avoid processing too long text
+                if len(sub.text) > 1000:
+                    print(f"Warning: Subtitle text too long, skipping word segmentation: {len(sub.text)} characters")
+                    continue
+                    
+                try:
+                    seg = wordsegment.segment(sub.text)
+                    if len(seg) == 1:
+                        seg = wordsegment.segment(re.sub(re.compile(f"(\ni)([^\\s])", re.I), "\\1 \\2", sub.text))
+                except Exception as e:
+                    print(f"Error: Word segmentation failed: {str(e)}")
+                    print(traceback.format_exc())
+                    continue
+                    
+                seg = format_seg_list(seg)
+
+                # 替换中文前的多个空格成单个空格, 避免中英文分行出错
+                sub.text = re.sub(' +([\\u4e00-\\u9fa5])', ' \\1', sub.text)
+                # 中英文分行
+                if lang in ["ch", "ch_tra"]:
+                    sub.text = sub.text.replace("  ", "\n")
+                lines = []
+                remain = sub.text
+                seg = remove_invalid_segment(seg, sub.text)
+                seg_len = len(seg)
+                for i in range(0, seg_len):
+                    s = seg[i]
+                    if len(s) > 1:
+                        regex = re.compile(f"(.*?)({s[0]}|{s[1]})", re.I)
+                    else:
+                        regex = re.compile(f"(.*?)({s[0]})", re.I)
+                    ss = re.search(regex, remain)
+                    if ss is None:
+                        if i == seg_len - 1:
+                            lines.append(remain.strip())
+                        continue
+
+                    lines.append(remain[:ss.span()[1]].strip())
+                    remain = remain[ss.span()[1]:].strip()
+                    if i == seg_len - 1:
+                        lines.append(remain)
+                if seg_len > 0:
+                    ss = " ".join(lines)
+                else:
+                    ss = remain
+                # again
+                ss = typo_fix(ss)
+                # 非大写字母的大写字母前加空格
+                ss = re.sub("([^\\sA-Z\\-])([A-Z])", "\\1 \\2", ss)
+                # 删除重复空格
+                ss = ss.replace("  ", " ")
+                ss = ss.replace("。", ".")
+                # 删除,?!,前的多个空格
+                ss = re.sub(" *([\\.\\?\\!\\,])", "\\1", ss)
+                # 删除'的前后多个空格
+                ss = re.sub(" *([\\']) *", "\\1", ss)
+                # 删除换行后的多个空格, 通常时第二行的开始的多个空格
+                ss = re.sub('\n\\s*', '\n', ss)
+                # 删除开始的多个空格
+                ss = re.sub('^\\s*', '', ss)
+                # 删除-左侧空格
+                ss = re.sub("([A-Za-z0-9]) (\\-[A-Za-z0-9])", '\\1\\2', ss)
+                # 删除%左侧空格
+                ss = re.sub("([A-Za-z0-9]) %", '\\1%', ss)
+                # 结尾·改成.
+                ss = re.sub('·$', '.', ss)
+                # 移除Dr.后的空格
+                ss = re.sub(r'\bDr\. *\b', "Dr.", ss)
+                # 中文引号转英文
+                ss = re.sub(r'[""]', "\"", ss)
+                # 中文逗号转英文
+                ss = re.sub(r'，', ",", ss)
+                # .,?后面加空格
+                ss = re.sub('([\\.,\\!\\?])([A-Za-z0-9\\u4e00-\\u9fa5])', '\\1 \\2', ss)
+                ss = ss.replace("\n\n", "\n")
+                sub.text = ss.strip()
+                
+                if original_text != sub.text:
+                    modified_count += 1
+                    
+            except Exception as e:
+                print(f"Error: Failed to process subtitle line {index+1}: {str(e)}")
+                print(traceback.format_exc())
+                # Keep original text unchanged
+                continue
+                
+        try:
+            subs.save(path, encoding='utf-8')
+            print(f"Successfully processed subtitle file: {path}, modified {modified_count} lines")
+            return True
+        except Exception as e:
+            print(f"Error: Failed to save subtitle file: {str(e)}")
+            print(traceback.format_exc())
+            return False
+            
+    except Exception as e:
+        print(f"Critical error occurred while executing reformat.py: {str(e)}")
+        print(traceback.format_exc())
+        return False
+
+
+if __name__ == '__main__':
+    path = "/home/yao/Videos/null.srt"
+    execute(path)
+
diff --git a/backend/tools/subtitle_detect.py b/backend/tools/subtitle_detect.py
new file mode 100644
index 0000000..e0c19e9
--- /dev/null
+++ b/backend/tools/subtitle_detect.py
@@ -0,0 +1,37 @@
+
+from backend.tools.paddle_model_config import PaddleModelConfig
+from backend.tools.hardware_accelerator import HardwareAccelerator
+import numpy as np
+
+try:
+    from paddleocr import TextDetection
+except ImportError:
+    TextDetection = None
+
+
+class SubtitleDetect:
+    """
+    文本框检测类，用于检测视频帧中是否存在文本框
+    """
+
+    def __init__(self):
+        hardware_accelerator = HardwareAccelerator.instance()
+        model_config = PaddleModelConfig(hardware_accelerator)
+        # 使用 TextDetection 公开 API（PaddleOCR 3.x）
+        kwargs = {'model_dir': model_config.DET_MODEL_PATH}
+        if model_config.DET_MODEL_NAME:
+            kwargs['model_name'] = model_config.DET_MODEL_NAME
+        self.text_detector = TextDetection(**kwargs)
+
+    def detect_subtitle(self, img):
+        """
+        检测图像中的文本框
+        :param img: 输入图像
+        :return: (dt_boxes, elapse) dt_boxes为numpy数组，elapse为耗时
+        """
+        results = list(self.text_detector.predict(img))
+        if not results:
+            return np.array([]), 0
+        res = results[0]
+        dt_polys = res.get('dt_polys', np.array([]))
+        return dt_polys, 0
diff --git a/backend/tools/subtitle_extractor_remote_call.py b/backend/tools/subtitle_extractor_remote_call.py
new file mode 100644
index 0000000..8b2c43f
--- /dev/null
+++ b/backend/tools/subtitle_extractor_remote_call.py
@@ -0,0 +1,67 @@
+import multiprocessing
+import threading
+from enum import Enum
+
+class Command(Enum):
+    FINISH = 0,
+    PROGRESS = 1,
+    LOG = 2,
+    MANAGE_PROCESS = 3,
+    ERROR = 4,
+
+class SubtitleExtractorRemoteCall:
+    """
+    远程回调函数类，用于在多进程环境中传递回调函数
+    """
+    def __init__(self):
+        self.queue = multiprocessing.Queue()
+        self.callbacks = {}
+        self.running = True
+        threading.Thread(target=self.run, daemon=True).start()
+    
+    def run(self):
+        try:
+            while self.running:
+                cmd, args = self.queue.get(block=True)
+                if cmd == Command.FINISH:
+                    break
+                callback = self.callbacks.get(cmd)
+                if callback:
+                    callback(*args)
+        finally:
+            self.running = False
+
+    def stop(self):
+        self.running = False
+
+    def register_update_progress_callback(self, callback):
+        self.callbacks[Command.PROGRESS] = callback
+
+    def register_log_callback(self, callback):
+        self.callbacks[Command.LOG] = callback
+    
+    def register_manage_process_callback(self, callback):
+        self.callbacks[Command.MANAGE_PROCESS] = callback
+
+    def register_error_callback(self, callback):
+        self.callbacks[Command.ERROR] = callback
+
+    @staticmethod
+    def remote_call_update_progress(queue, progress_ocr, progress_frame_extract, progress_total, isFinished, progress_post=0):
+        queue.put((Command.PROGRESS, (progress_ocr, progress_frame_extract, progress_total, isFinished, progress_post,)))
+
+    @staticmethod
+    def remote_call_append_log(queue, *args):
+        queue.put((Command.LOG, (*args,)))
+
+    @staticmethod
+    def remote_call_finish(queue, *args):
+        queue.put((Command.FINISH, (None,)))
+        
+    @staticmethod
+    def remote_call_catch_error(queue, e):
+        queue.put((Command.ERROR, (e,)))
+
+    @staticmethod
+    def remote_call_manage_process(queue, pid):
+        queue.put((Command.MANAGE_PROCESS, (pid,)))
\ No newline at end of file
diff --git a/backend/tools/subtitle_ocr.py b/backend/tools/subtitle_ocr.py
new file mode 100644
index 0000000..ad0eec5
--- /dev/null
+++ b/backend/tools/subtitle_ocr.py
@@ -0,0 +1,302 @@
+import os
+import re
+from multiprocessing import Queue, Process
+import cv2
+from PIL import ImageFont, ImageDraw, Image
+from tqdm import tqdm
+from backend.tools.ocr import OcrRecogniser, get_coordinates
+from backend.tools.constant import SubtitleArea
+from backend.tools import constant
+from threading import Thread
+import queue
+from types import SimpleNamespace
+import shutil
+import numpy as np
+from collections import namedtuple
+from backend.config import tr
+
+
+def extract_subtitles(data, text_recogniser, img, raw_subtitles,
+                      sub_area, options, dt_box_arg, rec_res_arg, ocr_loss_debug_path):
+    """
+    提取视频帧中的字幕信息
+    """
+    # 从参数中获取检测框与检测结果
+    dt_box = dt_box_arg
+    rec_res = rec_res_arg
+    # 如果没有检测结果，则获取检测结果
+    if dt_box is None or rec_res is None:
+        dt_box, rec_res = text_recogniser.predict(img)
+        # rec_res格式为： ("hello", 0.997)
+    # 获取文本坐标
+    coordinates = get_coordinates(dt_box)
+    # 将结果写入txt文本中
+    if options.REC_CHAR_TYPE == 'en':
+        # 如果识别语言为英文，则去除中文
+        text_res = [(re.sub('[\u4e00-\u9fa5]', '', res[0]), res[1]) for res in rec_res]
+    else:
+        text_res = [(res[0], res[1]) for res in rec_res]
+    line = ''
+    loss_list = []
+    for content, coordinate in zip(text_res, coordinates):
+        text = content[0]
+        prob = content[1]
+        if sub_area is not None:
+            selected = False
+            # 初始化超界偏差为0
+            overflow_area_rate = 0
+            # 使用AABB矩形重叠判断（比Shapely Polygon快得多）
+            c_xmin, c_xmax, c_ymin, c_ymax = coordinate
+            # 计算交集矩形
+            inter_xmin = max(sub_area.xmin, c_xmin)
+            inter_ymin = max(sub_area.ymin, c_ymin)
+            inter_xmax = min(sub_area.xmax, c_xmax)
+            inter_ymax = min(sub_area.ymax, c_ymax)
+            has_intersection = inter_xmin < inter_xmax and inter_ymin < inter_ymax
+            drop_reason = ''
+            # 如果有交集
+            if has_intersection:
+                sub_area_w = sub_area.xmax - sub_area.xmin
+                sub_area_h = sub_area.ymax - sub_area.ymin
+                sub_area_size = sub_area_w * sub_area_h
+                inter_area = (inter_xmax - inter_xmin) * (inter_ymax - inter_ymin)
+                coord_area = (c_xmax - c_xmin) * (c_ymax - c_ymin)
+                # 计算越界允许偏差
+                overflow_area_rate = ((sub_area_size + coord_area - inter_area) / sub_area_size) - 1
+                # 如果越界比例低于设定阈值且该行文本识别的置信度高于设定阈值
+                not_overflow = overflow_area_rate <= options.SUB_AREA_DEVIATION_RATE
+                confident = prob > options.DROP_SCORE
+                if not_overflow and confident:
+                    # 保留该帧
+                    selected = True
+                    line += f'{str(data["i"]).zfill(8)}\t{coordinate}\t{text}\n'
+                    raw_subtitles.append(f'{str(data["i"]).zfill(8)}\t{coordinate}\t{text}\n')
+                else:
+                    if not not_overflow:
+                        drop_reason = tr['Main']['OcrDropOutOfBoxRate'].format(int(options.SUB_AREA_DEVIATION_RATE * 100), int(overflow_area_rate * 100))
+                    elif not confident:
+                        drop_reason = tr['Main']['OcrDropConfidentLow'].format(int(options.DROP_SCORE * 100))
+            else:
+                drop_reason = tr['Main']['OcrDropNoIntercetion']
+            if drop_reason:
+                tqdm.write(tr['Main']['OcrResultWithDropReason'].format(text, round(prob * 100,1), drop_reason))
+            else:
+                tqdm.write(tr['Main']['OcrResult'].format(text, round(prob * 100,1)))
+            # 保存丢掉的识别结果
+            loss_info = namedtuple('loss_info', 'text prob overflow_area_rate coordinate selected')
+            loss_list.append(loss_info(text, prob, overflow_area_rate, coordinate, selected))
+        else:
+            raw_subtitles.append(f'{str(data["i"]).zfill(8)}\t{coordinate}\t{text}\n')
+    # 输出调试信息
+    dump_debug_info(options, line, img, loss_list, ocr_loss_debug_path, sub_area, data)
+
+
+def dump_debug_info(options, line, img, loss_list, ocr_loss_debug_path, sub_area, data):
+    loss = False
+    if options.DEBUG_OCR_LOSS and options.REC_CHAR_TYPE in ('ch', 'japan ', 'korea', 'ch_tra'):
+        loss = len(line) > 0 and re.search(r'[\u4e00-\u9fa5\u3400-\u4db5\u3130-\u318F\uAC00-\uD7A3\u0800-\u4e00]', line) is None
+    if loss:
+        if not os.path.exists(ocr_loss_debug_path):
+            os.makedirs(ocr_loss_debug_path, mode=0o777, exist_ok=True)
+        img = cv2.rectangle(img, (sub_area.xmin, sub_area.ymin), (sub_area.xmax, sub_area.ymax), constant.BGR_COLOR_BLUE, 2)
+        for loss_info in loss_list:
+            coordinate = loss_info.coordinate
+            color = constant.BGR_COLOR_GREEN if loss_info.selected else constant.BGR_COLOR_RED
+            text = f"[{loss_info.text}] prob:{loss_info.prob:.4f} or:{loss_info.overflow_area_rate:.2f}"
+            img = paint_chinese_opencv(img, text, pos=(coordinate[0], coordinate[2] - 30), color=color)
+            img = cv2.rectangle(img, (coordinate[0], coordinate[2]), (coordinate[1], coordinate[3]), color, 2)
+        cv2.imwrite(os.path.join(os.path.abspath(ocr_loss_debug_path), f'{str(data["i"]).zfill(8)}.png'), img)
+
+
+FONT_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'NotoSansCJK-Bold.otf')
+FONT = ImageFont.truetype(FONT_PATH, 20)
+
+
+def paint_chinese_opencv(im, chinese, pos, color):
+    img_pil = Image.fromarray(im)
+    fill_color = color  # (color[2], color[1], color[0])
+    position = pos
+    draw = ImageDraw.Draw(img_pil)
+    draw.text(position, chinese, font=FONT, fill=fill_color)
+    img = np.array(img_pil)
+    return img
+
+
+def ocr_task_consumer(ocr_queue, raw_subtitle_path, sub_area, video_path, options, progress_queue):
+    """
+    消费者： 消费ocr_queue，将ocr队列中的数据取出，进行ocr识别，写入字幕文件中
+    :param ocr_queue (current_frame_no当前帧帧号, frame 视频帧, dt_box检测框, rec_res识别结果)
+    :param raw_subtitle_path
+    :param sub_area
+    :param video_path
+    :param options
+    """
+    data = {'i': 1}
+    # 初始化文本识别对象
+    text_recogniser = OcrRecogniser()
+    text_recogniser.hardware_accelerator = options.HARDWARD_ACCELERATOR
+    # 丢失字幕的存储路径
+    ocr_loss_debug_path = os.path.join(os.path.abspath(os.path.splitext(video_path)[0]), 'loss')
+    # 删除之前的缓存垃圾
+    if os.path.exists(ocr_loss_debug_path):
+        shutil.rmtree(ocr_loss_debug_path, True)
+
+    raw_subtitles = []
+    processed_count = 0
+    try:
+        while True:
+            try:
+                frame_no, frame, dt_box, rec_res = ocr_queue.get(block=True)
+                if frame_no == -1:
+                    # frame 是生产者统计的总帧数
+                    total_tasks = frame if frame is not None else processed_count
+                    progress_queue.put((-1, total_tasks))
+                    return
+                data['i'] = frame_no
+                extract_subtitles(data, text_recogniser, frame, raw_subtitles, sub_area, options, dt_box,
+                                    rec_res, ocr_loss_debug_path)
+                processed_count += 1
+                progress_queue.put((frame_no, processed_count))
+            except Exception as e:
+                print(e)
+                progress_queue.put(-1)
+                break
+    finally:
+        with open(raw_subtitle_path, mode='w+', encoding='utf-8') as raw_subtitle_file:
+            for line in raw_subtitles:
+                raw_subtitle_file.write(line)
+
+
+def ocr_task_producer(ocr_queue, task_queue, progress_queue, video_path, raw_subtitle_path):
+    """
+    生产者：负责生产用于OCR识别的数据，将需要进行ocr识别的数据加入ocr_queue中
+    :param ocr_queue (current_frame_no当前帧帧号, frame 视频帧, dt_box检测框, rec_res识别结果)
+    :param task_queue (total_frame_count总帧数, current_frame_no当前帧帧号, dt_box检测框, rec_res识别结果, subtitle_area字幕区域)
+    :param progress_queue
+    :param video_path
+    :param raw_subtitle_path
+    """
+    cap = cv2.VideoCapture(video_path)
+    tbar = None
+    frame_count = 0
+    while True:
+        try:
+            # 从任务队列中提取任务信息
+            total_frame_count, current_frame_no, dt_box, rec_res, total_ms, default_subtitle_area = task_queue.get(block=True)
+            if tbar is None:
+                tbar = tqdm(total=round(total_frame_count), position=1)
+            # current_frame 等于-1说明所有视频帧已经读完
+            if current_frame_no == -1:
+                # ocr识别队列加入结束标志，附带总帧数
+                ocr_queue.put((-1, frame_count, None, None))
+                # 通过 progress_queue 提前通知总帧数，让主进程可以精确计算进度
+                progress_queue.put((-2, frame_count))
+                # 更新进度条
+                tbar.update(tbar.total - tbar.n)
+                break
+            tbar.update(round(current_frame_no - tbar.n))
+            # 设置当前视频帧
+            # 如果total_ms不为空，则使用了VSF提取字幕
+            if total_ms is not None:
+                cap.set(cv2.CAP_PROP_POS_MSEC, total_ms)
+            else:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_no - 1)
+            # 读取视频帧
+            ret, frame = cap.read()
+            # 如果读取成功
+            if ret:
+                frame_count += 1
+                # 根据默认字幕位置，则对视频帧进行裁剪，裁剪后处理
+                if default_subtitle_area is not None:
+                    frame = frame_preprocess(default_subtitle_area, frame)
+                # print(f"current_frame_no: {current_frame_no}")
+                ocr_queue.put((current_frame_no, frame, dt_box, rec_res))
+        except Exception as e:
+            print(e)
+            break
+    cap.release()
+
+
+def subtitle_extract_handler(task_queue, progress_queue, video_path, raw_subtitle_path, sub_area, options):
+    """
+    创建并开启一个视频帧提取线程与一个ocr识别线程
+    :param task_queue 任务队列，(total_frame_count总帧数, current_frame_no当前帧, dt_box检测框, rec_res识别结果, subtitle_area字幕区域)
+    :param progress_queue 进度队列
+    :param video_path 视频路径
+    :param raw_subtitle_path 原始字幕文件路径
+    :param sub_area 字幕区域
+    :param options 选项
+    """
+    # 删除缓存
+    if os.path.exists(raw_subtitle_path):
+        os.remove(raw_subtitle_path)
+    # 创建一个OCR队列，大小建议值8-20
+    ocr_queue = queue.Queue(20)
+    # 创建一个OCR事件生产者线程
+    ocr_event_producer_thread = Thread(target=ocr_task_producer,
+                                       args=(ocr_queue, task_queue, progress_queue, video_path, raw_subtitle_path,),
+                                       daemon=True)
+    # 创建一个OCR事件消费者提取线程
+    ocr_event_consumer_thread = Thread(target=ocr_task_consumer,
+                                       args=(ocr_queue, raw_subtitle_path, sub_area, video_path, options, progress_queue,),
+                                       daemon=True)
+    # 开启消费者线程
+    ocr_event_producer_thread.start()
+    # 开启生产者线程
+    ocr_event_consumer_thread.start()
+    # join方法让主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程再终止
+    ocr_event_producer_thread.join()
+    ocr_event_consumer_thread.join()
+
+
+def async_start(video_path, raw_subtitle_path, sub_area, options):
+    """
+    开始进程处理异步任务
+    options.REC_CHAR_TYPE
+    options.DROP_SCORE
+    options.SUB_AREA_DEVIATION_RATE
+    options.DEBUG_OCR_LOSS
+    options.HARDWARD_ACCELERATOR
+    """
+    assert 'REC_CHAR_TYPE' in options, "options缺少参数：REC_CHAR_TYPE"
+    assert 'DROP_SCORE' in options, "options缺少参数: DROP_SCORE'"
+    assert 'SUB_AREA_DEVIATION_RATE' in options, "options缺少参数: SUB_AREA_DEVIATION_RATE"
+    assert 'DEBUG_OCR_LOSS' in options, "options缺少参数: DEBUG_OCR_LOSS"
+    assert 'HARDWARD_ACCELERATOR' in options, "options缺少参数: HARDWARD_ACCELERATOR"
+    # 创建一个任务队列
+    # 任务格式为：(total_frame_count总帧数, current_frame_no当前帧, dt_box检测框, rec_res识别结果, subtitle_area字幕区域)
+    task_queue = Queue()
+    # 创建一个进度更新队列
+    progress_queue = Queue()
+    # 新建一个进程
+    p = Process(target=subtitle_extract_handler,
+                args=(task_queue, progress_queue, video_path, raw_subtitle_path, sub_area, SimpleNamespace(**options),))
+    # 启动进程
+    p.start()
+    return p, task_queue, progress_queue
+
+
+def frame_preprocess(subtitle_area, frame):
+    """
+    将视频帧进行裁剪
+    """
+    # 对于分辨率大于1920*1080的视频，将其视频帧进行等比缩放至1280*720进行识别
+    # paddlepaddle会将图像压缩为640*640
+    # if self.frame_width > 1280:
+    #     scale_rate = round(float(1280 / self.frame_width), 2)
+    #     frames = cv2.resize(frames, None, fx=scale_rate, fy=scale_rate, interpolation=cv2.INTER_AREA)
+    # 如果字幕出现的区域在下部分
+    if subtitle_area == SubtitleArea.LOWER_PART:
+        cropped = int(frame.shape[0] // 2)
+        # 将视频帧切割为下半部分
+        frame = frame[cropped:]
+    # 如果字幕出现的区域在上半部分
+    elif subtitle_area == SubtitleArea.UPPER_PART:
+        cropped = int(frame.shape[0] // 2)
+        # 将视频帧切割为下半部分
+        frame = frame[:cropped]
+    return frame
+
+
+if __name__ == "__main__":
+    pass
diff --git a/backend/tools/theme_listener.py b/backend/tools/theme_listener.py
new file mode 100644
index 0000000..13aee96
--- /dev/null
+++ b/backend/tools/theme_listener.py
@@ -0,0 +1,26 @@
+from PySide6 import QtCore, QtWidgets, QtGui
+
+from qfluentwidgets import setTheme, qconfig, Theme
+import darkdetect
+
+
+class SystemThemeListener(QtCore.QThread):
+    """ System theme listener """
+
+    systemThemeChanged = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+
+    def run(self):
+        darkdetect.listener(self._onThemeChanged)
+
+    def _onThemeChanged(self, theme: str):
+        theme = Theme.DARK if theme.lower() == "dark" else Theme.LIGHT
+        setTheme(theme)
+        if qconfig.themeMode.value != Theme.AUTO or theme == qconfig.theme:
+            return
+
+        qconfig.theme = Theme.AUTO
+        qconfig._cfg.themeChanged.emit(Theme.AUTO)
+        self.systemThemeChanged.emit()
\ No newline at end of file
diff --git a/backend/tools/version_service.py b/backend/tools/version_service.py
new file mode 100644
index 0000000..22f51a4
--- /dev/null
+++ b/backend/tools/version_service.py
@@ -0,0 +1,83 @@
+# coding: utf-8
+import re
+import os
+import sys
+import requests
+
+from PySide6.QtCore import QVersionNumber
+
+from backend.config import VERSION, PROJECT_UPDATE_URLS, tr
+
+
+class VersionService:
+    """ Version service """
+
+    def __init__(self):
+        self.current_version = VERSION
+        self.lastest_version = VERSION
+        self.version_pattern = re.compile(r'v*((\d+)\.(\d+)\.(\d+))')
+        self.api_endpoints = PROJECT_UPDATE_URLS
+
+    def get_latest_version(self):
+        """ get latest version """
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36 Edg/112.0.1722.64"
+        }
+
+        proxy = self.get_system_proxy()
+        proxies = {
+            "http": proxy,
+            "https": proxy
+        }
+
+        # 依次尝试不同的API端点
+        for url in self.api_endpoints:
+            try:
+                response = requests.get(url, headers=headers, timeout=5, allow_redirects=True, proxies=proxies)
+                response.raise_for_status()
+                
+                # 解析版本
+                version = response.json()['tag_name']  # type:str
+                match = self.version_pattern.search(version)
+                if not match:
+                    continue  # 如果版本格式不匹配，尝试下一个API
+
+                self.lastest_version = match.group(1)
+                print(tr['VersionService']['VersionInfo'].format(VERSION, self.lastest_version))
+                return self.lastest_version
+            except Exception as e:
+                print(tr['VersionService']['RequestError'].format(url, str(e)))
+                continue  # 出错时尝试下一个API
+        
+        # 所有API都失败时返回当前版本
+        return VERSION
+
+    def has_new_version(self) -> bool:
+        """ check whether there is a new version """
+        version = QVersionNumber.fromString(self.get_latest_version())
+        current_version = QVersionNumber.fromString(self.current_version)
+        return version > current_version
+
+    def get_system_proxy(self):
+        """ get system proxy """
+        if sys.platform == "win32":
+            try:
+                import winreg
+
+                with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Internet Settings') as key:
+                    enabled, _ = winreg.QueryValueEx(key, 'ProxyEnable')
+
+                    if enabled:
+                        return "http://" + winreg.QueryValueEx(key, 'ProxyServer')
+            except:
+                pass
+        elif sys.platform == "darwin":
+            s = os.popen('scutil --proxy').read()
+            info = dict(re.findall(r'(?m)^\s+([A-Z]\w+)\s+:\s+(\S+)', s))
+
+            if info.get('HTTPEnable') == '1':
+                return f"http://{info['HTTPProxy']}:{info['HTTPPort']}"
+            elif info.get('ProxyAutoConfigEnable') == '1':
+                return info['ProxyAutoConfigURLString']
+
+        return os.environ.get("http_proxy")
\ No newline at end of file
diff --git a/design/UI design.png b/design/UI design.png
new file mode 100644
index 0000000..fb2e0ed
Binary files /dev/null and b/design/UI design.png differ
diff --git a/design/bg.png b/design/bg.png
new file mode 100644
index 0000000..c4224c7
Binary files /dev/null and b/design/bg.png differ
diff --git a/design/demo.gif b/design/demo.gif
new file mode 100644
index 0000000..ad9c2f2
Binary files /dev/null and b/design/demo.gif differ
diff --git a/design/demo.png b/design/demo.png
new file mode 100644
index 0000000..aaba859
Binary files /dev/null and b/design/demo.png differ
diff --git a/design/icon_1024.png b/design/icon_1024.png
new file mode 100644
index 0000000..e1eff8f
Binary files /dev/null and b/design/icon_1024.png differ
diff --git a/design/paper (2020).pdf b/design/paper (2020).pdf
new file mode 100644
index 0000000..440a065
Binary files /dev/null and b/design/paper (2020).pdf differ
diff --git a/design/sponsor.png b/design/sponsor.png
new file mode 100644
index 0000000..9e33c2f
Binary files /dev/null and b/design/sponsor.png differ
diff --git a/design/vse.ico b/design/vse.ico
new file mode 100644
index 0000000..84a782b
Binary files /dev/null and b/design/vse.ico differ
diff --git a/gui.py b/gui.py
new file mode 100644
index 0000000..f10bbe1
--- /dev/null
+++ b/gui.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Author  : Fang Yao（原作者） / 改写：Jason Eric
+@Time    : 2021/4/1 6:07 下午（原始时间）
+@FileName: gui.py
+@desc: 字幕提取器图形化界面（由 PySimpleGUI 改写为 PySide6）
+"""
+
+import sys
+import os
+import configparser
+import cv2
+import multiprocessing
+from PySide6.QtCore import Qt, QTimer
+from PySide6 import QtCore, QtWidgets, QtGui
+from PySide6.QtWidgets import QApplication, QWidget
+from qfluentwidgets import (FluentWindow, PushButton, Slider, ProgressBar, PlainTextEdit,
+                          setTheme, Theme, FluentIcon, CardWidget, SettingCardGroup,
+                          ComboBoxSettingCard, SwitchSettingCard, setThemeColor, OptionsConfigItem,
+                          OptionsValidator, SubtitleLabel, HollowHandleStyle, qconfig, ConfigItem, QConfig,
+                          NavigationWidget, NavigationItemPosition, isDarkTheme, InfoBar)
+
+from qframelesswindow.utils import getSystemAccentColor
+from backend.config import config, tr, VERSION
+from backend.tools.theme_listener import SystemThemeListener
+from backend.tools.process_manager import ProcessManager
+from ui.advanced_setting_interface import AdvancedSettingInterface
+from ui.home_interface import HomeInterface
+from ui.timeline_sync_interface import TimelineSyncInterface
+
+
+class SubtitleExtractorGUI(FluentWindow): 
+    def __init__(self):
+        super().__init__()
+        # 禁用云母效果
+        self.setMicaEffectEnabled(False)
+        # 设置深色主题并跟随系统主题色
+        # setTheme(Theme.LIGHT)
+        # setThemeColor(getSystemAccentColor(), save=True)
+
+        # 初始化系统主题监听器并连接信号
+        # self.themeListener = SystemThemeListener(self)
+        # self.themeListener.start()
+        # 任何尺寸下都悬浮展开, 防止窗口撑大
+        self.navigationInterface.panel.minimumExpandWidth = 999999
+        # 设置窗口图标
+        self.setWindowIcon(QtGui.QIcon("design/vse.ico"))
+        self.setWindowTitle(tr['SubtitleExtractorGUI']['Title'] + " v" + VERSION)
+        # 创建界面布局
+        self._create_layout()
+        self._connectSignalToSlot()
+        self._lazy_check_update()
+
+    def _lazy_check_update(self):
+        """ 延迟检查更新 """
+        if not config.checkUpdateOnStartup.value:
+            return
+        self.check_update_timer = QtCore.QTimer(self)
+        self.check_update_timer.setSingleShot(True)
+        self.check_update_timer.timeout.connect(lambda: self.advancedSettingInterface.check_update(ignore=True))
+        self.check_update_timer.start(2000)
+
+    def _connectSignalToSlot(self):
+        config.appRestartSig.connect(self._showRestartTooltip)
+
+    def _showRestartTooltip(self):
+        """ show restart tooltip """
+        InfoBar.success(
+            'Updated successfully',
+            'Configuration takes effect after restart',
+            duration=5000,
+            parent=self
+        )
+
+    def _create_layout(self):
+        # 创建主页面和高级设置页面
+        self.homeInterface = HomeInterface(self)
+        self.homeInterface.setObjectName("HomeInterface")
+        self.timelineSyncInterface = TimelineSyncInterface(self)
+        self.timelineSyncInterface.setObjectName("TimelineSyncInterface")
+        self.advancedSettingInterface = AdvancedSettingInterface(self)
+        self.advancedSettingInterface.setObjectName("AdvancedSettingInterface")
+        
+        # 添加到主窗口作为子界面
+        self.addSubInterface(self.homeInterface,FluentIcon.HOME, tr['SubtitleExtractorGUI']['Title'])
+        self.addSubInterface(self.timelineSyncInterface,FluentIcon.FONT, tr['TimelineSync']['Title'])
+        self.addSubInterface(self.advancedSettingInterface, FluentIcon.SETTING, tr['Setting']['AdvancedSetting'], NavigationItemPosition.BOTTOM)
+
+    def switchTo(self, interface: QWidget):
+        super().switchTo(interface)
+        if interface == self.advancedSettingInterface:
+            QTimer.singleShot(222, lambda: self.advancedSettingInterface.macos_scrollarea_issue_workaround())
+            # try again
+            QTimer.singleShot(666, lambda: self.advancedSettingInterface.macos_scrollarea_issue_workaround())
+
+    def closeEvent(self, event):
+        """程序关闭时保存窗口位置并恢复标准输出和标准错误"""
+        self.save_window_position()
+        # 断开信号连接
+        # self.themeListener.terminate()
+        # self.themeListener.deleteLater()
+        ProcessManager().instance().terminate_all()
+        super().closeEvent(event)
+
+    def _onThemeChangedFinished(self):
+        super()._onThemeChangedFinished()
+
+    def save_window_position(self):
+        """保存窗口位置到配置文件"""
+        # 保存窗口位置和大小
+        config.set(config.windowX, self.x())
+        config.set(config.windowY, self.y())
+        config.set(config.windowW, self.width())
+        config.set(config.windowH, self.height())
+
+    def update_progress(self):
+        # 定时器轮询更新进度（现在更新到视频滑块上）
+        if self.se is not None:
+            try:
+                pos = min(self.frame_count - 1, int(self.se.progress_total / 100 * self.frame_count))
+                if pos != self.video_slider.value():
+                    self.video_slider.setValue(pos)
+                # 检查是否完成
+                if self.se.isFinished:
+                    self.processing_finished()
+            except Exception as e:
+                # 捕获任何异常，防止崩溃
+                print(f"更新进度时出错: {str(e)}")
+
+    def load_window_position(self):
+        # 尝试读取窗口位置
+        try:
+            x = config.windowX.value
+            y = config.windowY.value
+            width = config.windowW.value
+            height = config.windowH.value
+
+            if not x or not y:
+                self.center_window()
+                return
+
+            # 确保窗口在屏幕内
+            screen_rect = QtWidgets.QApplication.primaryScreen().availableGeometry()
+            if (x >= 0 and y >= 0 and 
+                x + width <= screen_rect.width() and 
+                y + height <= screen_rect.height()):
+                self.setGeometry(x, y, width, height)
+            else:
+                self.center_window()
+        except Exception as e:
+            print(e)
+            self.center_window()
+    
+    def center_window(self):
+        """将窗口居中显示"""
+        screen_rect = QtWidgets.QApplication.primaryScreen().availableGeometry()
+        window_rect = self.frameGeometry()
+        center_point = screen_rect.center()
+        window_rect.moveCenter(center_point)
+        self.move(window_rect.topLeft())
+
+    def keyPressEvent(self, event):
+        """处理键盘事件"""
+        # 检测Ctrl+C组合键
+        if event.key() == QtCore.Qt.Key_C and event.modifiers() == QtCore.Qt.ControlModifier:
+            print("\n程序被用户中断(Ctrl+C)，正在退出...")
+            self.close()
+        else:
+            super().keyPressEvent(event)
+
+
+if __name__ == '__main__':
+    multiprocessing.set_start_method("spawn")
+    QApplication.setHighDpiScaleFactorRoundingPolicy(
+    Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
+    app = QtWidgets.QApplication(sys.argv)
+    app.setAttribute(Qt.AA_DontCreateNativeWidgetSiblings)
+    window = SubtitleExtractorGUI()
+    # 先设置透明, 再显示, 否则会有闪烁的效果
+    window.setWindowOpacity(0.0)
+    window.show()
+    window.load_window_position()
+    # 使用动画效果逐渐显示窗口
+    animation = QtCore.QPropertyAnimation(window, b"windowOpacity")
+    animation.setDuration(300)  # 300毫秒的动画
+    animation.setStartValue(0.0)
+    animation.setEndValue(1.0)
+    animation.start()
+    app.exec()
\ No newline at end of file
diff --git a/test/test_ar.flv b/test/test_ar.flv
new file mode 100644
index 0000000..1edac23
Binary files /dev/null and b/test/test_ar.flv differ
diff --git a/test/test_chinese_cht.flv b/test/test_chinese_cht.flv
new file mode 100644
index 0000000..09818b9
Binary files /dev/null and b/test/test_chinese_cht.flv differ
diff --git a/test/test_cn.mp4 b/test/test_cn.mp4
new file mode 100644
index 0000000..e7899c0
Binary files /dev/null and b/test/test_cn.mp4 differ
diff --git a/test/test_cn2.mp4 b/test/test_cn2.mp4
new file mode 100644
index 0000000..c0ff2d4
Binary files /dev/null and b/test/test_cn2.mp4 differ
diff --git a/test/test_en.mp4 b/test/test_en.mp4
new file mode 100644
index 0000000..2d435b5
Binary files /dev/null and b/test/test_en.mp4 differ
diff --git a/test/test_en_ch.mp4 b/test/test_en_ch.mp4
new file mode 100644
index 0000000..2b058dc
Binary files /dev/null and b/test/test_en_ch.mp4 differ
diff --git a/test/test_es.flv b/test/test_es.flv
new file mode 100644
index 0000000..8e8243d
Binary files /dev/null and b/test/test_es.flv differ
diff --git a/test/test_german.mp4 b/test/test_german.mp4
new file mode 100644
index 0000000..f31f9ae
Binary files /dev/null and b/test/test_german.mp4 differ
diff --git a/test/test_it.flv b/test/test_it.flv
new file mode 100644
index 0000000..de8b917
Binary files /dev/null and b/test/test_it.flv differ
diff --git a/test/test_japan.mp4 b/test/test_japan.mp4
new file mode 100644
index 0000000..f0f854d
Binary files /dev/null and b/test/test_japan.mp4 differ
diff --git a/test/test_korean.flv b/test/test_korean.flv
new file mode 100644
index 0000000..d0f0e86
Binary files /dev/null and b/test/test_korean.flv differ
diff --git a/test/test_ru.flv b/test/test_ru.flv
new file mode 100644
index 0000000..cfba4cf
Binary files /dev/null and b/test/test_ru.flv differ
diff --git a/ui/advanced_setting_interface.py b/ui/advanced_setting_interface.py
new file mode 100644
index 0000000..5dc10cd
--- /dev/null
+++ b/ui/advanced_setting_interface.py
@@ -0,0 +1,327 @@
+"""
+@desc: 高级设置页面
+"""
+import sys
+
+from PySide6 import QtWidgets, QtCore, QtGui
+from PySide6.QtWidgets import QFileDialog
+from qfluentwidgets import (ScrollArea, ExpandLayout, CardWidget, SubtitleLabel,
+                           FluentIcon, NavigationWidget, NavigationItemPosition,
+                           SettingCardGroup, RangeSettingCard, SwitchSettingCard,
+                           HyperlinkCard, PrimaryPushSettingCard, ComboBoxSettingCard, PushSettingCard,
+                           MessageBox)
+from backend.config import config, tr, VERSION, PROJECT_HOME_URL, PROJECT_ISSUES_URL, PROJECT_RELEASES_URL
+from backend.tools.version_service import VersionService
+from backend.tools.concurrent import TaskExecutor
+from backend.tools.constant import VideoSubFinderDecoder
+
+class AdvancedSettingInterface(ScrollArea):
+    """高级设置页面"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.parent = parent
+        self.version_manager = VersionService()
+        self.__initWidget()
+
+    def __initWidget(self):
+        # 创建滚动内容的容器
+        self.scrollWidget = QtWidgets.QWidget(self)
+        self.expandLayout = ExpandLayout(self.scrollWidget)
+        
+        # 设置滚动区域属性
+        self.setWidget(self.scrollWidget)
+        self.enableTransparentBackground()
+        self.setWidgetResizable(True)
+        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+        
+        # 设置滚动区域样式以适应主题
+        self.setAttribute(QtCore.Qt.WA_StyledBackground)
+        
+        # 设置UI
+        self.setup_ui()
+        self.setup_layout()
+
+    def setup_layout(self):
+        self.advanced_group.addSettingCard(self.rec_batch_number)
+        self.advanced_group.addSettingCard(self.max_batch_size)
+        self.advanced_group.addSettingCard(self.subtitle_area)
+        self.advanced_group.addSettingCard(self.extract_frequency)
+        self.advanced_group.addSettingCard(self.tolerant_pixel_y)
+        self.advanced_group.addSettingCard(self.tolerant_pixel_x)
+        self.advanced_group.addSettingCard(self.subtitle_area_deviation_pixel)
+        self.advanced_group.addSettingCard(self.waterark_area_num)
+        self.advanced_group.addSettingCard(self.threshold_text_similarity)
+        self.advanced_group.addSettingCard(self.drop_score)
+        self.advanced_group.addSettingCard(self.subtitle_area_deviation_rate)
+        self.advanced_group.addSettingCard(self.save_directory)
+        self.advanced_group.addSettingCard(self.check_update_on_startup)
+        self.expandLayout.addWidget(self.advanced_group)
+
+        self.video_sub_finder_group.addSettingCard(self.video_sub_finder_cpu_cores)
+        self.video_sub_finder_group.addSettingCard(self.video_sub_finder_decoder)
+        self.expandLayout.addWidget(self.video_sub_finder_group)
+
+        self.dev_group.addSettingCard(self.debug_ocr_loss)
+        self.dev_group.addSettingCard(self.debug_no_delete_cache)
+        self.dev_group.addSettingCard(self.delete_empty_time_stamp)
+        self.expandLayout.addWidget(self.dev_group)
+
+        self.about_group.addSettingCard(self.feedback)
+        self.about_group.addSettingCard(self.copyright)
+        self.about_group.addSettingCard(self.project_link)
+        self.expandLayout.addWidget(self.about_group)
+       
+        self.expandLayout.setSpacing(16)
+        self.expandLayout.setContentsMargins(16, 16, 16, 48)
+        
+    def setup_ui(self):
+        """设置UI"""
+        # 高级设置组
+        self.advanced_group = SettingCardGroup(tr["Setting"]["AdvancedSetting"], self.scrollWidget)
+        # VideoSubFinder设置组
+        self.video_sub_finder_group = SettingCardGroup(tr["Setting"]["VideoSubFinderSetting"], self.scrollWidget)
+        # 开发设置组  
+        self.dev_group = SettingCardGroup(tr["Setting"]["DevSetting"], self.scrollWidget)
+        # 关于设置组  
+        self.about_group = SettingCardGroup(tr["Setting"]["AboutSetting"], self.scrollWidget)
+        
+        # 每张图中同时识别的文本框数量
+        self.rec_batch_number = RangeSettingCard(
+            configItem=config.recBatchNumber,
+            icon=FluentIcon.SEARCH,
+            title=tr["Setting"]["RecBatchNumber"],
+            content=tr["Setting"]["RecBatchNumberDesc"],
+            parent=self.advanced_group
+        )
+        # DB算法每个batch识别多少张
+        self.max_batch_size = RangeSettingCard(
+            configItem=config.maxBatchSize,
+            icon=FluentIcon.SEARCH_MIRROR,
+            title=tr["Setting"]["MaxBatchSize"],
+            content=tr["Setting"]["MaxBatchSizeDesc"],
+            parent=self.advanced_group
+        )
+        # 字幕出现区域
+        self.subtitle_area = ComboBoxSettingCard(
+            configItem=config.subtitleArea,
+            icon=FluentIcon.VIEW,
+            title=tr["Setting"]["SubtitleArea"],
+            content=tr["Setting"]["SubtitleAreaDesc"],
+            parent=self.advanced_group,
+            texts=tr['SubtitleArea'].values(),
+        )
+        # 每一秒抓取多少帧进行OCR识别
+        self.extract_frequency = RangeSettingCard(
+            configItem=config.extractFrequency,
+            icon=FluentIcon.SPEED_HIGH,
+            title=tr["Setting"]["ExtractFrequency"],
+            content=tr["Setting"]["ExtractFrequencyDesc"],
+            parent=self.advanced_group
+        )
+        # 容忍的像素点偏差
+        self.tolerant_pixel_y = RangeSettingCard(
+            configItem=config.tolerantPixelY,
+            icon=FluentIcon.ARROW_DOWN,
+            title=tr["Setting"]["TolerantPixelY"],
+            content=tr["Setting"]["TolerantPixelYDesc"],
+            parent=self.advanced_group
+        )
+        self.tolerant_pixel_x = RangeSettingCard(
+            configItem=config.tolerantPixelX,
+            icon=FluentIcon.RIGHT_ARROW,
+            title=tr["Setting"]["TolerantPixelX"],
+            content=tr["Setting"]["TolerantPixelXDesc"],
+            parent=self.advanced_group
+        )
+        # 字幕区域偏移量
+        self.subtitle_area_deviation_pixel = RangeSettingCard(
+            configItem=config.subtitleAreaDeviationPixel,
+            icon=FluentIcon.MOVE,
+            title=tr["Setting"]["SubtitleAreaDeviationPixel"],
+            content=tr["Setting"]["SubtitleAreaDeviationPixelDesc"],
+            parent=self.advanced_group
+        )
+        # 最有可能出现的水印区域
+        self.waterark_area_num = RangeSettingCard(
+            configItem=config.waterarkAreaNum,
+            icon=FluentIcon.PHOTO,
+            title=tr["Setting"]["WaterarkAreaNum"],
+            content=tr["Setting"]["WaterarkAreaNumDesc"],
+            parent=self.advanced_group
+        )
+        # 文本相似度阈值
+        self.threshold_text_similarity = RangeSettingCard(
+            configItem=config.thresholdTextSimilarity,
+            icon=FluentIcon.DICTIONARY,
+            title=tr["Setting"]["ThresholdTextSimilarity"],
+            content=tr["Setting"]["ThresholdTextSimilarityDesc"],
+            parent=self.advanced_group
+        )
+        # 字幕提取中置信度低于0.75的不要
+        self.drop_score = RangeSettingCard(
+            configItem=config.dropScore,
+            icon=FluentIcon.ACCEPT_MEDIUM,
+            title=tr["Setting"]["DropScore"],
+            content=tr["Setting"]["DropScoreDesc"],
+            parent=self.advanced_group
+        )
+        # 字幕区域允许偏差
+        self.subtitle_area_deviation_rate = RangeSettingCard(
+            configItem=config.subtitleAreaDeviationRate,
+            icon=FluentIcon.PIE_SINGLE,
+            title=tr["Setting"]["SubtitleAreaDeviationRate"],
+            content=tr["Setting"]["SubtitleAreaDeviationRateDesc"],
+            parent=self.advanced_group
+        )
+        # 视频保存路径
+        self.save_directory = PushSettingCard(
+            text=tr["Setting"]["ChooseDirectory"],
+            icon=FluentIcon.DOWNLOAD,
+            title=tr["Setting"]["SaveDirectory"],
+            content=tr["Setting"]["SaveDirectoryDefault"] if not config.saveDirectory.value else config.saveDirectory.value,
+            parent=self.advanced_group
+        )
+        self.save_directory.clicked.connect(self.choose_save_directory)
+        # 启动时检查应用更新
+        self.check_update_on_startup = SwitchSettingCard(
+            configItem=config.checkUpdateOnStartup,
+            icon=FluentIcon.UPDATE,
+            title=tr["Setting"]["CheckUpdateOnStartup"],
+            content=tr["Setting"]["CheckUpdateOnStartupDesc"],
+            parent=self.advanced_group
+        )
+        # VideoSubFinder CPU核心数
+        self.video_sub_finder_cpu_cores = RangeSettingCard(
+            configItem=config.videoSubFinderCpuCores,
+            icon=FluentIcon.SPEED_MEDIUM,
+            title=tr["Setting"]["VideoSubFinderCpuCores"],
+            content=tr["Setting"]["VideoSubFinderCpuCoresDesc"],
+            parent=self.video_sub_finder_group
+        )
+        # VideoSubFinder 视频解码组件
+        self.video_sub_finder_decoder = ComboBoxSettingCard(
+            configItem=config.videoSubFinderDecoder,
+            icon=FluentIcon.VIDEO,
+            title=tr["Setting"]["VideoSubFinderDecoder"],
+            content=tr["Setting"]["VideoSubFinderDecoderDesc"],
+            texts=[item.value for item in VideoSubFinderDecoder],
+            parent=self.video_sub_finder_group
+        )
+        # 输出丢失的字幕帧
+        self.debug_ocr_loss = SwitchSettingCard(
+            configItem=config.debugOcrLoss,
+            icon=FluentIcon.QUESTION,
+            title=tr["Setting"]["DebugOcrLoss"],
+            content=tr["Setting"]["DebugOcrLossDesc"],
+            parent=self.dev_group
+        )
+        # 是否不删除缓存数据
+        self.debug_no_delete_cache = SwitchSettingCard(
+            configItem=config.debugNoDeleteCache,
+            icon=FluentIcon.FOLDER,
+            title=tr["Setting"]["DebugNoDeleteCache"],
+            content=tr["Setting"]["DebugNoDeleteCacheDesc"],
+            parent=self.dev_group
+        )
+        # 是否删除空时间轴
+        self.delete_empty_time_stamp = SwitchSettingCard(
+            configItem=config.deleteEmptyTimeStamp,
+            icon=FluentIcon.DELETE,
+            title=tr["Setting"]["DeleteEmptyTimeStamp"],
+            content=tr["Setting"]["DeleteEmptyTimeStampDesc"],
+            parent=self.dev_group
+        )
+        # 添加反馈链接
+        self.feedback = PrimaryPushSettingCard(
+            text=tr["Setting"]["FeedbackButton"],
+            icon=FluentIcon.MAIL,
+            title=tr["Setting"]["FeedbackTitle"],
+            content=tr["Setting"]["FeedbackDesc"],
+            parent=self.about_group
+        )
+        self.feedback.clicked.connect(lambda: QtGui.QDesktopServices.openUrl(
+            QtCore.QUrl(PROJECT_ISSUES_URL)
+        ))
+        # 添加版权信息
+        self.copyright = PrimaryPushSettingCard(
+            text=tr["Setting"]["CopyrightButton"],
+            icon=FluentIcon.MAIL,
+            title=tr["Setting"]["CopyrightTitle"],
+            content=tr["Setting"]["CopyrightDesc"].format(VERSION),
+            parent=self.about_group
+        )
+        self.copyright.clicked.connect(lambda: self.check_update())
+        # 添加项目链接
+        self.project_link = HyperlinkCard(
+            url=PROJECT_HOME_URL,
+            text=PROJECT_HOME_URL,
+            icon=FluentIcon.GITHUB,
+            title=tr["Setting"]["ProjectLinkTitle"],
+            content=tr["Setting"]["ProjectLinkDesc"],
+            parent=self.about_group
+        )
+
+    def show_message_box(self, title: str, content: str, showYesButton=False, yesSlot=None):
+        """ show message box """
+        w = MessageBox(title, content, self)
+        if not showYesButton:
+            w.cancelButton.setText(self.tr('Close'))
+            w.yesButton.hide()
+            w.buttonLayout.insertStretch(0, 1)
+
+        if w.exec() and yesSlot is not None:
+            yesSlot()
+
+    def check_update(self, ignore=False):
+        """ check software update
+
+        Parameters
+        ----------
+        ignore: bool
+            ignore message box when no updates are available
+        """
+        TaskExecutor.runTask(self.version_manager.has_new_version).then(
+            lambda success: self.on_version_info_fetched(success, ignore))
+
+    def on_version_info_fetched(self, success, ignore=False):
+        if success:
+            self.show_message_box(
+                tr["Setting"]["UpdatesAvailableTitle"],
+                tr["Setting"]["UpdatesAvailableDesc"].format(self.version_manager.lastest_version),
+                True,
+                lambda: QtGui.QDesktopServices.openUrl(
+                    QtCore.QUrl(PROJECT_RELEASES_URL)
+                )
+            )
+        elif not ignore:
+            self.show_message_box(
+                tr["Setting"]["NoUpdatesAvailableTitle"],
+                tr["Setting"]["NoUpdatesAvailableDesc"],
+            )
+    
+    def choose_save_directory(self):
+        """选择保存目录"""
+        last_save_directory = "./" if not config.saveDirectory.value else config.saveDirectory.value
+        folder = QFileDialog.getExistingDirectory(
+            self, tr['Setting']['ChooseDirectory'], last_save_directory)
+        if not folder:
+            folder = ""
+
+        config.set(config.saveDirectory, folder)
+        self.save_directory.setContent(tr["Setting"]["SaveDirectoryDefault"] if not config.saveDirectory.value else config.saveDirectory.value)
+            
+    def macos_scrollarea_issue_workaround(self):
+        if sys.platform != "darwin":
+            return
+        self.verticalScrollBar().setValue(0)
+        self.scrollWidget.adjustSize()
+        self.expandLayout.update()
+        self.expandLayout.activate()
+        
+    def resizeEvent(self, event):
+        # macos_scrollarea_issue_workaround
+        if sys.platform == "darwin":
+            self.verticalScrollBar().setValue(0)
+        super().resizeEvent(event)
\ No newline at end of file
diff --git a/ui/component/task_list_component.py b/ui/component/task_list_component.py
new file mode 100644
index 0000000..6f7f530
--- /dev/null
+++ b/ui/component/task_list_component.py
@@ -0,0 +1,395 @@
+import os
+from pathlib import Path
+from enum import Enum, unique
+from dataclasses import dataclass
+from functools import cached_property
+
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QAbstractItemView, QTableWidgetItem, QHeaderView
+from PySide6.QtCore import Qt, Signal, QModelIndex, QUrl
+from qfluentwidgets import TableWidget, InfoBar, RoundMenu
+from PySide6.QtGui import QAction, QColor, QBrush
+from showinfm import show_in_file_manager
+
+from backend.config import config, tr
+
+@unique
+class TaskStatus(Enum):
+    PENDING = tr['TaskList']['Pending']
+    PROCESSING = tr['TaskList']['Processing']
+    COMPLETED = tr['TaskList']['Completed']
+    FAILED = tr['TaskList']['Failed']
+
+
+@unique
+class TaskOptions(Enum):
+    AB_SECTIONS = "ab_sections"
+    # 目前只支持单选
+    SUB_AREAS = "sub_area"
+
+@dataclass
+class Task:
+    path: str
+    name: str
+    progress: int
+    status: TaskStatus
+    options: dict
+    # 用于储存只读的输出路径, 在任务完成后设置
+    _output_path: str = None
+
+    @property
+    def output_path(self):
+        """获取输出路径"""
+        if self._output_path is not None:
+            return self._output_path
+        save_directory = os.path.dirname(self.path) if not config.saveDirectory.value else config.saveDirectory.value
+        output_path = os.path.abspath(os.path.join(save_directory, f'{Path(self.path).stem}.srt'))
+        return output_path
+
+    @output_path.setter
+    def output_path(self, value):
+        self._output_path = value
+
+    @cached_property
+    def is_image(self):
+        """判断是否是图片文件"""
+        return False
+
+class TaskListComponent(QWidget):
+    """任务列表组件"""
+    
+    # 定义信号
+    task_selected = Signal(int, str)  # 任务被选中时发出信号，参数为任务索引和视频路径
+    task_deleted = Signal(int)  # 任务被删除时发出信号，参数为任务索引
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("TaskListComponent")
+        
+        # 初始化变量
+        self.tasks = []  # 存储任务列表
+        self.current_task_index = -1  # 当前选中的任务索引
+        
+        # 创建布局
+        self.__init_widgets()
+        
+    def __init_widgets(self):
+        """初始化组件"""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        
+        # 创建表格
+        self.table = TableWidget(self)
+        self.table.setColumnCount(3)
+        self.table.setHorizontalHeaderLabels([tr['TaskList']['Name'], tr['TaskList']['Progress'], tr['TaskList']['Status']])
+        
+        # 设置表格样式
+        self.table.setShowGrid(False)
+        self.table.setAlternatingRowColors(True)
+        
+        # 设置列宽模式
+        header = self.table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.Stretch)           # 名称列拉伸填充
+        header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # 进度列自适应内容宽度
+        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # 状态列自适应内容宽度
+        
+        self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.table.setSelectionMode(QAbstractItemView.SingleSelection)
+        self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
+        
+        # 连接信号
+        self.table.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.table.customContextMenuRequested.connect(self.show_context_menu)
+        self.table.clicked.connect(self.on_task_clicked)
+        
+        layout.addWidget(self.table)
+        
+    def add_task(self, video_path):
+        """添加任务到列表
+        
+        Args:
+            video_path: 视频文件路径
+        """
+        # 覆盖相同路径的任务
+        for row, task in enumerate(self.tasks[:]):
+            if task.path == video_path:
+                self.delete_task(row)
+                continue
+                
+        # 获取文件名
+        file_name = os.path.basename(video_path)
+        
+        # 添加到任务列表
+        task = Task(
+            path=video_path,
+            name=file_name,
+            progress=0,
+            status=TaskStatus.PENDING,
+            options={},
+        )
+        self.tasks.append(task)
+        
+        # 更新表格
+        row = len(self.tasks) - 1
+        self.table.setRowCount(len(self.tasks))
+        
+        item0 = QTableWidgetItem(file_name)
+        item1 = QTableWidgetItem("0%")
+        item2 = QTableWidgetItem(TaskStatus.PENDING.value)
+        
+        # 设置文件名单元格的省略模式为中间省略
+        item0.setTextAlignment(Qt.AlignVCenter | Qt.AlignLeft)
+        item0.setToolTip(video_path)  # 设置完整路径为工具提示
+        # 设置表格的文本省略模式
+        self.table.setTextElideMode(Qt.ElideMiddle)
+        
+        item1.setTextAlignment(Qt.AlignCenter)
+        item2.setTextAlignment(Qt.AlignCenter)
+        
+        self.table.setItem(row, 0, item0)
+        self.table.setItem(row, 1, item1)
+        self.table.setItem(row, 2, item2)
+        
+        # 滚动到最新添加的行
+        self.table.scrollToBottom()
+        return True
+        
+    def update_task_progress(self, index, progress):
+        """更新任务进度
+        
+        Args:
+            index: 任务索引
+            progress: 进度值(0-100)
+        """
+        if 0 <= index < len(self.tasks):
+            self.tasks[index].progress = progress
+            
+            # 更新进度单元格
+            progress_item = self.table.item(index, 1)
+            if progress_item:
+                progress_item.setText(f"{progress}%")
+            
+            # 如果是当前处理的任务，滚动到可见区域
+            if index == self.current_task_index:
+                self.table.scrollTo(self.table.model().index(index, 0))
+                
+    def update_task_status(self, index, status):
+        """更新任务状态
+        
+        Args:
+            index: 任务索引
+            status: 任务状态
+        """
+        if 0 <= index < len(self.tasks):
+            self.tasks[index].status = status
+            status_item = self.table.item(index, 2)
+            if status_item:
+                status_item.setText(status.value)
+                
+                # 根据状态设置不同颜色
+                if status == TaskStatus.COMPLETED:
+                    status_item.setForeground(QBrush(QColor("#2ecc71")))  # 绿色
+                elif status == TaskStatus.PROCESSING:
+                    status_item.setForeground(QBrush(QColor("#3498db")))  # 蓝色
+                elif status == TaskStatus.FAILED:
+                    status_item.setForeground(QBrush(QColor("#e74c3c")))  # 红色
+            
+            # 如果是当前处理的任务，滚动到可见区域
+            if index == self.current_task_index:
+                self.table.scrollTo(self.table.model().index(index, 0))
+                
+            # 选中当前行
+            self.table.selectRow(index)
+    
+    def get_pending_tasks(self):
+        """获取所有待处理的任务
+        
+        Returns:
+            list: 待处理任务列表，每项为 (索引, 任务) 元组
+        """
+        return [(i, task) for i, task in enumerate(self.tasks) if task.status == TaskStatus.PENDING]
+    
+    def get_all_tasks(self):
+        """获取所有任务
+        
+        Returns:
+            list: 所有任务列表
+        """
+        return self.tasks
+
+    def get_task(self, index):
+        """获取指定索引的任务
+
+        Args:
+            index: 任务索引
+
+        Returns:
+            Task: 任务对象
+        """
+        if 0 <= index < len(self.tasks):
+            return self.tasks[index]
+        return None
+    
+    def find_task_index_by_path(self, path):
+        tasks = self.get_all_tasks()
+        for idx, task in enumerate(tasks):
+            if task.path == path:
+                return idx
+        return -1  # 没找到返回-1
+        
+    def show_context_menu(self, pos):
+        """显示右键菜单
+        
+        Args:
+            pos: 鼠标位置
+        """
+        index = self.table.indexAt(pos)
+        if index.isValid():
+            menu = RoundMenu()
+            
+            # 打开视频文件位置
+            open_video_location_action = QAction(tr['TaskList']['OpenVideoLocation'], self)
+            open_video_location_action.triggered.connect(lambda: self.open_file_location(self.tasks[index.row()].path))
+            menu.addAction(open_video_location_action)
+            
+            # 打开目标文件位置
+            def open_target_location():
+                task = self.tasks[index.row()]
+                path = task.output_path
+                if task.status != TaskStatus.COMPLETED:
+                    InfoBar.warning(
+                        title=tr['TaskList']['Warning'],
+                        content=tr['TaskList']['TargetFileNotFound'],
+                        parent=self.get_root_parent(),
+                        duration=3000
+                    )
+                    return
+                self.open_file_location(path)
+            open_target_location_action = QAction(tr['TaskList']['OpenSubtitleLocation'], self)
+            open_target_location_action.triggered.connect(open_target_location)
+            menu.addAction(open_target_location_action)
+
+            reset_task_status_action = QAction(tr['TaskList']['ResetTaskStatus'], self)
+            reset_task_status_action.triggered.connect((lambda: (
+                    self.update_task_status(index.row(), TaskStatus.PENDING), 
+                    self.update_task_progress(index.row(), 0)
+                )
+            ))
+            menu.addAction(reset_task_status_action)
+            
+            # 删除任务
+            delete_action = QAction(tr['TaskList']['DeleteTask'], self)
+            delete_action.triggered.connect(lambda: self.delete_task(index.row()))
+            menu.addAction(delete_action)
+            
+            # 显示菜单
+            menu.exec_(self.table.viewport().mapToGlobal(pos))
+    
+    def delete_task(self, row):
+        """删除任务
+        
+        Args:
+            row: 行索引
+        """
+        if 0 <= row < len(self.tasks):
+            # 从列表中删除
+            del self.tasks[row]
+            
+            # 从表格中删除
+            self.table.removeRow(row)
+                
+            # 如果删除的是当前任务，重置当前任务索引
+            if row == self.current_task_index:
+                self.current_task_index = -1
+                
+            # 发出任务删除信号
+            self.task_deleted.emit(row)
+    
+    def on_task_clicked(self, index):
+        """任务被点击时的处理
+        
+        Args:
+            index: 索引
+        """
+        row = index.row()
+        if 0 <= row < len(self.tasks):
+            self.current_task_index = row
+            # 发出信号，通知外部加载对应视频
+            self.task_selected.emit(row, self.tasks[row].path)
+            
+    def set_current_task(self, index):
+        """设置当前处理的任务
+        
+        Args:
+            index: 任务索引
+        """
+        if 0 <= index < len(self.tasks):
+            self.current_task_index = index
+            self.table.selectRow(index)
+            self.table.scrollTo(self.table.model().index(index, 0))
+        
+    def get_current_task_index(self):
+        """获取当前处理的任务索引
+
+        Returns:
+            int: 任务索引
+        """
+        return self.current_task_index
+            
+    def select_task(self, index):
+        """选中指定任务
+        
+        Args:
+            index: 任务索引
+        """
+        self.set_current_task(index)
+        if 0 <= index < len(self.tasks):
+            self.task_selected.emit(index, self.tasks[index].path)
+
+    def open_file_location(self, path):
+        """打开文件所在位置
+        
+        Args:
+            row: 行索引
+            path: 目标路径
+        """                
+        # 检查视频文件是否存在
+        if not os.path.exists(path):
+            InfoBar.warning(
+                title=tr['TaskList']['Warning'],
+                content=tr['TaskList']['UnableToLocateFile'],
+                parent=self.get_root_parent(),
+                duration=3000
+            )
+            return
+            
+        show_in_file_manager(os.path.abspath(path))
+
+    def get_root_parent(self):
+        parent = self
+        while parent.parent():
+            parent = parent.parent()
+        return parent
+
+    def update_task_option(self, index, task_option: TaskOptions, value):
+        """更新任务选项
+
+        Args:
+            index: 任务索引
+            task_option: 选项名
+            value: 选项值
+        """
+        if 0 <= index < len(self.tasks):
+            self.tasks[index].options[task_option.value] = value
+
+    def get_task_option(self, index, task_option: TaskOptions, default=None):
+        """获取任务选项
+        Args:
+            index: 任务索引
+            task_option: 选项名
+            default: 默认值
+        Returns:
+            选项值
+        """
+        if 0 <= index < len(self.tasks):
+            return self.tasks[index].options.get(task_option.value, default)
\ No newline at end of file
diff --git a/ui/component/video_display_component.py b/ui/component/video_display_component.py
new file mode 100644
index 0000000..dd1a1f7
--- /dev/null
+++ b/ui/component/video_display_component.py
@@ -0,0 +1,976 @@
+import sys
+import cv2
+from PySide6.QtWidgets import QWidget, QVBoxLayout
+from PySide6.QtCore import Qt, Signal, QRect, QRectF, QObject, QEvent
+from PySide6.QtGui import QAction, QShortcut, QCursor
+from PySide6 import QtCore, QtWidgets, QtGui 
+from qfluentwidgets import qconfig, CardWidget, HollowHandleStyle, RoundMenu
+
+from backend.config import config, tr
+from backend.bean.subtitle_area import SubtitleArea
+
+class VideoDisplayComponent(QWidget):
+    """视频显示组件，包含视频预览和选择框功能"""
+    
+    # 定义信号
+    selections_changed = Signal(list)  # 选择框变化信号
+    ab_sections_changed = Signal(list)  # AB分区变化信号
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.parent = parent
+        
+        # 初始化变量
+        self.is_drawing = False
+        self.selection_rect = SubtitleArea(0, 0, 0, 0)  # 当前正在绘制或调整的选区
+        self.selection_rects = []  # 存储多个选区，每个元素为 SubtitleArea
+        self.active_selection_index = -1  # 当前活动选区的索引
+        self.drag_start_pos = None
+        self.resize_edge = None
+        self.edge_size = 10  # 调整大小的边缘区域
+        self.enable_mouse_events = True  # 控制是否启用鼠标事件
+        
+        # AB分区标记相关变量
+        self.ab_sections = []  # 存储AB分区标记 [range(start, end), ...]
+        self.current_ab_start = -1  # 当前AB分区的起点
+        
+        # 创建右键菜单
+        self.__init_context_menu()
+        
+        # 获取屏幕大小
+        screen = QtWidgets.QApplication.primaryScreen().size()
+        self.screen_width = screen.width()
+        self.screen_height = screen.height()
+        
+        # 设置视频预览区域大小（根据屏幕宽度动态调整）
+        self.video_preview_width = 960
+        self.video_preview_height = self.video_preview_width * 9 // 16
+        if self.screen_width // 2 < 960:
+            self.video_preview_width = 640
+            self.video_preview_height = self.video_preview_width * 9 // 16
+            
+        # 视频相关参数
+        self.frame_width = None
+        self.frame_height = None
+        self.scaled_width = None
+        self.scaled_height = None
+        self.border_left = 0
+        self.border_top = 0
+        self.fps = 30
+
+        self.__init_widgets()
+        self.__init_shotcuts()
+        
+    def __init_widgets(self):
+        """初始化组件"""
+        main_layout = QVBoxLayout(self)
+        main_layout.setSpacing(0)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        
+        # 视频预览区域和进度条容器
+        self.video_container = CardWidget(self)
+        self.video_container.setObjectName('videoContainer')
+        video_layout = QVBoxLayout()
+        video_layout.setSpacing(0)
+        video_layout.setContentsMargins(2, 2, 2, 2)
+        video_layout.setAlignment(Qt.AlignCenter)
+        
+        # 创建内部黑色背景容器
+        self.black_container = QWidget(self)
+        self.black_container.setObjectName('blackContainer')
+        self.black_container.setStyleSheet("""
+            #blackContainer {
+                background-color: black;
+                border-radius: 10px;
+                border: 0px solid transparent;
+            }
+        """)
+        black_layout = QVBoxLayout()
+        black_layout.setContentsMargins(0, 0, 0, 0)
+        black_layout.setSpacing(0)
+        black_layout.setAlignment(Qt.AlignCenter)
+        
+        # 视频显示标签
+        self.video_display = QtWidgets.QLabel()
+        self.video_display.setStyleSheet("""
+            background-color: black;
+            border-top-left-radius: 10px;
+            border-top-right-radius: 10px;
+            border: 0px solid transparent;
+        """)
+        self.video_display.setMinimumSize(self.video_preview_width, self.video_preview_height)
+        
+        self.video_display.setMouseTracking(True)
+        self.video_display.setScaledContents(True)
+        self.video_display.setAlignment(Qt.AlignCenter)
+        self.video_display.mousePressEvent = self.selection_mouse_press
+        self.video_display.mouseMoveEvent = self.selection_mouse_move
+        self.video_display.mouseReleaseEvent = self.selection_mouse_release
+        
+        # 视频滑块
+        self.video_slider = QtWidgets.QSlider(Qt.Horizontal)
+        self.video_slider.setMinimum(1)
+        self.video_slider.setFixedHeight(22)
+        self.video_slider.setMaximum(100)  # 默认最大值设为100，与进度百分比一致
+        self.video_slider.setValue(1)
+        self.video_slider.setStyle(HollowHandleStyle({
+            "handle.color": QtGui.QColor(255, 255, 255),
+            "handle.ring-width": 4,
+            "handle.hollow-radius": 6,
+            "handle.margin": 1
+        }))
+        
+        # 视频预览区域
+        self.video_display.setObjectName('videoDisplay')
+        # black_layout.addWidget(self.video_display, 0, Qt.AlignCenter)
+        # 创建一个容器来保持比例
+        ratio_container = QWidget()
+        ratio_layout = QVBoxLayout(ratio_container)
+        ratio_layout.setContentsMargins(0, 0, 0, 0)
+        ratio_layout.addWidget(self.video_display)
+
+        # 设置固定的宽高比
+        ratio_container.setFixedHeight(ratio_container.width() * 9 // 16)
+        ratio_container.setMinimumWidth(self.video_preview_width)
+
+        # 添加到布局
+        black_layout.addWidget(ratio_container)
+
+        # 添加一个事件过滤器来处理大小变化
+        class RatioEventFilter(QObject):
+            def eventFilter(self, obj, event):
+                if event.type() == QEvent.Resize:
+                    obj.setFixedHeight(obj.width() * 9 // 16)
+                return False
+
+        ratio_filter = RatioEventFilter(ratio_container)
+        ratio_container.installEventFilter(ratio_filter)
+
+        # 进度条和滑块容器
+        control_container = QWidget(self)
+        control_layout = QVBoxLayout()
+        control_layout.setContentsMargins(8, 8, 8, 8)
+        control_layout.addWidget(self.video_slider)
+        
+        control_container.setLayout(control_layout)
+        control_container.setStyleSheet("""
+            background-color: black;
+            border-bottom-left-radius: 8px;
+            border-bottom-right-radius: 8px;        
+        """)
+        black_layout.addWidget(control_container)
+        
+        self.black_container.setLayout(black_layout)
+        video_layout.addWidget(self.black_container)
+        self.video_container.setLayout(video_layout)
+        main_layout.addWidget(self.video_container)
+    
+    def __init_shotcuts(self):
+        """初始化快捷键"""
+
+        if sys.platform == "darwin":
+            self.shortcut_delete_selection = QShortcut(QtGui.QKeySequence.Backspace, self)
+        else:
+            self.shortcut_delete_selection = QShortcut(QtGui.QKeySequence.Delete, self)
+        self.shortcut_delete_selection.activated.connect(self.__handle_delete_selection)
+        self.shortcut_delete_selection.setContext(Qt.ApplicationShortcut)
+
+
+        # 添加左右键控制slider的快捷键
+        self.shortcut_right = QShortcut(QtGui.QKeySequence(Qt.Key_Right), self)
+        self.shortcut_right.activated.connect(lambda: self.__adjust_slider_value(self.fps))
+        self.shortcut_right.setContext(Qt.ApplicationShortcut)
+        
+        self.shortcut_left = QShortcut(QtGui.QKeySequence(Qt.Key_Left), self)
+        self.shortcut_left.activated.connect(lambda: self.__adjust_slider_value(-self.fps))
+        self.shortcut_left.setContext(Qt.ApplicationShortcut)
+        
+        # 添加Ctrl+左右键控制slider的快捷键
+        self.shortcut_ctrl_right = QShortcut(QtGui.QKeySequence("Ctrl+Right"), self)
+        self.shortcut_ctrl_right.activated.connect(lambda: self.__adjust_slider_value(self.fps*5))
+        self.shortcut_ctrl_right.setContext(Qt.ApplicationShortcut)
+        
+        self.shortcut_ctrl_left = QShortcut(QtGui.QKeySequence("Ctrl+Left"), self)
+        self.shortcut_ctrl_left.activated.connect(lambda: self.__adjust_slider_value(-self.fps*5))
+        self.shortcut_ctrl_left.setContext(Qt.ApplicationShortcut)
+        
+        # 添加Shift+左右键控制slider的快捷键
+        self.shortcut_shift_right = QShortcut(QtGui.QKeySequence("Shift+Right"), self)
+        self.shortcut_shift_right.activated.connect(lambda: self.__adjust_slider_value(1))
+        self.shortcut_shift_right.setContext(Qt.ApplicationShortcut)
+        
+        self.shortcut_shift_left = QShortcut(QtGui.QKeySequence("Shift+Left"), self)
+        self.shortcut_shift_left.activated.connect(lambda: self.__adjust_slider_value(-1))
+        self.shortcut_shift_left.setContext(Qt.ApplicationShortcut)
+
+    def update_video_display(self, frame, draw_selection=True):
+        """更新视频显示"""
+        if frame is None:
+            return
+
+        # 调整视频帧大小以适应视频预览区域
+        frame = cv2.resize(frame, (self.video_preview_width, self.video_preview_height))
+        # 将 OpenCV 帧（BGR 格式）转换为 QImage 并显示在 QLabel 上
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        h, w, ch = rgb_frame.shape
+        bytes_per_line = ch * w
+        image = QtGui.QImage(rgb_frame.data, w, h, bytes_per_line, QtGui.QImage.Format_RGB888)
+        pix = QtGui.QPixmap.fromImage(image)
+        
+        # 创建带圆角的图像
+        rounded_pix = QtGui.QPixmap(pix.size())
+        rounded_pix.fill(Qt.transparent)  # 填充透明背景
+        
+        painter = QtGui.QPainter(rounded_pix)
+        painter.setRenderHint(QtGui.QPainter.Antialiasing)  # 抗锯齿
+        painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform, True)
+        
+        # 创建圆角路径
+        path = QtGui.QPainterPath()
+        rect = QRectF(0, 0, pix.width(), pix.height())
+        
+        # 手动创建只有左上和右上圆角的路径
+        radius = 8
+        path.moveTo(radius, 0)
+        path.lineTo(pix.width() - radius, 0)
+        path.arcTo(pix.width() - radius * 2, 0, radius * 2, radius * 2, 90, -90)
+        path.lineTo(pix.width(), pix.height())
+        path.lineTo(0, pix.height())
+        path.lineTo(0, radius)
+        path.arcTo(0, 0, radius * 2, radius * 2, 180, -90)
+        path.closeSubpath()
+        
+        painter.setClipPath(path)
+        painter.drawPixmap(0, 0, pix)
+        painter.end()
+        
+        # 保存当前的pixmap用于绘制选择框
+        self.current_pixmap = rounded_pix.copy()
+        
+        self.video_display.setPixmap(rounded_pix)
+            
+        # 在滑动的过程中, 更新当前激活选区
+        self.auto_active_selection()
+        # 更新视频显示
+        self.update_preview_with_rect(draw_selection=draw_selection)
+    
+    def auto_active_selection(self):
+        """自动激活当前帧所在的选区"""
+        current_frame = self.video_slider.value()
+        if self.active_selection_index >= 0 and self.active_selection_index < len(self.selection_rects):
+            selection_rect = self.selection_rects[self.active_selection_index]
+            if selection_rect.in_ab_section(current_frame):
+                return
+        # 遍历所有选区，找到当前帧所在的选区
+        for i in range(len(self.selection_rects) - 1, -1, -1):
+            rect = self.selection_rects[i]
+            if rect.in_ab_section(current_frame):
+                self.active_selection_index = i
+                self.selection_rect = rect
+                return
+
+    def update_preview_with_rect(self, rect=None, draw_selection=True):
+        """更新带有选择框的预览"""
+        if not hasattr(self, 'current_pixmap') or self.current_pixmap is None:
+            return
+            
+        # 如果提供了新的矩形，使用它
+        if rect is not None and self.active_selection_index >= 0:
+            self.selection_rects[self.active_selection_index] = rect
+            
+        # 创建一个副本用于绘制
+        pixmap_copy = self.current_pixmap.copy()
+        painter = QtGui.QPainter(pixmap_copy)
+        
+        # 绘制所有选区
+        if draw_selection:
+            # 计算缩放比例
+            display_size = self.video_display.size()
+            pixmap_size = self.current_pixmap.size()
+            scale_x = pixmap_size.width() / display_size.width()
+            scale_y = pixmap_size.height() / display_size.height()
+            video_display_width = self.video_display.width()
+            video_display_height = self.video_display.height()
+            current_frame = self.video_slider.value()
+            for i, rect in enumerate(self.selection_rects):
+                if not rect.in_ab_section(current_frame):
+                    continue
+                # 设置选择框样式
+                if i == self.active_selection_index:
+                    if rect.ab_section is not None:
+                        # 非全局选区使用深绿
+                        pen = QtGui.QPen(QtGui.QColor(0x38, 0x8e, 0x3c))
+                    else:
+                        # 活动选区使用绿色
+                        pen = QtGui.QPen(QtGui.QColor(0, 255, 0))
+                else:
+                    if rect.ab_section is not None:
+                        # 非全局选区使用亮芥末黄
+                        pen = QtGui.QPen(QtGui.QColor(0xFF, 0xD5, 0x4f))
+                    else:
+                        # 非活动选区使用黄色
+                        pen = QtGui.QPen(QtGui.QColor(255, 255, 0))
+                pen.setWidth(2)
+                painter.setPen(pen)
+                
+                # 将比例坐标转换为像素坐标
+                pixel_rect = QRect(
+                    int(rect.xmin * scale_x * video_display_width),
+                    int(rect.ymin * scale_y * video_display_height),
+                    int(rect.width * scale_x * video_display_width),
+                    int(rect.height * scale_y * video_display_height)
+                )
+                
+                # 绘制选择框
+                painter.drawRect(pixel_rect)
+            
+            # 如果正在绘制新选区，也绘制它
+            if self.is_drawing and not self.selection_rect.is_empty():
+                pen = QtGui.QPen(QtGui.QColor(0, 255, 0))  # 绿色
+                pen.setWidth(2)
+                painter.setPen(pen)
+                
+                # 将比例坐标转换为像素坐标
+                rect = self.selection_rect
+                pixel_rect = QRect(
+                    int(rect.xmin * scale_x * video_display_width),
+                    int(rect.ymin * scale_y * video_display_height),
+                    int(rect.width * scale_x * video_display_width),
+                    int(rect.height * scale_y * video_display_height)
+                )
+                
+                painter.drawRect(pixel_rect)
+            
+        # 绘制AB分区标记
+        total_frames = self.video_slider.maximum()
+        if total_frames > 0 and self.ab_sections:
+            # 在视频显示区域下方5像素处绘制AB分区标记
+            ab_rect_height = 5
+            ab_rect_y = pixmap_copy.height() - ab_rect_height
+            
+            # 设置半透明白色画刷
+            painter.setPen(Qt.NoPen)
+            painter.setBrush(QtGui.QColor(255, 255, 255, 128))  # 半透明白色
+            
+            # 计算可用宽度（考虑左右边距）
+            left_margin = 15
+            right_margin = 15
+            available_width = pixmap_copy.width() - left_margin - right_margin
+            
+            for section_range in self.ab_sections:
+                # 计算相对位置
+                start_x = left_margin + int((section_range.start / total_frames) * available_width)
+                end_x = left_margin + int((section_range.stop / total_frames) * available_width)
+                
+                # 绘制AB分区矩形
+                painter.drawRect(start_x, ab_rect_y, end_x - start_x, ab_rect_height)
+        
+        # 绘制selection的ab分区
+        for i, rect in enumerate(self.selection_rects):
+            section_range = rect.ab_section
+            if section_range is None:
+                continue
+            # 在视频显示区域下方2像素处绘制AB分区标记
+            ab_rect_height = 2
+            ab_rect_y = pixmap_copy.height() - ab_rect_height
+            # 设置半透明色画刷
+            painter.setPen(Qt.NoPen)
+            painter.setBrush(QtGui.QColor(100, 180, 255, 180))  # 半透明黄色
+             # 计算可用宽度（考虑左右边距）
+            left_margin = 15
+            right_margin = 15
+            available_width = pixmap_copy.width() - left_margin - right_margin
+            # 计算相对位置
+            start_x = left_margin + int((section_range.start / total_frames) * available_width)
+            end_x = left_margin + int((section_range.stop / total_frames) * available_width)
+            
+            # 绘制AB分区矩形
+            painter.drawRect(start_x, ab_rect_y, end_x - start_x, ab_rect_height)
+
+        # 绘制current_ab_start的高亮竖线
+        if self.current_ab_start >= 0 and total_frames > 0:
+            # 计算可用宽度（考虑左右边距）
+            left_margin = 15
+            right_margin = 15
+            available_width = pixmap_copy.width() - left_margin - right_margin
+            
+            # 计算current_ab_start的相对位置
+            start_x = left_margin + int((self.current_ab_start / total_frames) * available_width)
+            
+            # 设置高亮白色画笔
+            pen = QtGui.QPen(QtGui.QColor(255, 255, 255))  # 纯白色
+            pen.setWidth(2)
+            painter.setPen(pen)
+            
+            # 绘制高亮竖线，高度为5像素
+            ab_line_height = 5
+            ab_line_y = pixmap_copy.height() - ab_line_height
+            painter.drawLine(start_x, ab_line_y, start_x, pixmap_copy.height())
+        
+        painter.end()
+        
+        # 更新显示
+        self.video_display.setPixmap(pixmap_copy)
+    
+    def selection_mouse_press(self, event):
+        """鼠标按下事件处理"""
+        if not self.enable_mouse_events:
+            return
+        
+        video_display_width = self.video_display.width()
+        video_display_height = self.video_display.height()
+
+        # 忽略双击
+        if event.type() == QEvent.MouseButtonDblClick:
+            return
+
+        # 检查是否点击了已有选区
+        pos = event.pos()
+        y_ratio = (pos.y() - self.border_top) / video_display_height if video_display_height > 0 else 0
+        x_ratio = (pos.x() - self.border_left) / video_display_width if video_display_width > 0 else 0
+        
+        clicked_index = -1
+        current_frame = self.video_slider.value()
+        for i, rect in enumerate(self.selection_rects):
+            if not rect.in_ab_section(current_frame):
+                continue
+            # 将比例坐标转换为像素坐标用于检测
+            pixel_rect = QRect(
+                int(rect.xmin * video_display_width) + self.border_left,
+                int(rect.ymin * video_display_height) + self.border_top,
+                int(rect.width * video_display_width),
+                int(rect.height * video_display_height)
+            )
+            
+            # 检查是否在选区边缘（用于调整大小）
+            if self.is_on_rect_edge(pos, pixel_rect):
+                clicked_index = i
+                self.active_selection_index = i
+                # 右键点击边缘时不设置resize_edge，避免意外调整大小
+                if event.button() == Qt.LeftButton:
+                    self.resize_edge = self.get_resize_edge(pos, pixel_rect)
+                    self.drag_start_pos = (y_ratio, x_ratio)
+                else:
+                    self.resize_edge = None
+                self.update_preview_with_rect()
+                break
+            # 检查是否在选区内部（用于移动或激活）
+            elif pixel_rect.contains(pos):
+                clicked_index = i
+                self.active_selection_index = i
+                # 右键点击内部时不设置move模式，避免意外移动
+                if event.button() == Qt.LeftButton:
+                    self.resize_edge = "move"
+                    self.drag_start_pos = (y_ratio, x_ratio)
+                else:
+                    self.resize_edge = None
+                self.update_preview_with_rect()
+                break
+        
+        # 右键点击处理：如果点击了选区则显示上下文菜单，否则也显示菜单
+        if event.button() == Qt.RightButton:
+            self.context_menu.exec_(QCursor.pos())
+            return
+        
+        # 如果没有点击任何选区且是左键，开始绘制新选区
+        if clicked_index == -1 and event.button() == Qt.LeftButton:
+            self.is_drawing = True
+            # VSE只保留一个选区
+            self.selection_rects = []
+            self.selection_rect = SubtitleArea(y_ratio, y_ratio, x_ratio, x_ratio)
+            self.drag_start_pos = (y_ratio, x_ratio)
+            self.resize_edge = None
+            self.active_selection_index = -1
+
+    def is_on_rect_edge(self, pos, pixel_rect):
+        """检查点是否在矩形边缘
+        注意：这里的pixel_rect是已经转换为像素坐标的QRect对象
+        """
+        # 右下角
+        if abs(pos.x() - pixel_rect.right()) <= self.edge_size and abs(pos.y() - pixel_rect.bottom()) <= self.edge_size:
+            return True
+        # 右上角
+        elif abs(pos.x() - pixel_rect.right()) <= self.edge_size and abs(pos.y() - pixel_rect.top()) <= self.edge_size:
+            return True
+        # 左下角
+        elif abs(pos.x() - pixel_rect.left()) <= self.edge_size and abs(pos.y() - pixel_rect.bottom()) <= self.edge_size:
+            return True
+        # 左上角
+        elif abs(pos.x() - pixel_rect.left()) <= self.edge_size and abs(pos.y() - pixel_rect.top()) <= self.edge_size:
+            return True
+        # 左边缘
+        elif abs(pos.x() - pixel_rect.left()) <= self.edge_size and pixel_rect.top() <= pos.y() <= pixel_rect.bottom():
+            return True
+        # 右边缘
+        elif abs(pos.x() - pixel_rect.right()) <= self.edge_size and pixel_rect.top() <= pos.y() <= pixel_rect.bottom():
+            return True
+        # 上边缘
+        elif abs(pos.y() - pixel_rect.top()) <= self.edge_size and pixel_rect.left() <= pos.x() <= pixel_rect.right():
+            return True
+        # 下边缘
+        elif abs(pos.y() - pixel_rect.bottom()) <= self.edge_size and pixel_rect.left() <= pos.x() <= pixel_rect.right():
+            return True
+        return False
+
+    def get_resize_edge(self, pos, rect):
+        """获取调整大小的边缘类型"""
+        # 右下角
+        if abs(pos.x() - rect.right()) <= self.edge_size and abs(pos.y() - rect.bottom()) <= self.edge_size:
+            return "bottomright"
+        # 右上角
+        elif abs(pos.x() - rect.right()) <= self.edge_size and abs(pos.y() - rect.top()) <= self.edge_size:
+            return "topright"
+        # 左下角
+        elif abs(pos.x() - rect.left()) <= self.edge_size and abs(pos.y() - rect.bottom()) <= self.edge_size:
+            return "bottomleft"
+        # 左上角
+        elif abs(pos.x() - rect.left()) <= self.edge_size and abs(pos.y() - rect.top()) <= self.edge_size:
+            return "topleft"
+        # 左边缘
+        elif abs(pos.x() - rect.left()) <= self.edge_size and rect.top() <= pos.y() <= rect.bottom():
+            return "left"
+        # 右边缘
+        elif abs(pos.x() - rect.right()) <= self.edge_size and rect.top() <= pos.y() <= rect.bottom():
+            return "right"
+        # 上边缘
+        elif abs(pos.y() - rect.top()) <= self.edge_size and rect.left() <= pos.x() <= rect.right():
+            return "top"
+        # 下边缘
+        elif abs(pos.y() - rect.bottom()) <= self.edge_size and rect.left() <= pos.x() <= rect.right():
+            return "bottom"
+        return None
+
+    def selection_mouse_move(self, event):
+        """鼠标移动事件处理"""
+        if not self.enable_mouse_events:
+            return
+        
+        video_display_width = self.video_display.width()
+        video_display_height = self.video_display.height()
+        
+        pos = event.pos()
+        y_ratio = (pos.y() - self.border_top) / video_display_height if video_display_height > 0 else 0
+        x_ratio = (pos.x() - self.border_left) / video_display_width if video_display_width > 0 else 0
+        
+        # 限制比例值在0-1范围内
+        y_ratio = max(0, min(1, y_ratio))
+        x_ratio = max(0, min(1, x_ratio))
+        
+        # 根据不同的操作模式处理鼠标移动
+        if self.is_drawing:  # 绘制新选择框
+            # 更新选择框的右下角，保留原始拖动方向
+            rect = self.selection_rect
+            self.selection_rect = SubtitleArea(rect.ymin, y_ratio, rect.xmin, x_ratio, rect.ab_section)
+            self.update_preview_with_rect()
+        elif self.resize_edge and self.active_selection_index >= 0:  # 调整选择框大小或位置
+            rect = self.selection_rects[self.active_selection_index]
+            start_y, start_x = self.drag_start_pos
+            
+            if self.resize_edge == "move":
+                # 移动整个选择框
+                dy = y_ratio - start_y
+                dx = x_ratio - start_x
+                
+                # 计算新位置，确保不超出边界
+                new_ymin = max(0, min(1 - rect.height, rect.ymin + dy))
+                new_ymax = min(1, max(new_ymin + rect.height, new_ymin))
+                new_xmin = max(0, min(1 - rect.width, rect.xmin + dx))
+                new_xmax = min(1, max(new_xmin + rect.width, new_xmin))
+                
+                _rect = SubtitleArea(new_ymin, new_ymax, new_xmin, new_xmax, rect.ab_section)
+                _rect.normalized()
+                self.selection_rects[self.active_selection_index] = _rect
+                self.drag_start_pos = (y_ratio, x_ratio)
+            else:
+                ymin = rect.ymin
+                ymax = rect.ymax
+                xmin = rect.xmin
+                xmax = rect.xmax
+                if "left" in self.resize_edge:
+                    xmin = min(xmax - 0.01, x_ratio)
+                if "right" in self.resize_edge:
+                    xmax = max(xmin + 0.01, x_ratio)
+                if "top" in self.resize_edge:
+                    ymin = min(ymax - 0.01, y_ratio)
+                if "bottom" in self.resize_edge:
+                    ymax = max(ymin + 0.01, y_ratio)
+
+                # 确保选择框在有效范围内
+                xmin = max(0, min(xmin, 1))
+                xmax = max(0, min(xmax, 1))
+                ymin = max(0, min(ymin, 1))
+                ymax = max(0, min(ymax, 1))
+                
+                _rect = SubtitleArea(ymin, ymax, xmin, xmax, rect.ab_section)
+                _rect.normalized()
+                self.selection_rects[self.active_selection_index] = _rect
+            
+            self.update_preview_with_rect()
+        else:
+            # 更新鼠标光标形状
+            self.update_cursor_shape(pos)
+    
+    def selection_mouse_release(self, event):
+        """鼠标释放事件处理"""
+        if not self.enable_mouse_events:
+            return
+            
+        # 结束绘制或调整
+        if self.is_drawing:
+            # 标准化选择框（确保ymin < ymax, xmin < xmax）
+            rect = self.selection_rect
+            rect.normalized()
+            
+            # 如果选择框有效（不是点击），添加到选区列表
+            # 使用比例值计算宽度和高度
+            # 转换为像素大小进行判断
+            pixel_width = rect.width * self.video_display.width()
+            pixel_height = rect.height * self.video_display.height()
+            
+            if pixel_width > 5 and pixel_height > 5:
+                self.selection_rects.append(self.selection_rect)
+                self.active_selection_index = len(self.selection_rects) - 1
+                
+                # 发送选择框变化信号
+                self.selections_changed.emit(self.selection_rects)
+            
+            self.is_drawing = False
+            self.selection_rect = (0, 0, 0, 0)  # 重置为空选区
+        elif self.resize_edge and self.active_selection_index >= 0:
+            # 标准化选择框
+            rect = self.selection_rects[self.active_selection_index]
+           
+            # 确保坐标规范化
+            rect.normalized()            
+                        
+            # 发送选择框变化信号
+            self.selections_changed.emit(self.selection_rects)
+            
+            self.resize_edge = None
+        
+    def update_cursor_shape(self, pos):
+        """根据鼠标位置更新光标形状"""
+        video_display_height = self.video_display.height()
+        video_display_width = self.video_display.width()
+        
+        selection_rects = []
+        _selection_rects = self.selection_rects.copy()
+        # 如果有活动选区，优先检查活动选区
+        if self.active_selection_index >= 0 and self.active_selection_index < len(self.selection_rects):
+            selection_rects.append(_selection_rects.pop(self.active_selection_index))
+
+        selection_rects.extend(_selection_rects)
+        current_frame = self.video_slider.value()
+        for rect in selection_rects:
+            if not rect.in_ab_section(current_frame):
+                continue
+            # 确保坐标规范化
+            rect.normalized()
+            
+            # 将比例坐标转换为像素坐标
+            pixel_rect = QRect(
+                round(rect.xmin * video_display_width) + self.border_left,
+                round(rect.ymin * video_display_height) + self.border_top,
+                round(rect.width * video_display_width),
+                round(rect.height * video_display_height)
+            )
+            
+            # 检查鼠标是否在选择框边缘
+            if self.is_on_rect_edge(pos, pixel_rect):
+                # 根据边缘类型设置光标
+                edge_type = self.get_resize_edge(pos, pixel_rect)
+                if edge_type == "left" or edge_type == "right":
+                    self.video_display.setCursor(Qt.SizeHorCursor)
+                    return
+                elif edge_type == "top" or edge_type == "bottom":
+                    self.video_display.setCursor(Qt.SizeVerCursor)
+                    return
+                elif edge_type == "topleft" or edge_type == "bottomright":
+                    self.video_display.setCursor(Qt.SizeFDiagCursor)
+                    return
+                elif edge_type == "topright" or edge_type == "bottomleft":
+                    self.video_display.setCursor(Qt.SizeBDiagCursor)
+                    return
+            # 检查鼠标是否在选择框内部
+            elif pixel_rect.contains(pos):
+                self.video_display.setCursor(Qt.SizeAllCursor)
+                return
+        
+        # 如果鼠标不在任何选区上，设置为默认光标
+        self.video_display.setCursor(Qt.ArrowCursor)
+    
+    def set_video_parameters(self, frame_width, frame_height, 
+                             scaled_width=None, scaled_height=None, 
+                             border_left=0, border_top=0, 
+                             fps=30):
+        """设置视频参数"""
+        self.frame_width = frame_width
+        self.frame_height = frame_height
+        self.scaled_width = scaled_width
+        self.scaled_height = scaled_height
+        self.border_left = border_left
+        self.border_top = border_top
+        self.fps = fps
+    
+    def get_selection_coordinates(self):
+        """获取选择框坐标"""
+        return self.selection_rect
+    
+    def set_selection_rects(self, rects):
+        """设置选择框"""
+        self.selection_rects = rects
+        self.selection_rect = rects[-1] if rects else QRect()
+        self.active_selection_index = len(rects) - 1
+        self.update_preview_with_rect()
+    
+    def load_selections_from_config(self):
+        """从配置中加载选择框的相对位置和大小"""
+        # 从配置中读取选择框的相对位置和大小
+        areas_str = config.subtitleSelectionAreas.value
+        
+        # 检查配置值是否有效
+        if not areas_str:
+            return False
+
+        # 清空现有选区
+        selection_rects = []
+        
+        # 解析配置字符串
+        areas = areas_str.split(";")
+        for area in areas:
+            try:
+                parts = area.split(",")
+                ymin, ymax, xmin, xmax = map(float, parts)
+                selection_rects.append(SubtitleArea(ymin, ymax, xmin, xmax))
+            except ValueError:
+                continue
+        
+        # 更新预览
+        self.update_preview_with_rect()
+        
+        return selection_rects
+    
+    def preview_coordinates_to_video_coordinates(self, preview_selection_rects):
+        """获取选择框在原始视频中的坐标"""
+        selection_rects = []
+        video_display_height = self.video_display.height()
+        video_display_width = self.video_display.width()
+        for rect in preview_selection_rects:
+                
+            # 调整选择框坐标，考虑黑边偏移
+            x_adjusted = max(0, rect.xmin - self.border_left)
+            y_adjusted = max(0, rect.ymin - self.border_top)
+            
+            # 如果选择框超出了实际视频区域，需要调整宽度和高度
+            w_adjusted = min(rect.width, self.scaled_width - x_adjusted)
+            h_adjusted = min(rect.height, self.scaled_height - y_adjusted)
+            # 转换为原始视频坐标
+            scale_x = self.frame_width / (self.scaled_width * video_display_width)
+            scale_y = self.frame_height / (self.scaled_height * video_display_height)
+
+            # 使用round代替int，避免精度丢失
+            xmin = round(x_adjusted * scale_x * video_display_width)
+            xmax = round((x_adjusted + w_adjusted) * scale_x * video_display_width)
+            ymin = round(y_adjusted * scale_y * video_display_height)
+            ymax = round((y_adjusted + h_adjusted) * scale_y * video_display_height)
+            
+            # 确保坐标在有效范围内
+            xmin = max(0, min(xmin, self.frame_width))
+            xmax = max(0, min(xmax, self.frame_width))
+            ymin = max(0, min(ymin, self.frame_height))
+            ymax = max(0, min(ymax, self.frame_height))
+            
+            _rect = SubtitleArea(ymin, ymax, xmin, xmax, rect.ab_section)
+            _rect.normalized()
+            selection_rects.append(_rect)
+        return selection_rects
+
+    def set_dragger_enabled(self, enabled):
+        """设置拖动器是否可用"""
+        self.enable_mouse_events = enabled
+        self.video_display.setMouseTracking(enabled)
+        self.video_display.setCursor(Qt.ArrowCursor)
+
+    def save_selections_to_config(self):
+        """保存所有选择框的相对位置和大小"""
+        areas_str_parts = []
+        
+        for rect in self.selection_rects:
+            # 直接使用比例值，四舍五入到4位小数
+            areas_str_parts.append(f"{round(rect.ymin,4)},{round(rect.ymax,4)},{round(rect.xmin,4)},{round(rect.xmax,4)}")
+        
+        # 更新配置
+        config.subtitleSelectionAreas.value = ";".join(areas_str_parts)
+        if len(config.subtitleSelectionAreas.value) <= 0:
+            config.subtitleSelectionAreas.value = config.subtitleSelectionAreas.defaultValue
+        qconfig.save()
+    
+    def get_selection_rects(self):
+        """获取所有选区"""
+        return self.selection_rects
+    
+    def clear_selections(self):
+        """清除所有选区"""
+        self.selection_rects = []
+        self.active_selection_index = -1
+        self.update_preview_with_rect()
+        self.selections_changed.emit(self.selection_rects)
+
+    def __handle_delete_selection(self):
+        """处理删除当前选区的逻辑"""
+        try:
+            if self.active_selection_index >= 0 and self.selection_rects:
+                # 删除当前活跃选区
+                self.selection_rects.pop(self.active_selection_index)
+                
+                # 如果还有其他选区，将最后一个选区设为活跃选区
+                if self.selection_rects:
+                    self.active_selection_index = len(self.selection_rects) - 1
+                else:
+                    self.active_selection_index = -1
+                
+                # 更新显示
+                self.update_preview_with_rect()
+                
+                # 发送选区变化信号
+                self.selections_changed.emit(self.selection_rects)
+                return True
+            return False
+        finally:
+            # 获取当前鼠标位置
+            global_pos = QCursor.pos()
+            pos = self.video_display.mapFromGlobal(global_pos)
+            self.update_cursor_shape(pos)
+
+    def __handle_mark_for_ab_start(self):
+        """处理标记AB分区起点的逻辑"""
+        current_frame = self.video_slider.value()
+        if current_frame >= 0:
+            # 记录新的AB分区起点
+            self.current_ab_start = current_frame
+            # 更新显示
+            self.update_preview_with_rect()
+            return True
+        return False
+
+    def __handle_mark_for_ab_end(self):
+        """处理标记AB分区终点的逻辑"""
+        current_frame = self.video_slider.value()
+        if current_frame >= 0 and self.current_ab_start >= 0:
+            if self.current_ab_start != current_frame:
+                # 添加新的AB分区
+                self.ab_sections.append(range(self.current_ab_start, current_frame + 1))
+                self.current_ab_start = -1  # 重置起点
+                self.ab_sections_changed.emit(self.ab_sections)
+            
+            # 更新显示
+            self.update_preview_with_rect()
+            return True
+        return False
+
+    def __handle_delete_ab_section(self):
+        """处理删除当前AB区块的逻辑"""
+        current_frame = self.video_slider.value()
+        if current_frame >= 0 and self.ab_sections:
+            # 查找当前帧所在的AB区块
+            for i in range(len(self.ab_sections) - 1, -1, -1):
+                section_range = self.ab_sections[i]
+                if current_frame in section_range:
+                    # 删除该AB区块
+                    self.ab_sections.pop(i)
+                    
+                    # 如果当前有标记的起点，且在被删除的区块内，重置起点
+                    if self.current_ab_start in section_range:
+                        self.current_ab_start = -1
+                    
+                    # 发送AB区块变化信号
+                    self.ab_sections_changed.emit(self.ab_sections)
+                    
+                    # 更新显示
+                    self.update_preview_with_rect()
+                    return True
+        return False
+    
+    def __handle_bind_selection_to_ab_section(self):
+        """处理绑定当前选区到AB分区的逻辑"""
+        if self.active_selection_index >= 0 and self.selection_rects:
+            # 获取当前选区的坐标
+            selection_rect = self.selection_rects[self.active_selection_index]
+            current_frame = self.video_slider.value()
+            if current_frame >= 0 and self.ab_sections:
+                # 查找当前帧所在的AB区块
+                # 反向查找, 因为AB分区是按顺序添加的, 所以从后往前查找, 可以拿到最后添加的
+                for section_range in reversed(self.ab_sections):
+                    if current_frame in section_range:
+                        # 为了方便使用, 默认支持解绑
+                        if selection_rect.ab_section == section_range:
+                            selection_rect.ab_section = None
+                        else:
+                            selection_rect.ab_section = section_range
+                        self.update_preview_with_rect()
+                        return True
+            # 没找到, 设为全局
+            selection_rect.ab_section = None
+            self.update_preview_with_rect()
+            return True
+        return False
+
+            
+    def __adjust_slider_value(self, delta):
+        """调整视频滑块的值"""
+        current_value = self.video_slider.value()
+        max_value = self.video_slider.maximum()
+        new_value = current_value + int(delta)
+        
+        # 确保新值在有效范围内
+        if new_value < self.video_slider.minimum():
+            new_value = self.video_slider.minimum()
+        elif new_value > max_value:
+            new_value = max_value
+            
+        # 设置新值
+        self.video_slider.setValue(new_value)
+
+    def eventFilter(self, obj, event):
+        """事件过滤器，处理键盘事件"""
+        if event.type() == QEvent.KeyPress:
+            # 处理退格键和删除键
+            if event.key() == Qt.Key_Backspace or event.key() == Qt.Key_Delete:
+                if self.__handle_delete_selection():
+                    return True
+        # 对于其他事件，继续传递给父类处理
+        return super().eventFilter(obj, event)
+
+    def __init_context_menu(self):
+        """初始化右键菜单"""
+        self.context_menu = RoundMenu()
+
+        self.action_delete_selection = QAction(tr['SubtitleExtractorGUI']['DeleteSelection'], self)
+        self.action_delete_selection.setShortcut("DELETE")
+        self.action_delete_selection.triggered.connect(self.__handle_delete_selection)
+        self.context_menu.addAction(self.action_delete_selection)
+
+    def get_ab_sections(self):
+        """获取AB分区标记"""
+        return self.ab_sections
+
+    def set_ab_sections(self, sections):
+        """设置AB分区标记"""
+        self.ab_sections = sections
+        self.update_preview_with_rect()
+
+    def clear_ab_sections(self):
+        """清除所有AB分区标记"""
+        self.ab_sections = []
+        self.current_ab_start = -1
+        self.update_preview_with_rect()
+
+    def closeEvent(self, event):
+        """窗口关闭时断开信号连接"""
+        try:
+            # 断开信号连接
+            self.shortcut_delete_selection.activated.disconnect(self.__handle_delete_selection)
+            self.action_delete_selection.triggered.disconnect(self.__handle_delete_selection)
+        except Exception as e:
+            print(f"Error during close window:", e)
+        super().closeEvent(event)
\ No newline at end of file
diff --git a/ui/home_interface.py b/ui/home_interface.py
new file mode 100644
index 0000000..216922f
--- /dev/null
+++ b/ui/home_interface.py
@@ -0,0 +1,627 @@
+import os
+import cv2
+import threading
+import multiprocessing
+import time
+import traceback
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout
+from PySide6.QtCore import Slot, QRect, Signal
+from PySide6.QtGui import QTextCharFormat, QColor
+from PySide6 import QtWidgets
+from qfluentwidgets import (PushButton, CardWidget, PlainTextEdit, FluentIcon)
+from ui.setting_interface import SettingInterface
+from ui.component.video_display_component import VideoDisplayComponent
+from ui.component.task_list_component import TaskListComponent, TaskStatus, TaskOptions
+from ui.icon.my_fluent_icon import MyFluentIcon
+from backend.config import config, tr
+from backend.tools.subtitle_extractor_remote_call import SubtitleExtractorRemoteCall
+from backend.tools.process_manager import ProcessManager
+
+class HomeInterface(QWidget):
+    progress_signal = Signal(int, int, int, bool, int) 
+    append_log_signal = Signal(list)
+    task_error_signal = Signal(object)
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.setObjectName("HomeInterface")
+        # 初始化一些变量
+        self.video_path = None
+        self.video_cap = None
+        self.fps = None
+        self.frame_count = None
+        self.frame_width = None
+        self.frame_height = None
+        self.se = None  # 后台字幕提取器
+
+        # 添加自动滚动控制标志
+        self.auto_scroll = True
+        self.running_task = False
+        self.running_process = None
+        self.running_sub_process_pids = []
+        
+        # 当前正在处理的任务索引
+        self.current_processing_task_index = -1
+
+        self.__init_widgets()
+        self.progress_signal.connect(self.update_progress)
+        self.append_log_signal.connect(self.append_log)
+        self.task_error_signal.connect(self.on_task_error)
+        print(tr['Main']['AcceleratorWarning'])
+
+    def __init_widgets(self):
+        """创建主页面"""
+        main_layout = QHBoxLayout(self)
+        main_layout.setSpacing(8)
+        main_layout.setContentsMargins(16, 16, 16, 16)
+
+        # 左侧视频区域
+        left_layout = QVBoxLayout()
+        left_layout.setSpacing(8)
+        
+        # 创建视频显示组件
+        self.video_display_component = VideoDisplayComponent(self)
+        self.video_display_component.ab_sections_changed.connect(self.ab_sections_changed)
+        self.video_display_component.selections_changed.connect(self.selections_changed)
+        left_layout.addWidget(self.video_display_component)
+        
+        # 获取视频显示和滑块的引用
+        self.video_display = self.video_display_component.video_display
+        self.video_slider = self.video_display_component.video_slider
+        self.video_slider.valueChanged.connect(self.slider_changed)
+        
+        # 输出文本区域
+        self.output_text = PlainTextEdit()
+        self.output_text.setMinimumHeight(150)
+        self.output_text.setReadOnly(True)
+        self.output_text.document().setDocumentMargin(10)
+        # 连接滚动条值变化信号
+        self.output_text.verticalScrollBar().valueChanged.connect(self.on_scroll_change)
+        
+        output_container = CardWidget(self)
+        output_layout = QVBoxLayout()
+        output_layout.setContentsMargins(0, 0, 0, 0)
+        output_layout.addWidget(self.output_text)
+        output_container.setLayout(output_layout)
+        left_layout.addWidget(output_container)
+
+        main_layout.addLayout(left_layout, 2)
+
+        # 右侧设置区域
+        right_layout = QVBoxLayout()
+        right_layout.setSpacing(10)
+
+        # 设置容器
+        settings_container = CardWidget(self)
+        settings_container.setLayout(SettingInterface(settings_container))
+        right_layout.addWidget(settings_container)
+        
+        # 添加任务列表容器
+        task_list_container = CardWidget(self)
+        task_list_layout = QHBoxLayout()
+        task_list_layout.setContentsMargins(0, 0, 0, 0)
+        task_list_layout.setSpacing(0)
+        self.task_list_component = TaskListComponent(self)
+        self.task_list_component.task_selected.connect(self.on_task_selected)
+        self.task_list_component.task_deleted.connect(self.on_task_deleted)
+        task_list_layout.addWidget(self.task_list_component)
+        task_list_container.setLayout(task_list_layout)
+        right_layout.addWidget(task_list_container, 1)  # 占满剩余空间
+        
+        # 操作按钮容器
+        button_container = CardWidget(self)
+        button_layout = QHBoxLayout()
+        button_layout.setContentsMargins(16, 16, 16, 16)
+        button_layout.setSpacing(8)
+        
+        self.file_button = PushButton(tr['SubtitleExtractorGUI']['Open'], self)
+        self.file_button.setIcon(FluentIcon.FOLDER)
+        self.file_button.clicked.connect(self.open_file)
+        button_layout.addWidget(self.file_button)
+        
+        self.run_button = PushButton(tr['SubtitleExtractorGUI']['Run'], self)
+        self.run_button.setIcon(FluentIcon.PLAY)
+        self.run_button.clicked.connect(self.run_button_clicked)
+        button_layout.addWidget(self.run_button)
+        
+        self.stop_button = PushButton(tr['SubtitleExtractorGUI']['Stop'], self)
+        self.stop_button.setIcon(MyFluentIcon.Stop)
+        self.stop_button.setVisible(False)
+        self.stop_button.clicked.connect(self.stop_button_clicked)
+        
+        button_layout.addWidget(self.stop_button)
+        
+        button_container.setLayout(button_layout)
+        right_layout.addWidget(button_container)
+
+        main_layout.addLayout(right_layout, 1)
+    
+    def on_scroll_change(self, value):
+        """监控滚动条位置变化"""
+        scrollbar = self.output_text.verticalScrollBar()
+        # 如果滚动到底部，启用自动滚动
+        if value == scrollbar.maximum():
+            self.auto_scroll = True
+        # 如果用户向上滚动，禁用自动滚动
+        elif self.auto_scroll and value < scrollbar.maximum():
+            self.auto_scroll = False
+
+    
+    def slider_changed(self, value):
+        if self.video_cap is not None and self.video_cap.isOpened():
+            frame_no = self.video_slider.value()
+            self.video_cap.set(cv2.CAP_PROP_POS_FRAMES, frame_no)
+            ret, frame = self.video_cap.read()
+            if ret:
+                # 更新预览图像
+                self.update_preview(frame)
+
+    def ab_sections_changed(self, ab_sections):
+        get_current_task_index = self.task_list_component.get_current_task_index()
+        if get_current_task_index == -1:
+            return
+        self.task_list_component.update_task_option(get_current_task_index, TaskOptions.AB_SECTIONS, ab_sections)
+
+    def selections_changed(self, selections):
+        get_current_task_index = self.task_list_component.get_current_task_index()
+        if get_current_task_index == -1:
+            return
+        self.task_list_component.update_task_option(get_current_task_index, TaskOptions.SUB_AREAS, selections)
+
+    def on_task_selected(self, index, file_path):
+        """处理任务被选中事件
+        
+        Args:
+            index: 任务索引
+            file_path: 文件路径
+        """
+        # 加载选中的视频进行预览
+        self.load_video(file_path)
+        ab_sections = self.task_list_component.get_task_option(index, TaskOptions.AB_SECTIONS, [])
+        self.video_display_component.set_ab_sections(ab_sections)
+        self.apply_task_selection(index)
+
+    def apply_task_selection(self, index):
+        """
+        从任务列表中获取选区信息
+        如果选区信息不存在, 则从已设置的选区中加载
+        如果仍然不存在已设置选区则从配置文件中加载
+        """
+        selections = self.task_list_component.get_task_option(index, TaskOptions.SUB_AREAS, [])
+        # 优先从已设置选区中加载
+        if len(selections) <= 0:
+            tasks = self.task_list_component.get_all_tasks()
+            for i, _ in enumerate(tasks):
+                selections = self.task_list_component.get_task_option(i, TaskOptions.SUB_AREAS, []).copy()
+                if len(selections) > 0:
+                    self.append_output('update subarea', selections)
+                    self.task_list_component.update_task_option(index, TaskOptions.SUB_AREAS, selections)
+                    break
+        
+        if len(selections) <= 0:
+            selections = self.video_display_component.load_selections_from_config()
+
+        self.video_display_component.set_selection_rects(selections)
+        self.task_list_component.update_task_option(index, TaskOptions.SUB_AREAS, selections)
+        return selections
+
+    
+    def on_task_deleted(self, index):
+        """处理任务被删除事件
+        
+        Args:
+            index: 任务索引
+        """
+        # 如果删除的是正在处理的任务，则需要更新状态
+        if index == self.current_processing_task_index:
+            self.current_processing_task_index = -1
+        
+        task = self.task_list_component.get_task(0)
+        if task:
+            # 如果还有任务，选中第一个
+            self.task_list_component.select_task(0)
+
+    def update_preview(self, frame):
+        # 先缩放图像
+        resized_frame = self._img_resize(frame)
+
+        # 设置视频参数
+        self.video_display_component.set_video_parameters(
+            self.frame_width, self.frame_height, 
+            self.scaled_width if hasattr(self, 'scaled_width') else None,
+            self.scaled_height if hasattr(self, 'scaled_height') else None,
+            self.border_left if hasattr(self, 'border_left') else 0,
+            self.border_top if hasattr(self, 'border_top') else 0,
+            self.fps if self.fps is not None else 30,
+        )
+        
+        # 更新视频显示（这会同时保存current_pixmap）
+        self.video_display_component.update_video_display(resized_frame)
+
+    def _img_resize(self, image):
+        height, width = image.shape[:2]
+        
+        video_preview_width = self.video_display_component.video_preview_width
+        video_preview_height = self.video_display_component.video_preview_height
+        # 计算等比缩放后的尺寸
+        target_ratio = video_preview_width / video_preview_height
+        image_ratio = width / height
+        
+        if image_ratio > target_ratio:
+            # 宽度适配，高度按比例缩放
+            new_width = video_preview_width
+            new_height = int(new_width / image_ratio)
+            top_border = (video_preview_height - new_height) // 2
+            bottom_border = video_preview_height - new_height - top_border
+            left_border = 0
+            right_border = 0
+        else:
+            # 高度适配，宽度按比例缩放
+            new_height = video_preview_height
+            new_width = int(new_height * image_ratio)
+            left_border = (video_preview_width - new_width) // 2
+            right_border = video_preview_width - new_width - left_border
+            top_border = 0
+            bottom_border = 0
+        
+        # 先缩放图像
+        resized = cv2.resize(image, (new_width, new_height))
+        
+        # 添加黑边以填充到目标尺寸
+        padded = cv2.copyMakeBorder(
+            resized, 
+            top_border, bottom_border, 
+            left_border, right_border, 
+            cv2.BORDER_CONSTANT, 
+            value=[0, 0, 0]
+        )
+        
+        # 保存边框信息，用于坐标转换
+        self.border_left = left_border / video_preview_width
+        self.border_right = right_border / video_preview_width
+        self.border_top = top_border / video_preview_height
+        self.border_bottom = bottom_border / video_preview_height
+        self.original_width = width
+        self.original_height = height
+        self.is_vertical = width < height
+        self.scaled_width = new_width / video_preview_width
+        self.scaled_height = new_height / video_preview_height
+        
+        return padded
+
+    def stop_button_clicked(self):
+        try:
+            self.running_task = False
+            for pid in self.running_sub_process_pids:
+                ProcessManager.instance().terminate_by_pid(pid)
+            running_process = self.running_process
+            if running_process:
+                ProcessManager.instance().terminate_by_process(running_process)
+            # 更新任务状态为待处理
+            if self.current_processing_task_index >= 0:
+                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.PENDING)
+        finally:    
+            self.running_sub_process_pids = []
+            self.running_process = None
+            self.run_button.setVisible(True)
+            self.stop_button.setVisible(False)
+
+    def run_button_clicked(self):
+        if not self.task_list_component.get_pending_tasks():
+            self.append_output(tr['SubtitleExtractorGUI']['OpenVideoFirst'])
+            return
+            
+        try:
+            # 获取所有待执行的任务
+            pending_tasks = self.task_list_component.get_pending_tasks()
+            if not pending_tasks:
+                return
+            
+            self.run_button.setVisible(False)
+            self.stop_button.setVisible(True)
+            # 开启后台线程处理视频
+            def task():
+                self.running_task = True
+                try:
+                    while self.running_task:
+                        try:
+                            pending_tasks = self.task_list_component.get_pending_tasks()
+                            if not pending_tasks:
+                                print("No pending tasks. Exiting.")
+                                break
+                            pending_task = pending_tasks[0]
+                            # 更新当前处理的任务索引
+                            self.current_processing_task_index, task = pending_task
+                            if not self.load_video(task.path):
+                                self.append_output(tr['SubtitleExtractorGUI']['OpenVideoFailed'].format(task.path))
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                                continue
+                            
+                            # 获取字幕区域坐标
+                            subtitle_areas = self.apply_task_selection(self.current_processing_task_index)
+                            if not subtitle_areas or len(subtitle_areas) <= 0:
+                                self.append_output(tr['SubtitleExtractorGUI']['SelectSubtitleArea'].format(task.path))
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                                continue
+
+                            self.video_display_component.save_selections_to_config()
+
+                            # 更新任务状态为运行中
+                            self.task_list_component.update_task_progress(self.current_processing_task_index, 0)
+                            
+                            # 选中当前任务
+                            self.task_list_component.select_task(self.current_processing_task_index)
+                            
+                            self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.PROCESSING)
+                            options = {}
+                            for key in task.options:
+                                value = task.options[key]
+                                if key == TaskOptions.SUB_AREAS.value:
+                                    value = self.video_display_component.preview_coordinates_to_video_coordinates(value)
+                                    value = value[0] if len(value) > 0 else None
+                                options[key] = value
+                            # 清理缓存, 使用动态路径
+                            task.output_path = None
+                            output_path = task.output_path
+                            process = self.run_subtitle_extractor_process(task.path, output_path, options)
+                            
+                            # 更新任务状态为已完成
+                            task = self.task_list_component.get_task(self.current_processing_task_index)
+                            if process.exitcode == 0 and task and task.status == TaskStatus.PROCESSING:
+                                self.progress_signal.emit(100, 100, 100, True, 100)
+                                # 任务完成, 更新输出路径为只读
+                                task.output_path = output_path
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.COMPLETED)
+                            else:
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                            
+                        except Exception as e:
+                            print(e)
+                            self.append_output(f"Error: {e}")
+                            # 更新任务状态为失败
+                            if self.current_processing_task_index >= 0:
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                            break
+                        finally:
+                            if self.video_cap:
+                                self.video_cap.release()
+                                self.video_cap = None
+                            time.sleep(1)
+                finally:
+                    self.running_task = False
+                    self.run_button.setVisible(True)
+                    self.stop_button.setVisible(False)
+
+            threading.Thread(target=task, daemon=True).start()
+        except Exception as e:
+            print(traceback.format_exc())
+            self.append_output(f"Error: {e}")
+            # 没有待执行的任务，恢复按钮状态
+            self.run_button.setVisible(True)
+            self.stop_button.setVisible(False)
+
+    @staticmethod
+    def extractor_process(queue, video_path, output_path, options):
+        """
+        在子进程中执行字幕提取的函数
+        
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出文件路径
+            options: 选项
+        """
+        sr = None
+        try:
+            from backend.main import SubtitleExtractor
+            sr = SubtitleExtractor(video_path)
+            sr.subtitle_output_path = output_path
+            for key in options:
+                setattr(sr, key, options[key])
+            sr.add_progress_listener(lambda progress_ocr, progress_frame_extract, progress_total, isFinished, progress_post=0: SubtitleExtractorRemoteCall.remote_call_update_progress(queue, progress_ocr, progress_frame_extract, progress_total, isFinished, progress_post))
+            sr.append_output = lambda *args: SubtitleExtractorRemoteCall.remote_call_append_log(queue, args)
+            sr.manage_process = lambda pid: SubtitleExtractorRemoteCall.remote_call_manage_process(queue, pid)
+            sr.run()
+        except Exception as e:
+            traceback.print_exc()
+            SubtitleExtractorRemoteCall.remote_call_catch_error(queue, e)
+        finally:
+            if sr:
+                sr.isFinished = True
+                sr.vsf_running = False
+            SubtitleExtractorRemoteCall.remote_call_finish(queue)
+            ProcessManager.instance().terminate_all()
+            
+
+    # 修改run_subtitle_extractor_process方法
+    def run_subtitle_extractor_process(self, video_path, output_path, options):
+        """
+        使用多进程执行字幕提取，并等待进程完成
+        
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出文件路径
+            options: 任务选项
+        """
+
+        subtitle_extractor_remote_caller = SubtitleExtractorRemoteCall()
+        subtitle_extractor_remote_caller.register_update_progress_callback(self.progress_signal.emit)
+        subtitle_extractor_remote_caller.register_log_callback(self.append_log_signal.emit)
+        subtitle_extractor_remote_caller.register_manage_process_callback(lambda pid: (
+                ProcessManager.instance().add_pid(pid),
+                self.running_sub_process_pids.append(pid),
+            )
+        )
+        subtitle_extractor_remote_caller.register_error_callback(self.task_error_signal.emit)
+        process = multiprocessing.Process(
+            target=HomeInterface.extractor_process,
+            args=(subtitle_extractor_remote_caller.queue, video_path, output_path, options)
+        )
+        try:
+            if not self.running_task:
+                return process
+            process.start()
+            ProcessManager.instance().add_process(process)
+            self.running_process = process
+            process.join()
+            print(f"Process exited with code {process.exitcode}")
+        finally:
+            subtitle_extractor_remote_caller.stop()
+        return process
+
+    @Slot()
+    def processing_finished(self):
+        pending_tasks = self.task_list_component.get_pending_tasks()
+        if pending_tasks:
+            # 还有待执行任务, 忽略
+            return
+        # 处理完成后恢复界面可用性
+        self.run_button.setVisible(True)
+        self.stop_button.setVisible(False)
+        self.se = None
+        # 重置视频滑块
+        self.video_slider.setValue(1)
+        # 重置当前处理任务索引
+        self.current_processing_task_index = -1
+
+    @Slot(int, bool)
+    def update_progress(self, progress_remover, progress_finder, progress_total, isFinished, progress_post=0):
+        try:
+            pos = min(self.frame_count - 1, int(progress_remover / 100 * self.frame_count))
+            if pos != self.video_slider.value():
+                self.video_slider.setValue(pos)
+
+            # 更新任务进度（加权：帧提取5% + OCR 90% + 后处理5%）
+            if self.current_processing_task_index >= 0:
+                displayed = min(100, int(progress_remover * 0.9 + progress_finder * 0.05 + progress_post * 0.05))
+                # 确保进度不会回退
+                if not hasattr(self, '_last_task_progress'):
+                    self._last_task_progress = {}
+                task_idx = self.current_processing_task_index
+                last_progress = self._last_task_progress.get(task_idx, -1)
+                if displayed >= last_progress or isFinished:
+                    self._last_task_progress[task_idx] = displayed
+                    self.task_list_component.update_task_progress(
+                        task_idx,
+                        displayed,
+                    )
+            
+            # 检查是否完成
+            if isFinished:
+                self.processing_finished()
+        except Exception as e:
+            # 捕获任何异常，防止崩溃
+            print(f"更新进度时出错: {str(e)}")
+
+    @Slot(list)
+    def append_log(self, log):
+        self.append_output(*log)
+
+    def append_output(self, *args):
+        """添加文本到输出区域并控制滚动
+        Args:
+            *args: 要输出的内容，多个参数将用空格连接
+        """
+        text = ' '.join(str(arg) for arg in args).rstrip()
+
+        # 根据消息类型选择颜色
+        fmt = QTextCharFormat()
+        if '【完成】' in text or '【结束】' in text:
+            fmt.setForeground(QColor('#10b981'))
+        elif '【处理中】' in text:
+            fmt.setForeground(QColor('#3b82f6'))
+        elif '【警告】' in text or '【重要提示】' in text:
+            fmt.setForeground(QColor('#f59e0b'))
+        elif text.startswith('---'):
+            fmt.setForeground(QColor('#d1d5db'))
+        elif '成功打开视频' in text:
+            fmt.setForeground(QColor('#10b981'))
+        elif '无法打开视频' in text or '请先打开视频' in text or '错误' in text or 'Error' in text:
+            fmt.setForeground(QColor('#ef4444'))
+        elif text.startswith('  '):
+            fmt.setForeground(QColor('#6b7280'))
+
+        cursor = self.output_text.textCursor()
+        cursor.movePosition(cursor.MoveOperation.End)
+        cursor.insertText(text + '\n', fmt)
+        print(*args)  # 保持原始的 print 行为
+        # 如果启用了自动滚动，则滚动到底部
+        if self.auto_scroll:
+            scrollbar = self.output_text.verticalScrollBar()
+            scrollbar.setValue(scrollbar.maximum())
+
+    @Slot(object)
+    def on_task_error(self, e):
+        self.append_output(tr['SubtitleExtractorGUI']['ErrorDuringProcessing'].format(str(e)))
+        if self.current_processing_task_index >= 0:
+            self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+
+    def load_video(self, video_path):
+        self.video_path = video_path
+        if self.video_cap:
+            self.video_cap.release()
+            self.video_cap = None
+        self.video_cap = cv2.VideoCapture(self.video_path)
+        if not self.video_cap.isOpened():
+            return False
+        ret, frame = self.video_cap.read()
+        if not ret:
+            return False
+        self.frame_count = int(self.video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        self.frame_height = int(self.video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.frame_width = int(self.video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        self.fps = self.video_cap.get(cv2.CAP_PROP_FPS)
+        
+        self.update_preview(frame)
+        self.video_slider.setMaximum(self.frame_count)
+        self.video_slider.setValue(1)
+        self.video_display_component.set_dragger_enabled(True)
+        return True
+        self.video_slider.setMaximum(self.frame_count)
+        self.video_slider.setValue(1)
+        self.video_display_component.set_dragger_enabled(True)
+        return True
+
+
+    def open_file(self):
+        files, _ = QtWidgets.QFileDialog.getOpenFileNames(
+            self,
+            tr['SubtitleExtractorGUI']['Open'],
+            "",
+            "All Files (*.*);;MP4 Files (*.mp4);;FLV Files (*.flv);;WMV Files (*.wmv);;AVI Files (*.avi)"
+        )
+        if files:
+            files_loaded = []
+            # 倒序打开, 确保第一个视频截图显示在屏幕上
+            for path in reversed(files):
+                if self.load_video(path):
+                    self.append_output(f"{tr['SubtitleExtractorGUI']['OpenVideoSuccess']}: {path}")
+                    files_loaded.append(path)
+                else:
+                    self.append_output(f"{tr['SubtitleExtractorGUI']['OpenVideoFailed']}: {path}")
+            # 正序添加, 确保任务列表顺序一致
+            for path in reversed(files_loaded):
+                # 添加到任务列表
+                self.task_list_component.add_task(path)
+            index = max(0, self.task_list_component.find_task_index_by_path(path))
+            self.task_list_component.select_task(index)
+
+    def closeEvent(self, event):
+        """窗口关闭时断开信号连接"""
+        try:
+            # 断开信号连接
+            self.progress_signal.disconnect(self.update_progress)
+            self.append_log_signal.disconnect(self.append_log)
+            self.task_error_signal.disconnect(self.on_task_error)
+            self.video_display_component.video_slider.valueChanged.disconnect(self.slider_changed)
+            self.video_display_component.ab_sections_changed.disconnect(self.ab_sections_changed)
+            self.video_display_component.selections_changed.disconnect(self.selections_changed)
+            # 释放视频资源
+            if self.video_cap:
+                self.video_cap.release()
+                self.video_cap = None
+                
+            # 确保所有子进程都已终止
+            ProcessManager.instance().terminate_all()
+        except Exception as e:
+            print(f"Error during close window:", e)
+        super().closeEvent(event)
+    
\ No newline at end of file
diff --git a/ui/setting_interface.py b/ui/setting_interface.py
new file mode 100644
index 0000000..a46462a
--- /dev/null
+++ b/ui/setting_interface.py
@@ -0,0 +1,90 @@
+from PySide6 import QtWidgets
+from qfluentwidgets import (FluentWindow, PushButton, Slider, ProgressBar, PlainTextEdit,
+                          setTheme, Theme, FluentIcon, CardWidget, SettingCardGroup,
+                          ComboBoxSettingCard, SwitchSettingCard, RangeSettingCard,
+                          PushSettingCard, PrimaryPushSettingCard, OptionsSettingCard,
+                          FolderListSettingCard, HyperlinkCard, ColorSettingCard, 
+                          CustomColorSettingCard)
+from backend.config import config, tr, HARDWARD_ACCELERATION_OPTION
+
+class SettingInterface(QtWidgets.QVBoxLayout):
+
+    def __init__(self, parent):
+        super().__init__()
+        self.setContentsMargins(16, 16, 16, 16)
+        
+        # 界面语言设置
+        self.interface_combo = ComboBoxSettingCard(
+            configItem=config.interface,
+            icon=FluentIcon.LANGUAGE,
+            title=tr["LanguageModeGUI"]["InterfaceLanguage"],
+            content="",
+            parent=parent,
+            texts=config.intefaceTexts.keys(),
+        )
+        self.addWidget(self.interface_combo)
+        
+        # 字幕语言设置
+        self.language_combo = ComboBoxSettingCard(
+            configItem=config.language,
+            icon=FluentIcon.FONT,
+            title=tr["LanguageModeGUI"]["SubtitleLanguage"],
+            content="",
+            parent=parent,
+            texts=[tr['Language'][i] for i in config.language.validator.options],
+        )
+        self.addWidget(self.language_combo)
+
+        # 识别模式设置
+        self.mode_combo = ComboBoxSettingCard(
+            configItem=config.mode,
+            icon=FluentIcon.SETTING,
+            title=tr["LanguageModeGUI"]["Mode"],
+            content="",
+            parent=parent,
+            texts=[tr['Mode'][i] for i in config.mode.validator.options],
+        )
+        self.addWidget(self.mode_combo)
+           
+        # 是否启用硬件加速
+        self.hardware_acceleration = SwitchSettingCard(
+            configItem=config.hardwareAcceleration,
+            icon=FluentIcon.SPEED_HIGH, 
+            title=tr["Setting"]["HardwareAcceleration"],
+            content=tr["Setting"]["HardwareAccelerationDesc"],
+            parent=parent
+        )
+        self.addWidget(self.hardware_acceleration)
+        # 如果硬件加速选项被禁用, 设置硬件加速为False并只读
+        if not HARDWARD_ACCELERATION_OPTION:
+            self.hardware_acceleration.switchButton.setChecked(False)
+            self.hardware_acceleration.switchButton.setEnabled(False)
+            config.set(config.hardwareAcceleration, False)
+        
+        # 是否生成TXT文本字幕
+        self.generate_txt_switch = SwitchSettingCard(
+            configItem=config.generateTxt,
+            icon=FluentIcon.DOCUMENT,
+            title=tr["Setting"]["GenerateTxt"],
+            content="",
+            parent=parent
+        )
+        self.addWidget(self.generate_txt_switch)
+        
+        # 是否重新分词
+        self.word_segmentation = SwitchSettingCard(
+            configItem=config.wordSegmentation,
+            icon=FluentIcon.EDIT, 
+            title=tr["Setting"]["WordSegmentation"],
+            content=tr["Setting"]["WordSegmentationDesc"],
+            parent=parent
+        )
+        self.addWidget(self.word_segmentation)
+        
+        # 添加一些空间
+        self.addStretch(1)
+    
+    def reset_setting(self):
+        """重置所有设置为默认值"""
+        # 这里需要实现重置逻辑
+        pass
\ No newline at end of file
diff --git a/ui/timeline_sync_interface.py b/ui/timeline_sync_interface.py
new file mode 100644
index 0000000..866f4c4
--- /dev/null
+++ b/ui/timeline_sync_interface.py
@@ -0,0 +1,196 @@
+
+import os
+from pathlib import Path
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QWidget, QFileDialog, QHBoxLayout, QVBoxLayout, QSizePolicy
+from qfluentwidgets import (PushButton, ConfigValidator, ConfigItem, PlainTextEdit,
+                          FluentIcon, CardWidget, SettingCardGroup, PushSettingCard, InfoBar)
+from backend.config import tr
+from backend.tools.python_runner import AsyncPythonRunner
+from ui.icon.my_fluent_icon import MyFluentIcon
+
+class Option:
+    def __init__(self):
+        self.source_video = ConfigItem("TimelineSync", "SushiSourceVideo", "", ConfigValidator())
+        self.source_subtitle = ConfigItem("TimelineSync", "SushiSourceSubtitle", "", ConfigValidator())
+        self.destination_video = ConfigItem("TimelineSync", "SushiDestinationVideo", "", ConfigValidator())
+
+class TimelineSyncInterface(QWidget):
+
+    append_log_signal = Signal(str)
+    def __init__(self, parent):
+        super().__init__()
+        
+        self.auto_scroll = True
+        self.python_runner = AsyncPythonRunner()
+        self.python_runner.register_callback(
+            stdout = self.append_log_signal.emit,
+            stderr = self.append_log_signal.emit,
+            complete = self.on_complete
+        )
+        self.option = Option()
+
+        self.setContentsMargins(16, 16, 16, 16)
+
+        self.expandLayout = QVBoxLayout(self)
+
+        self.advanced_group = SettingCardGroup(tr["TimelineSync"]["Title"], self)
+        self.advanced_group.cardLayout.setSpacing(6)
+        
+        self.source_video = PushSettingCard(
+            text=tr["TimelineSync"]["ChooseFile"],
+            icon=FluentIcon.VIDEO,
+            title=tr["TimelineSync"]["SourceVideoTitle"],
+            content=tr["TimelineSync"]["SourceVideoDesc"] if not self.option.source_video.value else self.option.source_video.value,
+            parent=self.advanced_group
+        )
+        self.source_video.clicked.connect(lambda: self.choose_path(self.source_video, tr["TimelineSync"]["SourceVideoTitle"], self.option.source_video, tr["TimelineSync"]["SourceVideoDesc"]))
+        self.advanced_group.addSettingCard(self.source_video)
+
+        self.source_subtitle = PushSettingCard(
+            text=tr["TimelineSync"]["ChooseFile"],
+            icon=FluentIcon.FONT,
+            title=tr["TimelineSync"]["SourceSubtitleTitle"],
+            content=tr["TimelineSync"]["SourceSubtitleDesc"] if not self.option.source_subtitle.value else self.option.source_subtitle.value,
+            parent=self.advanced_group
+        )
+        self.source_subtitle.clicked.connect(lambda: self.choose_path(self.source_subtitle, tr["TimelineSync"]["SourceSubtitleTitle"], self.option.source_subtitle, tr["TimelineSync"]["SourceSubtitleDesc"], "Subtitle File(*.srt, *.ass);;SRT File (*.srt);;ASS File (*.ass)"))
+        self.advanced_group.addSettingCard(self.source_subtitle)
+        
+        self.destination_video = PushSettingCard(
+            text=tr["TimelineSync"]["ChooseFile"],
+            icon=FluentIcon.MOVIE,
+            title=tr["TimelineSync"]["DestinationVideoTitle"],
+            content=tr["TimelineSync"]["DestinationVideoDesc"] if not self.option.destination_video.value else self.option.destination_video.value,
+            parent=self.advanced_group
+        )
+        self.destination_video.clicked.connect(lambda: self.choose_path(self.destination_video, tr["TimelineSync"]["DestinationVideoTitle"], self.option.destination_video, tr["TimelineSync"]["DestinationVideoDesc"]))
+        self.advanced_group.addSettingCard(self.destination_video)
+
+        self.expandLayout.addWidget(self.advanced_group)
+
+        # 操作按钮容器
+        button_container = CardWidget()
+        button_container.setMinimumHeight(60)
+        button_container.setStyleSheet("""
+            background-color: #fcfdfe;
+            border: 1px solid #eeeff0;
+            border-radius: 6px;
+        """)
+        button_layout = QHBoxLayout()
+        button_layout.setContentsMargins(16, 16, 16, 16)
+        button_layout.setSpacing(8)
+        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft) 
+        
+        self.run_button = PushButton(tr['SubtitleExtractorGUI']['Run'], self)
+        self.run_button.setIcon(FluentIcon.PLAY)
+        self.run_button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        self.run_button.clicked.connect(self.run_button_clicked)
+        button_layout.addWidget(self.run_button)
+        
+        self.stop_button = PushButton(tr['SubtitleExtractorGUI']['Stop'], self)
+        self.stop_button.setIcon(MyFluentIcon.Stop)
+        self.stop_button.setVisible(False)
+        self.stop_button.clicked.connect(self.stop_button_clicked)
+        button_layout.addWidget(self.stop_button)
+
+        button_container.setLayout(button_layout)
+        self.expandLayout.addWidget(button_container, 0)
+
+         # 输出文本区域
+        self.output_text = PlainTextEdit()
+        self.output_text.setMinimumHeight(150)
+        self.output_text.setReadOnly(True)
+        self.output_text.document().setDocumentMargin(10)        
+        # 连接滚动条值变化信号
+        self.output_text.verticalScrollBar().valueChanged.connect(self.on_scroll_change)
+        output_container = CardWidget(self)
+        output_layout = QVBoxLayout()
+        output_layout.setContentsMargins(0, 0, 0, 0)
+        output_layout.addWidget(self.output_text, 1)
+        output_container.setLayout(output_layout)
+        self.expandLayout.addWidget(output_container, 1)
+
+        self.append_log_signal.connect(self.append_output)
+        
+    def choose_path(self, target, name, option, placeholder, filters=None):
+        """选择保存目录"""
+        last_source_video = "./" if not option.value else option.value
+        selected = QFileDialog.getOpenFileName(
+            self, name, last_source_video, filters)
+        if len(selected) >= 1 and selected[0] == "":
+            return
+        path, _ = selected 
+        option.value = path
+        target.setContent(placeholder if not option.value else option.value)
+
+    def on_scroll_change(self, value):
+        """监控滚动条位置变化"""
+        scrollbar = self.output_text.verticalScrollBar()
+        # 如果滚动到底部，启用自动滚动
+        if value == scrollbar.maximum():
+            self.auto_scroll = True
+        # 如果用户向上滚动，禁用自动滚动
+        elif self.auto_scroll and value < scrollbar.maximum():
+            self.auto_scroll = False
+       
+    def append_output(self, text):
+        """添加文本到输出区域并控制滚动
+        Args:
+            text: 要输出的内容
+        """
+        text = text.strip()
+        self.output_text.appendPlainText(text)
+        print(text)  # 保持原始的 print 行为
+        # 如果启用了自动滚动，则滚动到底部
+        if self.auto_scroll:
+            scrollbar = self.output_text.verticalScrollBar()
+            scrollbar.setValue(scrollbar.maximum())
+
+    def stop_button_clicked(self):
+        self.python_runner.stop()
+        self.stop_button.setVisible(False)
+        self.run_button.setVisible(True)
+
+    def run_button_clicked(self):
+        """运行按钮点击事件"""
+        self.python_runner.stop()
+
+        if not self.is_selected_file_exists(tr["TimelineSync"]["SourceVideoTitle"], self.option.source_video.value):
+            return
+        if not self.is_selected_file_exists(tr["TimelineSync"]["SourceSubtitleTitle"], self.option.source_subtitle.value):
+            return
+        if not self.is_selected_file_exists(tr["TimelineSync"]["DestinationVideoTitle"], self.option.destination_video.value):
+            return
+
+        self.python_runner.start("sushi", cwd="./backend/", args=[
+            '--src', self.option.source_video.value,
+            '--dst', self.option.destination_video.value,
+            '--script', self.option.source_subtitle.value,
+            '--output', self.output_path
+        ], python_args=["-u"])
+        self.stop_button.setVisible(True)
+        self.run_button.setVisible(False)
+
+    def is_selected_file_exists(self, name, path):
+        if not os.path.exists(path):
+            InfoBar.error(
+                title=tr['TimelineSync']['Error'],
+                content=tr['TimelineSync']['UnableToLocateFile'].format(name, path),
+                parent=self,
+                duration=3000
+            )
+            return False
+        return True
+
+    @property
+    def output_path(self):
+        return os.path.join(os.path.dirname(self.option.destination_video.value), f"{Path(self.option.destination_video.value).stem}{os.path.splitext(self.option.source_subtitle.value)[-1]}")
+
+    def on_complete(self, return_code):
+        self.stop_button.setVisible(False)
+        self.run_button.setVisible(True)
+        if return_code == 0:
+            self.append_log_signal.emit(f"Synced subtitle: {self.output_path}")
+            return