TNN MatConverter Resize

原创 已于 2023-08-12 09:43:12 修改
· 970 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#深度学习 #TNN #图像处理 #arm

于 2021-05-09 16:53:29 首次发布

TNN 的 resize 虽然分通道提供了多个接口，但底层是一起的。整个实现对于灰度图优化非常有限，而3通道或4通道的图像会有加速。缩放的映射关系较为简单，主要分为三步：

  • 一维位置索引和插值系数计算；
  • 行内像素插值；
  • 相邻行结果插值。

ResizeBilinearC1
ResizeBilinearC1
ResizeBilinearC1Impl 
    return ResizeBilinearC1Impl(src, batch, src_w, src_h, src_w, dst, w, h, w);

ResizeBilinearC1Impl
ResizeBilinearC1Impl
ResizeBilinearPreparation
ResizeBilinearC3Impl
ResizeBilinearOneRow

ResizeBilinearPreparation 在行列方向上独立计算对应源图上的位置和系数。
根据线程数开辟rows0和rows1缓存，rows0_t和rows1_t为所属各线程的指针。
OMP_PARALLEL_FOR_
OMP_TID_ 调用 omp_get_thread_num
prev_sy数组记录每个线程上次处理的源图上的行。而 OpenMP 下每个目的行都是独立执行的，复用靠运气？
ResizeBilinearOneRow 传入一个比较复杂的 ResizeBilinearKernelParm 结构体。

    ResizeBilinearPreparation(1);

    ResizeBilinearKernelParm param(xofs, yofs, ialpha, ibeta, src, dst, src_plane, src_stride, schannel);

    // loop body
    int max_num_threads = OMP_MAX_THREADS_NUM_;
    short* rows0        = new short[w * max_num_threads];
    short* rows1        = new short[w * max_num_threads];
    short* rows0_t[max_num_threads];
    short* rows1_t[max_num_threads];
    int    prev_sy[max_num_threads];

    for (int b = 0; b < batch; ++b) {
        for (int t = 0; t < max_num_threads; ++t) {
            prev_sy[t] = -2;
            rows0_t[t] = rows0 + t * w;
            rows1_t[t] = rows1 + t * w;
        }

        OMP_PARALLEL_FOR_
        for (int dy = 0; dy < h; dy++) {
            int thread_id  = OMP_TID_;
            ResizeBilinearOneRow(param, thread_id, rows0_t, rows1_t, prev_sy, b, w, h, stride, dy);
        }
    }

    delete[] rows0;
    delete[] rows1;
    delete[] buf;

ResizeBilinearPreparation
ResizeBilinearPreparation
GetResizeBuf

GetResizeBuf 开辟一块公共连续内存并计算输入图上的对应位置（xofs和yofs）和一维插值系数（ialpha和ibeta）。
内部计算好后外部通过指针访问，不如 OpenCV 直观。

#define ResizeBilinearPreparation(channel)                               \
    int schannel  = channel;                                             \
    int* buf      = nullptr;                                             \
    GetResizeBuf(src_w, src_h, w, h, schannel, &buf);                    \
    int* xofs     = buf;                                                 \
    int* yofs     = buf + w;                                             \
    short* ialpha = (short*)(buf + w + h);                               \
    short* ibeta  = (short*)(buf + w + h + w);                           \
    int src_plane = src_h * src_stride;

GetResizeBuf

GetResizeBufPreparation 开辟一段连续内存并定义4个参数指针。
CalculatePositionAndRatio 计算对应位置和一维插值系数。
横向和纵向操作是相同的。

    GetResizeBufPreparation(short);

    CalculatePositionAndRatio(w, scale_x, src_w, c, xofs, ialpha);
    CalculatePositionAndRatio(h, scale_y, src_h, 1, yofs, ibeta);

GetResizeBufPreparation

源除以目的。

#define  GetResizeBufPreparation(type)                                    \
    double scale_x = (double)src_w / w;                                   \
    double scale_y = (double)src_h / h;                                   \
    *buf = new int[w + h + w + h];                                        \
    int* xofs = *buf;                                                     \
    int* yofs = *buf + w;                                                 \
    type* ialpha = (type*)(*buf + w + h);                                 \
    type* ibeta  = (type*)(*buf + w + h + w);

CalculatePositionAndRatio

CalculatePosition 根据索引和缩放系数计算源图上对应的位置并修剪到边界内，返回位置比例系数rat_f。
将一组比例系数放大以整数形式保存。

    const int INTER_RESIZE_COEF_BITS  = 11;
    const int INTER_RESIZE_COEF_SCALE = 1 << INTER_RESIZE_COEF_BITS;
    for (int i = 0; i < length; i++) {
        float rat_f = CalculatePosition(position, i, scale, border, channel);
        float a0 = (1.f - rat_f) * INTER_RESIZE_COEF_SCALE;
        float a1 = rat_f * INTER_RESIZE_COEF_SCALE;

        ratio[i * 2]     = SATURATE_CAST_SHORT(a0);
        ratio[i * 2 + 1] = SATURATE_CAST_SHORT(a1);
    }

ResizeBilinearOneRow
ResizeBilinearOneRow
ResizeGetAdjacentRows
ResizeCalculateOneRow

借助yofs得到对应源图上的行。
ResizeGetAdjacentRows 对于单通道无优化，将同行两元素加权。
ResizeCalculateOneRow 由两个相邻的源行得到目的行。

    int sy = param.yofs[dy];
    ResizeGetAdjacentRows(sy, prev_sy[thread_id], &rows0_t[thread_id], &rows1_t[thread_id], param.xofs,
                          param.src + b * param.src_plane, param.src_stride, param.schannel, w, param.ialpha);
    prev_sy[thread_id] = sy;

    // vresize
    short b0 = param.ibeta[dy * 2];
    short b1 = param.ibeta[dy * 2 + 1];

    uint8_t* Dp   = param.dst + stride * (b * h + dy);

    ResizeCalculateOneRow(rows0_t[thread_id], rows1_t[thread_id], b0, b1, w, param.schannel, Dp);

ResizeGetAdjacentRows

如果prev_sy是sy的前一行，那么意味着sy行不需要处理了，只处理sy + 1行。
S1指向了sy + 1行。
S1p为当前行中位置。

x 2 − x x 2 − x 1 f ( Q 21 ) + x − x 1 x 2 − x 1 f ( Q 22 ) = α 0 f ( Q 21 ) + α 1 f ( Q 22 ) \frac{x_2 -x}{x_2 -x_1}f(Q_{21}) + \frac{x-x_1}{x_2 -x_1}f(Q_{22})= \alpha_0 f(Q_{21}) + \alpha_1 f(Q_{22}) x2​−x1​x2​−x​f(Q21​)+x2​−x1​x−x1​​f(Q22​)=α0​f(Q21​)+α1​f(Q22​)

不论通道数量如何，每次循环处理一个目的像素。
加权结果右移4位。

    if (sy == prev_sy) {
        // reuse all rows
    } else if (sy == prev_sy + 1) {
        // hresize one row
        short* rows0_old  = *rows0;
        *rows0            = *rows1;
        *rows1            = rows0_old;
        const uint8_t* S1 = src + src_stride * (sy + 1);

        short* rows1p        = *rows1;
        for (int dx = 0; dx < w; dx++) {
            int sx   = xofs[dx];
            short a0 = ialphap[0];
            short a1 = ialphap[1];

            const uint8_t* S1p = S1 + sx;

#ifndef TNN_USE_NEON
            for (int dc = 0; dc < c; ++dc) {
                rows1p[dc]         = (S1p[dc] * a0 + S1p[dc + c] * a1) >> 4;
            }
#else
            if (c == 2) {
                int16x4_t _a0a1XX = vld1_s16(ialphap);
                int16x4_t _a0a0a1a1 = vzip_s16(_a0a1XX, _a0a1XX).val[0];
                uint8x8_t _S1 = uint8x8_t();

                _S1 = vld1_lane_u8(S1p, _S1, 0);
                _S1 = vld1_lane_u8(S1p + 1, _S1, 1);
                _S1 = vld1_lane_u8(S1p + 2, _S1, 2);
                _S1 = vld1_lane_u8(S1p + 3, _S1, 3);

                int16x8_t _S116 = vreinterpretq_s16_u16(vmovl_u8(_S1));
                int16x4_t _S1lowhigh = vget_low_s16(_S116);
                int32x4_t _S1ma0a1 = vmull_s16(_S1lowhigh, _a0a0a1a1);
                int32x2_t _rows1low = vadd_s32(vget_low_s32(_S1ma0a1), vget_high_s32(_S1ma0a1));
                int32x4_t _rows1 = vcombine_s32(_rows1low, vget_high_s32(_S1ma0a1));
                int16x4_t _rows1_sr4 = vshrn_n_s32(_rows1, 4);
                vst1_s16(rows1p, _rows1_sr4);
            } else if (c == 3) {
                int16x4_t _a0 = vdup_n_s16(a0);
                int16x4_t _a1 = vdup_n_s16(a1);
                uint8x8_t _S1 = uint8x8_t();

                _S1 = vld1_lane_u8(S1p, _S1, 0);
                _S1 = vld1_lane_u8(S1p + 1, _S1, 1);
                _S1 = vld1_lane_u8(S1p + 2, _S1, 2);
                _S1 = vld1_lane_u8(S1p + 3, _S1, 3);
                _S1 = vld1_lane_u8(S1p + 4, _S1, 4);
                _S1 = vld1_lane_u8(S1p + 5, _S1, 5);

                int16x8_t _S116 = vreinterpretq_s16_u16(vmovl_u8(_S1));
                int16x4_t _S1low = vget_low_s16(_S116);
                int16x4_t _S1high = vext_s16(_S1low, vget_high_s16(_S116), 3);
                int32x4_t _rows1 = vmull_s16(_S1low, _a0);
                _rows1 = vmlal_s16(_rows1, _S1high, _a1);
                int16x4_t _rows1_sr4 = vshrn_n_s32(_rows1, 4);
                vst1_s16(rows1p, _rows1_sr4);
            } else if (c == 4) {
                int16x4_t _a0 = vdup_n_s16(a0);
                int16x4_t _a1 = vdup_n_s16(a1);
                uint8x8_t _S1 = vld1_u8(S1p);

                int16x8_t _S116 = vreinterpretq_s16_u16(vmovl_u8(_S1));
                int16x4_t _S1low = vget_low_s16(_S116);
                int16x4_t _S1high = vget_high_s16(_S116);
                int32x4_t _rows1 = vmull_s16(_S1low, _a0);
                _rows1 = vmlal_s16(_rows1, _S1high, _a1);
                int16x4_t _rows1_sr4 = vshrn_n_s32(_rows1, 4);
                vst1_s16(rows1p, _rows1_sr4);
            } else {
                for (int dc = 0; dc < c; ++dc) {
                    rows1p[dc]         = (S1p[dc] * a0 + S1p[dc + c] * a1) >> 4;
                }
            }
#endif

            ialphap += 2;
            rows1p += c;
        }

否则分别缩放sy和sy + 1两行。
α 0 f ( Q 11 ) + α 1 f ( Q 12 ) \alpha_0 f(Q_{11}) + \alpha_1 f(Q_{12}) α0​f(Q11​)+α1​f(Q12​) 和 α 0 f ( Q 21 ) + α 1 f ( Q 22 ) \alpha_0 f(Q_{21}) + \alpha_1 f(Q_{22}) α0​f(Q21​)+α1​f(Q22​)
vdup_n_s16 广播参数。
vld1_lane_u8 逐个加载源像素。
对于两通道的图，_S0和_S1使用了一半；三通道使用了3/4。
_S016和_S116为临时变量，_S0lowhigh和_S1lowhigh取其前4个元素。_S0S1low_S0S1high分开存储两个目的点的值。
vmovl_u8 将_S0和_S1中的元素值左移，vreinterpretq_s16_u16 转为有符号数。
vget_low_s16 取出_S0和_S1中有效的一半元素。
vtrn_s32 转置元素。在转置前使用 vreinterpret_s32_s16，确保同一像素的两个通道在一起，而两行的左源像素在一起，右源像素在一起。即_S0S1low_S0S1high.val[0]为 [ f ( Q 11 ) , f ( Q 21 ) ] [f(Q_{11}), f(Q_{21})] [f(Q11​),f(Q21​)]，_S0S1low_S0S1high.val[1]为 [ f ( Q 12 ) , f ( Q 22 ) ] [f(Q_{12}), f(Q_{22})] [f(Q12​),f(Q22​)]。

左移转换
取低
左移转换
取低
转换并转置
转换并转置
_S0
_S016
_S0lowhigh
_S1
_S116
_S1lowhigh
_S0S1low_S0S1high

_rows01向量中分别为sy行和sy+1行的加权和。
vext_s16 从第二个操作数向量的低端提取 n 个元素，从第一个操作数的高端提取其余元素，并将它们组合以形成结果向量。 第二个操作数的元素放置在结果向量的最高有效部分中，第一个操作数的元素放置在结果向量的最低有效部分中。这里两个输入向量相同，则会将其循环移位。
vst1_s16 存储4个元素。这里有越写覆盖问题，所以申请内存的时候尾部多一点。两次调用将_rows01_sr4中的两部分分别保存下来。

    } else {
        // hresize two rows
        const uint8_t* S0 = src + src_stride * (sy);
        const uint8_t* S1 = src + src_stride * (sy + 1);

        short* rows0p        = *rows0;
        short* rows1p        = *rows1;
        for (int dx = 0; dx < w; dx++) {
            int sx   = xofs[dx];
            short a0 = ialphap[0];
            short a1 = ialphap[1];

            const uint8_t* S0p = S0 + sx;
            const uint8_t* S1p = S1 + sx;

#ifndef TNN_USE_NEON
            for (int dc = 0; dc < c; ++dc) {
                rows0p[dc]         = (S0p[dc] * a0 + S0p[dc + c] * a1) >> 4;
                rows1p[dc]         = (S1p[dc] * a0 + S1p[dc + c] * a1) >> 4;
            }
#else
            if (c == 2) {
                int16x4_t _a0 = vdup_n_s16(a0);
                int16x4_t _a1 = vdup_n_s16(a1);
                uint8x8_t _S0 = uint8x8_t();
                uint8x8_t _S1 = uint8x8_t();

                _S0 = vld1_lane_u8(S0p, _S0, 0);
                _S0 = vld1_lane_u8(S0p + 1, _S0, 1);
                _S0 = vld1_lane_u8(S0p + 2, _S0, 2);
                _S0 = vld1_lane_u8(S0p + 3, _S0, 3);

                _S1 = vld1_lane_u8(S1p, _S1, 0);
                _S1 = vld1_lane_u8(S1p + 1, _S1, 1);
                _S1 = vld1_lane_u8(S1p + 2, _S1, 2);
                _S1 = vld1_lane_u8(S1p + 3, _S1, 3);

                int16x8_t _S016 = vreinterpretq_s16_u16(vmovl_u8(_S0));
                int16x8_t _S116 = vreinterpretq_s16_u16(vmovl_u8(_S1));
                int16x4_t _S0lowhigh = vget_low_s16(_S016);
                int16x4_t _S1lowhigh = vget_low_s16(_S116);
                int32x2x2_t _S0S1low_S0S1high = vtrn_s32(vreinterpret_s32_s16(_S0lowhigh), vreinterpret_s32_s16(_S1lowhigh));
                int32x4_t _rows01 = vmull_s16(vreinterpret_s16_s32(_S0S1low_S0S1high.val[0]), _a0);
                _rows01 = vmlal_s16(_rows01, vreinterpret_s16_s32(_S0S1low_S0S1high.val[1]), _a1);
                int16x4_t _rows01_sr4 = vshrn_n_s32(_rows01, 4);
                int16x4_t _rows1_sr4 = vext_s16(_rows01_sr4, _rows01_sr4, 2);
                vst1_s16(rows0p, _rows01_sr4);
                vst1_s16(rows1p, _rows1_sr4);

三通道和四通道的加载稍有不同，计算方式相同。

            } else if (c == 3) {
                int16x4_t _a0 = vdup_n_s16(a0);
                int16x4_t _a1 = vdup_n_s16(a1);
                uint8x8_t _S0 = uint8x8_t();
                uint8x8_t _S1 = uint8x8_t();

                _S0 = vld1_lane_u8(S0p, _S0, 0);
                _S0 = vld1_lane_u8(S0p + 1, _S0, 1);
                _S0 = vld1_lane_u8(S0p + 2, _S0, 2);
                _S0 = vld1_lane_u8(S0p + 3, _S0, 3);
                _S0 = vld1_lane_u8(S0p + 4, _S0, 4);
                _S0 = vld1_lane_u8(S0p + 5, _S0, 5);

                _S1 = vld1_lane_u8(S1p, _S1, 0);
                _S1 = vld1_lane_u8(S1p + 1, _S1, 1);
                _S1 = vld1_lane_u8(S1p + 2, _S1, 2);
                _S1 = vld1_lane_u8(S1p + 3, _S1, 3);
                _S1 = vld1_lane_u8(S1p + 4, _S1, 4);
                _S1 = vld1_lane_u8(S1p + 5, _S1, 5);

                int16x8_t _S016 = vreinterpretq_s16_u16(vmovl_u8(_S0));
                int16x8_t _S116 = vreinterpretq_s16_u16(vmovl_u8(_S1));
                int16x4_t _S0low = vget_low_s16(_S016);
                int16x4_t _S1low = vget_low_s16(_S116);
                int16x4_t _S0high = vext_s16(_S0low, vget_high_s16(_S016), 3);
                int16x4_t _S1high = vext_s16(_S1low, vget_high_s16(_S116), 3);
                int32x4_t _rows0 = vmull_s16(_S0low, _a0);
                int32x4_t _rows1 = vmull_s16(_S1low, _a0);
                _rows0 = vmlal_s16(_rows0, _S0high, _a1);
                _rows1 = vmlal_s16(_rows1, _S1high, _a1);
                int16x4_t _rows0_sr4 = vshrn_n_s32(_rows0, 4);
                int16x4_t _rows1_sr4 = vshrn_n_s32(_rows1, 4);
                vst1_s16(rows0p, _rows0_sr4);
                vst1_s16(rows1p, _rows1_sr4);
            } else if (c == 4) {
                int16x4_t _a0 = vdup_n_s16(a0);
                int16x4_t _a1 = vdup_n_s16(a1);
                uint8x8_t _S0 = vld1_u8(S0p);
                uint8x8_t _S1 = vld1_u8(S1p);
                int16x8_t _S016 = vreinterpretq_s16_u16(vmovl_u8(_S0));
                int16x8_t _S116 = vreinterpretq_s16_u16(vmovl_u8(_S1));
                int16x4_t _S0low = vget_low_s16(_S016);
                int16x4_t _S1low = vget_low_s16(_S116);
                int16x4_t _S0high = vget_high_s16(_S016);
                int16x4_t _S1high = vget_high_s16(_S116);
                int32x4_t _rows0 = vmull_s16(_S0low, _a0);
                int32x4_t _rows1 = vmull_s16(_S1low, _a0);
                _rows0 = vmlal_s16(_rows0, _S0high, _a1);
                _rows1 = vmlal_s16(_rows1, _S1high, _a1);
                int16x4_t _rows0_sr4 = vshrn_n_s32(_rows0, 4);
                int16x4_t _rows1_sr4 = vshrn_n_s32(_rows1, 4);
                vst1_s16(rows0p, _rows0_sr4);
                vst1_s16(rows1p, _rows1_sr4);
            } else {
                for (int dc = 0; dc < c; ++dc) {
                    rows0p[dc]         = (S0p[dc] * a0 + S0p[dc + c] * a1) >> 4;
                    rows1p[dc]         = (S1p[dc] * a0 + S1p[dc + c] * a1) >> 4;
                }
            }
#endif

            ialphap += 2;
            rows0p += c;
            rows1p += c;
        }
    }

ResizeCalculateOneRow

不区分通道，每次处理8个元素。
_v2对最终结果实现四舍五入。

#ifndef TNN_USE_NEON
    int remain = w * c;
#else
    int nn = (w * c) >> 3;
    int remain = (w * c) - (nn << 3);
    int16x4_t _b0 = vdup_n_s16(b0);
    int16x4_t _b1 = vdup_n_s16(b1);
    int32x4_t _v2 = vdupq_n_s32(2);

_rows0p_sr4_mb0和_rows0p_1_sr4_mb0为 β 0 ( α 0 f ( Q 11 ) + α 1 f ( Q 12 ) ) \beta_0(\alpha_0 f(Q_{11}) + \alpha_1 f(Q_{12})) β0​(α0​f(Q11​)+α1​f(Q12​))，
_rows1p_sr4_mb1和_rows1p_1_sr4_mb1为 β 1 ( α 0 f ( Q 21 ) + α 1 f ( Q 22 ) ) \beta_1(\alpha_0 f(Q_{21}) + \alpha_1 f(Q_{22})) β1​(α0​f(Q21​)+α1​f(Q22​))。
vsraq_n_s32 向量右移常数位并累加。
中间结果右移16位，然后右移两位。
_acc16和_acc16_1运算结果。vcombine_s16 将二者拼接起来。vqmovun_s16 为有符号整数到无符号的向量饱和窄指令。

    for (; nn > 0; nn--) {
        int16x4_t _rows0p_sr4   = vld1_s16(rows0p);
        int16x4_t _rows1p_sr4   = vld1_s16(rows1p);
        int16x4_t _rows0p_1_sr4 = vld1_s16(rows0p + 4);
        int16x4_t _rows1p_1_sr4 = vld1_s16(rows1p + 4);

        int32x4_t _rows0p_sr4_mb0   = vmull_s16(_rows0p_sr4, _b0);
        int32x4_t _rows1p_sr4_mb1   = vmull_s16(_rows1p_sr4, _b1);
        int32x4_t _rows0p_1_sr4_mb0 = vmull_s16(_rows0p_1_sr4, _b0);
        int32x4_t _rows1p_1_sr4_mb1 = vmull_s16(_rows1p_1_sr4, _b1);

        int32x4_t _acc = _v2;
        _acc           = vsraq_n_s32(_acc, _rows0p_sr4_mb0, 16);
        _acc           = vsraq_n_s32(_acc, _rows1p_sr4_mb1, 16);

        int32x4_t _acc_1 = _v2;
        _acc_1           = vsraq_n_s32(_acc_1, _rows0p_1_sr4_mb0, 16);
        _acc_1           = vsraq_n_s32(_acc_1, _rows1p_1_sr4_mb1, 16);

        int16x4_t _acc16   = vshrn_n_s32(_acc, 2);
        int16x4_t _acc16_1 = vshrn_n_s32(_acc_1, 2);

        uint8x8_t _D = vqmovun_s16(vcombine_s16(_acc16, _acc16_1));

        vst1_u8(Dp, _D);

        Dp += 8;
        rows0p += 8;
        rows1p += 8;
    }
#endif
    for (; remain; --remain) {
        *Dp++ = (uint8_t)(
            ((short)((b0 * (short)(*rows0p++)) >> 16) + (short)((b1 * (short)(*rows1p++)) >> 16) + 2) >> 2);
    }

参考资料：

TNN Model Converter教程
一行一生
04-28 1120
1.安装docekr 首先安装依赖 sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common 信任 Docker 的 GPG 公钥 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - 对于 amd64 架构的计算机，添加软件仓库 sudo add-apt-repos.
NCNN 源码学习【三】：数据处理
豫州刺史
12-13 968
从这个可以看出来，获取ncnn::Mat的三个通道的数据，是要用channel索引出来的，这里就是一个需要留意的点，ncnn::Mat的数据存储，channel间的需要对齐，不一定是连续的，也就是不要理所当然的用channel(0)的指针，自己加加加想去访问其他channel的数据，很容易翻车（我就因为这个翻车过），这个我们后面有时间可以好好写一写ncnn的数据排布。这个计算的细节还是很多的，大家感兴趣的可以去仔细研究一下，这里就不细写了，ncnn的代码为例效率，可能写的不是特别美观。
TNN MatConverter WarpAffine
yiran103的专栏
05-09 578
TNN 的仿射变换形态介于 OpenCV 和 ncnn 之间。其处理流程与 OpenCV 较为相似并做了一些优化，不同的地方在于数据处理宽度为4，比较小。在性能表现方面中规中矩，小图上不及 ncnn。 MatUtils::WarpAffine #mermaid-svg-FNwIOkXOm8kxHfXI .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color
TNN MatConvertParam参数scale和bias设置
AI吃大瓜的博客
12-16 1346
TNN MatConvertParam参数设置 实验TNN进行模型推理前，需要进行必要的预处理，如下设置TNN_NS::MatConvertParam inputCvtParam的scale和bias两个参数值 /*** Read image ***/ cv::Mat orig_image = cv::imread(IMAGE_NAME); int imageWidth = orig_image.size[1]; int imageHeight = orig_image
基于TNN在Android手机上实现图像分类
夜雨飘零
09-06 3852
TNN：由腾讯优图实验室打造，移动端高性能、轻量级推理框架，同时拥有跨平台、高性能、模型压缩、代码裁剪等众多突出优势。TNN框架在原有Rapidnet、ncnn框架的基础上进一步加强了移动端设备的支持以及性能优化，同时也借鉴了业界主流开源框架高性能和良好拓展性的优点。
TNN API说明文档
AI吃大瓜的博客
12-16 2766
TNN API说明文档 TNN：https://github.com/Tencent/TNN 说明文档：https://github.com/Tencent/TNN/blob/master/doc/cn/user/api.md 目录 TNN API说明文档 一、API兼容性 二、API调用 简介 步骤1. 模型解析 步骤2. 网络构建 步骤3. 输入设定 步骤4. 输出获取 二、API详解 API目录结构 1. core/macro.h 2. core/common.h 3.
腾讯TNN示例里的model文件
03-23
腾讯TNN（Tencent Neural Network）是一个轻量级、高效的深度学习框架，主要设计用于移动端和嵌入式设备。这个框架旨在提供快速的计算速度和较低的内存消耗，使其在资源有限的环境下也能运行复杂的神经网络模型。TNN...
腾讯Tnn 示例model文件
06-12
【腾讯Tnn 示例model文件】 腾讯Tnn，全称为Tencent Neural Network，是腾讯公司推出的一款轻量级的深度学习推理框架。它专注于移动设备和嵌入式平台，旨在提供高效、快速且易于部署的模型运行环境。Tnn支持多种...
Android版TNN SO 动态库
11-10
**Android版TNN SO动态库详解** TNN（Tensor Network Neural）是一款专为移动端设计的高性能、轻量级神经网络推理框架。它以其卓越的计算效率、跨平台兼容性、模型压缩技术以及代码裁剪能力在人工智能领域内备受...
基于腾讯优图的TNN推理引擎设计源码，性能超越ncnn的升级版开源技术
最新发布
10-03
TNN推理引擎在设计上超越了业界知名的ncnn推理引擎，通过腾讯优图的TNN源码，开发者能够接触到一个性能卓越的推理引擎解决方案。 TNN推理引擎支持多种平台，包括但不限于Android、iOS、Linux、Windows等。它通过...
TNN-model.zip
12-07
标题中的"TNN-model.zip"指的是一个包含TNN（Ternary Neural Network）模型的压缩文件。TNN是一种针对深度学习的轻量化模型，它通过使用二值化或三值化的权重来减少神经网络的计算复杂度和存储需求，特别适用于资源...
TNN API说明文档
金戈鐡馬
03-03 904
TNN 是一个移动端高性能、轻量级推理框架，同时拥有跨平台、高性能、模型压缩、代码裁剪等众多突出优势。TNN 框架在原有 Rapidnet、ncnn 框架的基础上进一步加强了移动端设备的支持以及性能优化，同时也借鉴了业界主流开源框架高性能和良好拓展性的优点。目前 TNN 已经在手 Q、微视、P 图等应用中落地，欢迎大家参与协同共建，促进 TNN 推理框架进一步完善。API调用主要对模型解析，网络构建，输入设定，输出获取四个步骤进行简要介绍，详细说明参见API详解部分。
ARM和NEON指令
热门推荐
学无止境
10-15 5万+
在移动平台上进行一些复杂算法的开发，一般需要用到指令集来进行加速。目前在移动上使用最多的是ARM芯片。 ARM是微处理器行业的一家知名企业，其芯片结构有：armv5、armv6、armv7和armv8系列。芯片类型有：arm7、arm9、arm11、cortex系列。指令集有：armv5、armv6和neon指令。关于ARM到知识参考：http://baike.baidu.com/view/11
转贴ARM NEON 优化的例子
weixin_30905133的博客
09-14 321
ARM NEON Optimization. An Example Http://hilbert-space.de/?p=22 Since there is so little information about NEON optimizations out there I thought I’d write a little about it. Some weeks a...
ARM NEON 编程系列8——ARM NEON 优化
STN_LCD的专栏
08-22 7732
https://zhuanlan.zhihu.com/p/24702989 ARM NEON 优化 小鱼干 8 个月前 原贴：ARM NEON Optimization. An Example 将RGB图像转为灰度图，作者运用NEON优化，速度大幅提升。这里来学习一下如何使用NEON。 Since there is so little inf
图像预处理篇---resize和padding的区别-持续更新
HeavenerWen的博客
06-12 6516
图像预处理中resize和padding resize 如果只是为了获得要求尺寸的图像，最常用的方法就是resize, the usual practice is to resize the input image to the given size(但是resize有缺点，the image aspect ratio is no longer kept.) This practice may work well for image classification where fine details may
RK3399pro 使用TNN日记 2（Linux系统）
weixin_36588212的博客
12-07 1103
RK3399pro 使用TNN日记 2（Linux系统）一、TNN的demo调试1.下载链接2.编译TNN3.从摄像头获取数据图像并检测目前在看源码中，先写到这里...... 一、TNN的demo调试 1.下载链接 TNN模型下载链接 model 优快云下载链接 百度网盘下载链接 提取码：a904 2.编译TNN 简单粗暴 (1) 进入到 TNN_PATH/scripts/ (2) 在终端中运行 ./build_aarch64_linux.sh 一般都没有问题的，然后便已完成 (3) 进入到 TNN_PA
腾讯发布推理框架TNN全平台版本，同时支持移动端、桌面端和服务端
OpenCV中文网
04-27 742
本文转载自腾讯优图。TNN是腾讯开源的新一代跨平台深度学习推理框架，也是腾讯深度学习与加速Oteam云帆的开源协同成果，由腾讯优图实验室主导，腾讯光影研究室、腾讯云架构平台部、腾讯数据平台...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值