(2026.2.5更新)AMD RDNA ROCm vllm后端和pipeline后端完整适配分享

[healy-hub]

2026.2.12 folk了几个相关的仓库，准备抽空精简一下教程，直接clone我的仓库反而更方便。排查了一下flash_attn的triton实现，最新的提交实现了RDNA上的flash_attn v3，带了问题是仅推理会导致速度反而不如v2。另外每个实现都没有做形状的分类归一，导致在mineru这种视觉处理上只要有一点点的长度不一样就会导致triton重新启用新的kernel。这些问题均解决了，空了我更新一下教程。另外triton后端建议在安装结束后采用一个大的PDF文件生成缓存，这是triton的特性无解。这个缓存文件一次即可，重启等不会丢失。

2026.2.5 更新，设置了flash_attn仓库回退，最新的triton 后端合并在RDNA 3 7900xtx上的性能回退30%左右，回退到12月的版本即可，git checkout bba578d43974c1d3ba157ab597124dd0fe2ccdb4, 最新的合并实现了Fused Bwd，只能说暂时还不好用

2026.1.31更新，放弃所有的triton实现，难以在不同的GPU上都实现最好的性能，因此转向于利用AMD 优化好的无问题的后端提供适配。目前在7900xtx测试下来，300页的PDF，vllm后端的速度大概能跑到1.8～2.01it/s，pipeline ocr速度也能到几百it/s。有些国产GPU的pipeline后端也许可以参考这个实现，好像有看到过vllm后端没问题，但是pipeline后端几个模型反而没有实现的。

吐槽：ROCm 7.2 并没有解决RDNA上3D卷积，2D卷积的基数倍数，空洞卷积的问题。。。。绷不住了，真特么幽默的RDNA CK后端优化。开始觉得不用自己来AMD官方能解决，想多了。

---

在开头先解释一下原因，为什么在RDNA AMD GPU上推理速度如此之慢。第一个是vllm的conv3d，torch.Size([56700, 3, 2, 14, 14])这种batch_size 根本找不到MIOPEN的kernel实现，它回退到了fp64的双精度计算，并且搜索kernel花了12s，但是啥也没找到，vllm后端只有这一个问题。

接下来是pipeline后端，这个问题就多了，首先是第一步Layout Predict用的空洞卷积，自定义的doclayout_yolo/nn/modules/g2l_crm.py找不到kernel，回退+1。然后是ocr部分，这里有两个问题，一个是conv2d在MIOPEN上，遇到(1, 3, 544, 672)这种，后面两个都是32的奇数倍数时，每次都会冷启动，导致需要1s多搜索最佳kernel的时间，另一个问题是mineru每次ocr的batch是6个送过去的，到最后一次的时候，很可能不是6个，这个时候同时面对batch和形状的冷启动，会带来一个7s左右的延迟，对，你没听错，是7s。。。。。。

---

下面是做的一个适配修改，需要修改的部分比之前多一点，，其实可以写一个脚本自动实现，也不是非要自己手动修改，但是尽可能详细一点：

如果有疏漏，可以在下面评论，看到会解决的

1.环境介绍

System: Ubuntu 24.04.3 Kernel: Linux 6.14.0-37-generic ROCm version: 7.1.1 CPU 13900K 内存 64G 6800MHz ddr5
python环境：
python 3.13.8
pytorch-triton-rocm 3.6.0+git5261b273
torch 2.10.0.dev20251208+rocm7.1
torchvision 0.25.0.dev20251209+rocm7.1
vllm 0.15.2rc1.dev2+g72bb24e2d.rocm720
amd-aiter 0.1.11.dev27+g1f5a39227
flash_attn 2.8.3

不同版本无所谓，处理方法是一样的，这个版本的fp16和bf16矩阵乘能到104tflops的结果。新版AMD 官方的ROCm 7.2 torch 性能也不错更好，但是torch 2.10 官方只给了python 3.12的，没有python 3.13，参见https://repo.radeon.com/rocm/manylinux/rocm-rel-7.2/ 。Pytorch这边的preview版的暂时没有更新ROCm 7.2版的，得等等，参见https://pytorch.org/ 。

---

2.前置环境安装

已有完整python vllm和mineru环境直接跳转第3步！！！ 建议使用推荐版本的vllm和Torch
这里我用的uv python环境，conda等均可，但是切记使用pip 安装mineru而不要使用uv pip，uv pip会安装英伟达的torch后端等。。。。日志显示 Flash Attention (Triton backend) for ViT model on RDNA。

uv venv --python python3.13
source .venv/bin/activate
uv pip install --pre torch==2.10.0.dev20251208+rocm7.1 torchvision==0.25.0.dev20251209+rocm7.1 pytorch-triton-rocm==3.6.0+git5261b273 --index-url https://download.pytorch.org/whl/nightly/rocm7.1
# 最近的更新里就这附近的版本最猛
uv pip install pip
# 避免覆盖我们本地的pytorch，改用pip而没有继续使用uv pip
pip install -U "mineru[core]" -i https://pypi.mirrors.ustc.edu.cn/simple/

vllm 安装参考官方手册Vllm

#手动安装aiter，vllm，amd-smi等，自行找一个位置clone，然后进入该目录吧
git clone --recursive https://github.com/ROCm/aiter.git
cd aiter
git submodule sync; git submodule update --init --recursive
python setup.py develop
cd ..
git clone --recursive https://github.com/Dao-AILab/flash-attention.git
cd flash-attention
git checkout bba578d43974c1d3ba157ab597124dd0fe2ccdb4   #一月到二月commi均导致在RDNA 3上的性能回退，尤其是最新的2月rocm改进提交
export FLASH_ATTENTION_TRITON_AMD_ENABLE="TRUE"   
rm -rf ~/.triton/cache   #清理以前的triton缓存
#至关重要，官方FLASH_ATTENTION_TRITON_AMD_ENABLE="TRUE" python setup.py install不大好，而且运行的时候这个环境变量也需要，不如终端设置了。
python setup.py install
cd ..
git clone https://github.com/vllm-project/vllm.git
cd vllm/
cp -r /opt/rocm/share/amd_smi ~/Pytorch/vllm/
pip install amd_smi/
pip install --upgrade numba \
    scipy \
    huggingface-hub[cli,hf_transfer] \
    setuptools_scm
pip install -r requirements/rocm.txt    #如果和mineru的包冲突了，用mineru需要的的版本即可，vllm不挑的，没啥问题
export PYTORCH_ROCM_ARCH="gfx1100"   #根据自己的GPU架构 rocminfo | grep gfx
python setup.py develop

---

3.patch环节

mineru和doclayoutyolo 两个仓库的改动可以参考我做的 MinerU-AMD-RDNA 和 DocLayout-YOLO-AMD-RDNA 的commit。下面我还是给出完整的patch部分：

3.1 vllm patch部分

定位自己vllm位置XXX

pip show vllm

关键更改
XXX/vllm/model_executor/models/qwen2_vl.py文件：
35行下面增加一个import：

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

446行class Qwen2VisionPatchEmbed(nn.Module) 函数修改为下面的,直接用F.linear来实现conv3d，速度极快，拉满rocblas：

class Qwen2VisionPatchEmbed(nn.Module):
    def __init__(
        self,
        patch_size: int = 14,
        temporal_patch_size: int = 2,
        in_channels: int = 3,
        embed_dim: int = 1152,
    ) -> None:
        super().__init__()
        self.patch_size = patch_size
        self.temporal_patch_size = temporal_patch_size
        self.embed_dim = embed_dim

        kernel_size = (temporal_patch_size, patch_size, patch_size)

        # 保持 Conv3d 定义，确保加载 Checkpoint 时 key 匹配
        self.proj = nn.Conv3d(
            in_channels,
            embed_dim,
            kernel_size=kernel_size,
            stride=kernel_size,
            bias=False,
        )

        # Conv 权重默认是连续的
        self.flat_weight_shape = (embed_dim, -1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x shape: (L, Total_Input_Pixels), 例如: (56700, 3 * 2 * 14 * 14) = (56700, 1176)
        # 确保输入内存连续
        if not x.is_contiguous():
            x = x.contiguous()
        weight = self.proj.weight.view(self.flat_weight_shape)
        # 偏差处理 (Bias Handling)
        bias = self.proj.bias
        # Conv3d (stride=k) 等同于将每个 Patch 拉平后与权重矩阵做点积。
        out = F.linear(x, weight, bias)
        return out

3.2 pipline doclayout_yolo patch部分

可以去仓库直接复制该文件：DocLayout-YOLO-AMD-RDNA
定位自己doclayout_yolo位置XXX

pip show doclayout_yolo

修改XXX/doclayout_yolo/nn/modules/g2l_crm.py，比如我的在/home/XXX/Pytorch/MinerUvllm/.venv/lib/python3.13/site-packages/doclayout_yolo/nn/modules/g2l_crm.py：
代码不长直接替换好了：

import torch
from torch import nn, Tensor
import torch.nn.functional as F
from typing import List, Optional

from .conv import Conv
from .block import CIB

class DilatedBlock(nn.Module):
    """
    针对 AMD RDNA、优化的 DilatedBlock。
    针对非整除尺寸的 Padding 对齐逻辑，彻底解决 RuntimeError，蛋疼的RDNA。
    """
    def __init__(self, c, dilation: List[int], k: int, fuse="sum", shortcut=True):
        super().__init__()
        self.dilation = dilation
        self.k = k
        self.fuse = fuse
        self.add = shortcut

        self.cv2 = Conv(c, c, k=1, s=1)
        if fuse == "glu":
            self.conv_gating = Conv(c * len(dilation), c * len(dilation), k=1, s=1, g=c * len(dilation))
            self.conv1x1 = Conv(c * len(dilation), c, k=1, s=1, g=c)
        elif fuse == "sum":
            self.conv1x1 = Conv(c, c, k=1, s=1, g=c)

        # 这里的 dcv 包含 conv, bn, act。将在 _s2b_forward 中复用
        self.dcv = Conv(c, c, k=k, s=1)

    def _s2b_forward(self, x: Tensor, d: int) -> Tensor:
        """
        Space-to-Batch 卷积实现 (Robust Version)。
        自动处理非整除尺寸，避免 RuntimeError。
        """
        if d == 1:
            return self.dcv(x)

        n, c, h, w = x.shape
        conv_mod = self.dcv.conv
        
        # 计算 Padding，base_pad用于模拟相同卷积所需的 padding
        base_pad = d * (self.k // 2)
        
        h_padded_base = h + 2 * base_pad
        w_padded_base = w + 2 * base_pad
        
        pad_h_extra = (d - (h_padded_base % d)) % d
        pad_w_extra = (d - (w_padded_base % d)) % d
        
        # F.pad 参数顺序: (left, right, top, bottom)，额外的 padding 加在右侧和下侧，方便后续裁剪
        x_pad = F.pad(x, (base_pad, base_pad + pad_w_extra, base_pad, base_pad + pad_h_extra))
        
        # Space-to-Batch(S2B)切片
        slices = []
        for i in range(d):
            for j in range(d):
                slices.append(x_pad[:, :, i::d, j::d])
        
        # 堆叠 -> (N * d*d, C, H_sub, W_sub)，extra_pad，此处所有 slice 的 shape 严格一致
        x_batch = torch.cat(slices, dim=0)

        # 标准卷积 (Stride=1, Padding=0)
        # 手动处理过padding，用padding=0的valid conv
        out_batch = F.conv2d(x_batch, conv_mod.weight, conv_mod.bias, stride=1, padding=0)
        
        # 计算子块输出尺寸
        h_sub_out, w_sub_out = out_batch.shape[2], out_batch.shape[3]
        
        # 预分配输出张量 (尺寸可能略大于原图)
        out_temp = torch.empty((n, c, h_sub_out * d, w_sub_out * d), device=x.device, dtype=x.dtype)
        
        out_chunks = torch.tensor_split(out_batch, d*d, dim=0)
        
        idx = 0
        for i in range(d):
            for j in range(d):
                # 并行写入显存，还原空间位置
                out_temp[:, :, i::d, j::d] = out_chunks[idx]
                idx += 1

        # 输出 (N, C, H, W)，由于padding存在，out_temp会略大，问题不大
        if out_temp.shape[2] != h or out_temp.shape[3] != w:
            out = out_temp[:, :, :h, :w]
        else:
            out = out_temp

        return self.dcv.act(self.dcv.bn(out))

    def forward(self, x: Tensor) -> Tensor:
        # 确保内存连续，防止 AMD GPU 上的 stride 异常
        if not x.is_contiguous():
            x = x.contiguous()

        if self.fuse == "sum":
            dx_accum = None
            for d in self.dilation:
                # 使用 S2B 优化的卷积
                current = self.cv2(self._s2b_forward(x, d))
                if dx_accum is None:
                    dx_accum = current
                else:
                    dx_accum = dx_accum + current
            dx = self.conv1x1(dx_accum)
            
        elif self.fuse == "glu":
            dx_list = [self.cv2(self._s2b_forward(x, d)) for d in self.dilation]
            dx = torch.cat(dx_list, dim=1)
            g = torch.sigmoid(self.conv_gating(dx))
            dx = self.conv1x1(dx * g)

        return (x + dx if self.add else dx)

class DilatedBottleneck(nn.Module):
    # 标准空洞卷积瓶颈模块
    def __init__(self, c1, c2, shortcut=True, dilation=[1,2,3], block_k=3, fuse="sum", g=1, k=(3, 3), e=0.5):
        super().__init__()
        c_ = int(c2 * e)
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.dilated_block = DilatedBlock(c_, dilation, block_k, fuse)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        return x + self.cv2(self.dilated_block(self.cv1(x))) if self.add else self.cv2(self.dilated_block(self.cv1(x)))

class G2L_CRM(nn.Module):
    # 使用2个卷积层更快地实现CSP瓶颈问题。
    def __init__(self, c1, c2, n=1, shortcut=False, use_dilated=False, dilation=[1,2,3], block_k=3, fuse="sum", g=1, e=0.5):
        super().__init__()
        self.c = int(c2 * e)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)
        if use_dilated:
            self.m = nn.ModuleList(DilatedBottleneck(
                self.c, self.c, shortcut, dilation, block_k, fuse, g, k=((3, 3), (3, 3)), e=1.0
            ) for _ in range(n))
        else:
            self.m = nn.ModuleList(CIB(self.c, self.c, shortcut, e=1.0) for _ in range(n))

    def forward(self, x):
        y = list(self.cv1(x).chunk(2, 1))
        for m in self.m:
            y.append(m(y[-1]))
        return self.cv2(torch.cat(y, 1))

    def forward_split(self, x):
        y = list(self.cv1(x).split((self.c, self.c), 1))
        for m in self.m:
            y.append(m(y[-1]))
        return self.cv2(torch.cat(y, 1))

3.3 pipline mineru patch部分

可以去仓库直接复制对应文件，MinerU-AMD-RDNA ：
定位自己mineru位置XXX

pip show mineru

XXX/mineru/model/utils/tools/infer/predict_rec.py的136行下面增加将 imgW 对齐到 32：

        max_wh_ratio = max(max_wh_ratio, imgW / imgH)
        imgW = int(imgH * max_wh_ratio)
        imgW = max(min(imgW, self.limited_max_width), self.limited_min_width)
        # 将 imgW 对齐到 32，以避免任意宽度图像的 ROCm MIOpen JIT 开销。
        imgW = math.ceil(imgW / 32) * 32

XXX/mineru/model/utils/tools/infer/predict_rec.py的355行下面增加

                        norm_img = norm_img[np.newaxis, :]
                        norm_img_batch.append(norm_img)
                # 增加下面内容，将批次填充到固定大小（self.rec_batch_num），以避免 MIOpen 重新编译。避免最后一个部分批次7秒以上的延迟问题。
                actual_batch_size = len(norm_img_batch)
                if actual_batch_size < batch_num:
                    pad_size = batch_num - actual_batch_size
                    pad_img = np.zeros_like(norm_img_batch[0])
                    for _ in range(pad_size):
                        norm_img_batch.append(pad_img)
                # 改动结束
                norm_img_batch = np.concatenate(norm_img_batch)
                norm_img_batch = norm_img_batch.copy()

XXX/mineru/model/utils/tools/infer/predict_rec.py的433行附近修改for rno in range(len(rec_result))为for rno in range(actual_batch_size)：

                # 只处理实际图像，忽略填充。
                for rno in range(actual_batch_size):
                    rec_res[indices[beg_img_no + rno]] = rec_result[rno]
                elapse += time.time() - starttime

XXX/mineru/model/utils/tools/infer/predict_det.py 312行下面增加两行形式检查，是否连续：

            inp = torch.from_numpy(img)
            inp = inp.to(self.device)
            # Check format
            if not inp.is_contiguous():
                inp = inp.contiguous()
            outputs = self.net(inp)

差不多就这么多，仓库里我额外改了两个文件，只是为了修复一个warming的，不重要

---

4.运行一个预热脚本，在这个环境提前存好所有的MIOPEN conv2d的kernel缓存，避免用的时候寻找。

抓取模型运行时的张量形状得到的问题形状，冷启动需要1s搜索的，就是后两个都是32的奇数次时：

序号	输入形状 (Shape)	Net Forward Time (ms)
1	(1, 3, 544, 672)	1320.09
2	(1, 3, 416, 704)	1133.11
3	(1, 3, 288, 736)	982.78
4	(1, 3, 448, 736)	1202.01
5	(1, 3, 512, 672)	1236.20
6	(1, 3, 352, 736)	1076.65
7	(1, 3, 480, 672)	1207.67
8	(1, 3, 288, 544)	906.87

让AI帮我重新写了一个预热脚本，我自己是通过加载模型预热过的，但是每个人电脑模型存储位置可能不一样，那还是预热形状吧。建一个cache_warmer.py 直接运行就行。

import os
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
from tqdm import tqdm

def get_args():
    parser = argparse.ArgumentParser(description="ROCm MIOpen Cache Warmer (No Model File Required)")
    parser.add_argument("--device", type=str, default="cuda", help="Device to run on")
    parser.add_argument("--max_side", type=int, default=960, help="Max image side length")
    parser.add_argument("--step", type=int, default=32, help="Step size for resolution grid")
    return parser.parse_args()

class MockOCRModel(nn.Module):
    """
    一个模拟 PP-OCR/DBNet 结构的代理模型。
    它不需要通过训练，包含了 MobileNetV3 和 DBHead 中涉及的所有关键卷积算子类型：
    1. Standard Conv 3x3, stride 1 & 2
    2. Pointwise Conv 1x1
    3. Depthwise Conv 3x3
    4. Depthwise Conv 5x5 (MobileNetV3 特有)
    5. Upsampling / Fusion
    """
    def __init__(self, in_channels=3):
        super().__init__()
        
        # 1. Stem (Standard 3x3, stride 2)
        self.stem = nn.Conv2d(in_channels, 16, kernel_size=3, stride=2, padding=1)
        
        # 2. Depthwise Separable Blocks (模拟 MobileNetV3 的核心算子)
        # Block 1: 3x3 Depthwise
        self.dw_3x3 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=1, groups=16)
        self.pw_1 = nn.Conv2d(16, 64, kernel_size=1, stride=1)
        
        # Block 2: 5x5 Depthwise (关键！很多缓存缺失是因为没覆盖 k=5)
        self.dw_5x5 = nn.Conv2d(64, 64, kernel_size=5, stride=2, padding=2, groups=64)
        self.pw_2 = nn.Conv2d(64, 128, kernel_size=1, stride=1)
        
        # Block 3: Larger stride/channel
        self.dw_3x3_s2 = nn.Conv2d(128, 128, kernel_size=3, stride=2, padding=1, groups=128)
        self.pw_3 = nn.Conv2d(128, 256, kernel_size=1, stride=1)

        # 3. Neck/Head (FPN + DBHead Simulation)
        # 模拟特征融合和输出层的 1x1 卷积与上采样
        self.out_conv = nn.Conv2d(256, 64, kernel_size=1)
        self.binarize_conv = nn.Conv2d(64, 1, kernel_size=3, stride=1, padding=1) # Standard 3x3 for head
        
        # 激活函数也会影响某些融合算子的编译
        self.act = nn.ReLU()

    def forward(self, x):
        # 模拟前向传播路径，确保所有算子被执行
        x = self.stem(x)
        x = self.act(x)
        
        x = self.dw_3x3(x)
        x = self.pw_1(x)
        
        x = self.dw_5x5(x)
        x = self.act(x)
        x = self.pw_2(x)
        
        x = self.dw_3x3_s2(x)
        x = self.pw_3(x)
        
        # 模拟 Head 部分的上采样和输出
        x = self.out_conv(x)
        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
        x = self.binarize_conv(x)
        return x

def main():
    args = get_args()

    if not torch.cuda.is_available():
        print("Error: CUDA/ROCm is not available. This script requires a GPU.")
        return

    device = torch.device(args.device)
    
    print("="*80)
    print("ROCm MIOpen Cache Warmer (Standalone Version)")
    print("="*80)
    print("Initializing Proxy Model (matches PP-OCR architecture structure)...")
    
    # 初始化模型并放入 GPU (随机权重即可，不需要加载真实模型)
    model = MockOCRModel().to(device)
    model.eval()

    # 生成分辨率列表
    # PP-OCR 默认限制通常在 960 左右，且必须是 32 的倍数
    min_side = 64 # 这里的最小尺寸不需要太小，常用范围即可
    heights = range(min_side, args.max_side + 1, args.step)
    widths = range(min_side, args.max_side + 1, args.step)
    
    combinations = []
    for h in heights:
        for w in widths:
            combinations.append((h, w))

    print(f"Plan to warm up {len(combinations)} shape combinations...")
    print(f"Range: {min_side}x{min_side} to {args.max_side}x{args.max_side}, Step: {args.step}")

    # 开始预热
    pbar = tqdm(combinations)
    success_count = 0
    
    # 只需要做一次 forward 就可以触发编译
    with torch.no_grad():
        for h, w in pbar:
            pbar.set_description(f"Warming {h}x{w}")
            try:
                # 构造输入 Tensor (B=1, C=3, H, W)
                # 使用 float32，因为这是推理时的默认精度
                dummy_input = torch.zeros((1, 3, h, w), device=device, dtype=torch.float32)
                
                # 执行推理
                model(dummy_input)
                success_count += 1
                
            except RuntimeError as e:
                if "out of memory" in str(e):
                    pbar.write(f"Skipping {h}x{w} due to OOM")
                    torch.cuda.empty_cache()
                else:
                    pbar.write(f"Failed {h}x{w}: {e}")
            except Exception as e:
                pbar.write(f"Unexpected error at {h}x{w}: {e}")

    print("\n" + "="*80)
    print(f"WARMUP COMPLETE! ({success_count}/{len(combinations)} shapes processed)")
    print("MIOpen kernels for MobileNetV3/DBNet architectures have been cached.")
    print("Location: ~/.cache/miopen/ (or system default)")
    print("="*80)

if __name__ == "__main__":
    main()

---

5.最后整三个环境变量后愉快玩耍即可

export MINERU_MODEL_SOURCE=modelscope
export TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1
export FLASH_ATTENTION_TRITON_AMD_ENABLE="TRUE"  #使用时也需要，否则flash_attn不识别
mineru-gradio --server-name 0.0.0.0 --server-port 7860 

---

6.运行结果

Layout Predict: 100%|█████████████████████████████████| 200/200 [00:10<00:00, 18.81it/s]
MFD Predict: 100%|██████████████████████████████████| 200/200 [00:09<00:00, 21.82it/s]
MFR Predict: 100%|██████████████████████████████████| 430/430 [00:04<00:00, 106.36it/s]
Table-ocr det: 100%|█████████████████████████████████| 142/142 [00:01<00:00, 127.44it/s]
Table-ocr rec ch: 100%|███████████████████████████████| 881/881 [00:02<00:00, 409.11it/s]
Table-wireless Predict: 100%|████████████████████████████| 141/141 [00:01<00:00, 71.38it/s]
Table-wired Predict: 100%|████████████████████████████| 117/117 [00:03<00:00, 30.32it/s]
OCR-det Predict: 100%|██████████████████████████████| 200/200 [00:14<00:00, 14.22it/s]
Processing pages: 100%|█████████████████████████████| 200/200 [00:08<00:00, 24.86it/s]
OCR-rec Predict: 100%|██████████████████████████████| 20/20 [00:00<00:00, 422.94it/s]

下面vllm的PDF来自https://github.com/krahets/hello-algo/releases/tag/1.3.0 中文python版

mineru.utils.engine_utils:get_vlm_engine:32 - Using vllm-async-engine as the inference engine for VLM.
Two Step Extraction: 100%|█████████████████████████████| 348/348 [02:53<00:00,  2.01it/s]

---

PS：mineru保存的jpg图片很不清晰，并且命名也不是序号来的，我自用版本改成了webp格式图片，并且按照真实顺序保存的，方便使用，300dpi压缩95%的webp图像就非常清晰了，而且每张图体积也非常小。所以其实推荐使用这个格式来保存图片。

[tinafengfun]

非常赞的patch，能详细说说为啥7900 要这样手动调的原因？--- 针对7900xtx的手动调优配置，其他GPU的最优组合可能需要自行寻找，AMD的autotune效果就是没有效果

[healy-hub]

非常赞的patch，能详细说说为啥7900 要这样手动调的原因？--- 针对7900xtx的手动调优配置，其他GPU的最优组合可能需要自行寻找，AMD的autotune效果就是没有效果

这个triton实现比较麻烦，我放弃了triton有一个优雅点的通解了，回头整理一下更新，现在还很混乱。AMD的vllm要么docker，要么自行编译，感觉没法写一个pr合并进这个仓库。但是pipeline后端的加速方案，我猜国产基于rocm改的GPU可以参考。

[myhloli]

非常赞的patch，能详细说说为啥7900 要这样手动调的原因？--- 针对7900xtx的手动调优配置，其他GPU的最优组合可能需要自行寻找，AMD的autotune效果就是没有效果

这个triton实现比较麻烦，我放弃了triton有一个优雅点的通解了，回头整理一下更新，现在还很混乱。AMD的vllm要么docker，要么自行编译，感觉没法写一个pr合并进这个仓库。但是pipeline后端的加速方案，我猜国产基于rocm改的GPU可以参考。

我们在国产的海光dcu上进行过测试，没有遇到amd上这么明显的性能bug，速度比较符合预期。

[healy-hub]

非常赞的patch，能详细说说为啥7900 要这样手动调的原因？--- 针对7900xtx的手动调优配置，其他GPU的最优组合可能需要自行寻找，AMD的autotune效果就是没有效果

这个triton实现比较麻烦，我放弃了triton有一个优雅点的通解了，回头整理一下更新，现在还很混乱。AMD的vllm要么docker，要么自行编译，感觉没法写一个pr合并进这个仓库。但是pipeline后端的加速方案，我猜国产基于rocm改的GPU可以参考。

我们在国产的海光dcu上进行过测试，没有遇到amd上这么明显的性能bug，速度比较符合预期。

原来如此，看来他们应该用的有tensor的CDNA架构，就没什么问题。消费级AMD这边用的RDNA架构，真的一言难尽，很多算子支持都有奇葩回退，一个超大尺寸的conv3d能寻找12s的kernel，空洞卷积每次找1s，conv2d出现双32的奇数倍丢失kernel。。。。我做了一些改动，新的教程我需要整理一下再发在评论区。另外用户patch其实比较麻烦，我考虑做一个仓库方便大家。

[tinafengfun]

可以试试flag gemm那边搞的一个自动生成triton的项目，https://github.com/flagos-ai/KernelGen 不知道怎么样，再手工调调看。 哎，手搓真的不容易，心痛各位一下下。最近工程界弄了不少ai生成kernel的项目，可能能解决点痛点。

[healy-hub]

可以试试flag gemm那边搞的一个自动生成triton的项目，https://github.com/flagos-ai/KernelGen 不知道怎么样，再手工调调看。 哎，手搓真的不容易，心痛各位一下下。最近工程界弄了不少ai生成kernel的项目，可能能解决点痛点。

可以的，谢谢，我学习了解一下。
这个项目的适配我暂时放弃Triton了，空洞卷积那个可以直接填充到标准卷积，OCR批处理不满足6 batch的也填充到到6patch，避免任何非官方kernel的寻找，速度就挺快的。我正在整理文档，为了测试改动的位置有点混乱。。。
目前vllm大概在1.84-2.01it/s（300页的编程pdf测试），pipeline后端的ocr也可以到几百it/s了。

[ChenxiWu-Lab]

大佬啥时候更新呀~

[healy-hub]

大佬啥时候更新呀~

稍等，下午或者晚上应该就发了，这几天事情太多了

[healy-hub]

大佬啥时候更新呀~

已更新

[vjeson]

大佬是否支持 mineru 3.x版本？

[tinafengfun]

有兴趣去参加AMD 的模型优化比赛吗？用上AI 会更厉害，大牛加油，可以转奖金呀 https://marketing.csdn.net/questions/Q2603192021352912290?utm_source=dx&utm_medium=distribute.app_sms.1093755.nonecase&csdn_tiny_tail=%7B%22ext%22%3A%221c4f62c151001033%22,%22phone%22%3A%2213466334563%22,%22distribute_task_id%22%3A%221093755%22,%22taskId%22%3A%221093755%22,%22smsOperator%22%3A%22mengwang%22%7D， 我不是广告，我是在做AI算子优化的同学