TensorRT动态卷积自定义op（多输入卷积/权重动态卷积）

已于 2022-03-24 17:45:09 修改
阅读量2.1k 收藏 7
点赞数 4
分类专栏： TensorRT 推理框架 深度学习 文章标签： 深度学习 cnn 算法
于 2022-01-06 17:38:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fenplan/article/details/122348409
版权

随着算法模型的不断演变，常规的模型结构已经不能满足算法人员的需求，于是衍生出形色各异的op，比如动态卷积，即前向传播过程中，weight也会随着输入的不同而发生改变。
声明：

  1. 所谓动态卷积指在前向传播过程中weight发生变化
  2. 此处的动态卷积只是笔者对该op的一种称呼
  3. TensorRT通过ConvMultiInput来实现这种卷积（多输入卷积），但是只支持INT8显式量化
  4. 目前发现只在TensorRT中存在动态的问题，其他如onnx、OpenVINO不存在该问题

动态卷积大概长下面这个样子。其中input是输入，weight也是输入。weight根据前面层的输出内容进行调整。此时，weight已不再是默认参数，而是会根据模型input发生改变的。
在这里插入图片描述
1. 解决方法：自定义op（DWConv2D）
2. 如何写自定义op插件：自定义op
3. DWConv2D自定义插件代码（cudnn实现）：
dwConv2D.h

#ifndef WS_DYNAMIC_WEIGHT_CONV_2D_PLUGIN_H
#define WS_DYNAMIC_WEIGHT_CONV_2D_PLUGIN_H

#include "cudnn.h"
#include <cuda.h>
#include <vector>
#include <string>

#include <NvInfer.h>

class DWConv2D: public nvinfer1::IPluginV2DynamicExt
{
public:
    DWConv2D(const std::string name, const void *serial_buf, size_t serial_size);
    DWConv2D(const std::string &name, const int &stride, const int &padding, const int &dilation, const int group);
    DWConv2D(const void* data, size_t length);
    ~DWConv2D() override = default;

    nvinfer1::DimsExprs getOutputDimensions(int outputIndex, const nvinfer1::DimsExprs* inputs,
        int nbInputs, nvinfer1::IExprBuilder& exprBuilder) override;
    size_t getWorkspaceSize(const nvinfer1::PluginTensorDesc* inputs, int nbInputs,
        const nvinfer1::PluginTensorDesc* outputs, int nbOutputs) const override;
    int enqueue(const nvinfer1::PluginTensorDesc* inputDesc, const nvinfer1::PluginTensorDesc* outputDesc,
        const void* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) override;
    IPluginV2DynamicExt* clone() const override;

    void configurePlugin(const nvinfer1::DynamicPluginTensorDesc* in, int nbInputs,
        const nvinfer1::DynamicPluginTensorDesc* out, int nbOutputs) override;
    bool supportsFormatCombination(int pos, const nvinfer1::PluginTensorDesc* inOut, int nbInputs, int nbOutputs) override;
    void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, nvinfer1::IGpuAllocator* gpuAllocator) override;
    nvinfer1::DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const override;

    const char* getPluginType() const override;
    const char* getPluginVersion() const override;
    const char* getPluginNamespace() const override;
    void terminate() override;
    int initialize() override;
    void serialize(void* buffer) const override;
    size_t getSerializationSize() const override;
    void destroy() override;
    void detachFromContext() override;
    void setPluginNamespace(const char* pluginNamespace) override;
    int getNbOutputs() const override { return 1; }

private:
    std::string layer_name_;
    int stride_;
    int pads_;
    int dilation_;
    int group_;
    bool conv_init_;
    std::string mPluginNamespace;
    std::string mNamespace;
    
    cudnnHandle_t cudnn_;
    cudnnTensorDescriptor_t in_desc_;
    cudnnFilterDescriptor_t filt_desc_;
    cudnnTensorDescriptor_t out_desc_;
    cudnnConvolutionDescriptor_t conv_desc_;
};


class DWConv2DCreator : public nvinfer1::IPluginCreator
{
public:
    DWConv2DCreator();
    ~DWConv2DCreator() override = default;

    const char* getPluginName() const override;
    const char* getPluginVersion() const override;
    const nvinfer1::PluginFieldCollection* getFieldNames() override;
    nvinfer1::IPluginV2DynamicExt* createPlugin(const char* name, const nvinfer1::PluginFieldCollection* fc) override;
    nvinfer1::IPluginV2DynamicExt* deserializePlugin(const char* name, const void* serialData, size_t serialLength) override;
    void setPluginNamespace(const char* libNamespace) override {
        mNamespace = libNamespace;
    }

    const char* getPluginNamespace() const override {
        return mNamespace.c_str();
    }

private:
    static nvinfer1::PluginFieldCollection mFC;
    static std::vector<nvinfer1::PluginField> mPluginAttributes;
    std::string mNamespace;
    std::string mPluginName;
};

REGISTER_TENSORRT_PLUGIN(DWConv2DCreator);

#endif // WS_DYNAMIC_WEIGHT_CONV_2D_PLUGIN_H

dwConv2D.cpp

#include "dwConv2d.h"

#include <cassert>
#include <cstring>
#include <iostream>

#define CHECK_CUDNN(call) do                                                                   \
{                                                                                            \
cudnnStatus_t status_ = call;                                                                \
if( status_ != CUDNN_STATUS_SUCCESS )                                                        \
{                                                                                            \
    fprintf(stderr, "CUDNN Error at line %d: %s\n", __LINE__, cudnnGetErrorString(status_)); \
    exit(1);                                                                                 \
    }                                                                                        \
} while(0)

namespace {
    const char* DWCONV2D_PLUGIN_VERSION{"1"};
    const char* DWCONV2D_PLUGIN_NAME{"DWConv2D"};
} // namespace

nvinfer1::PluginFieldCollection DWConv2DCreator::mFC{};
std::vector<nvinfer1::PluginField> DWConv2DCreator::mPluginAttributes;

template <typename T>
void writeToBuffer(char *&buffer, const T &val) {
    *reinterpret_cast<T *>(buffer) = val;
    buffer += sizeof(T);
}

template <typename T>
T readFromBuffer(const char *&buffer) {
    T val = *reinterpret_cast<const T *>(buffer);
    buffer += sizeof(T);
    return val;
}

DWConv2D::DWConv2D(const std::string name, const void *serial_buf, size_t serial_size) : layer_name_(name),
    conv_init_(false) {
    cudnn_  = NULL;
    in_desc_ = NULL;
    filt_desc_ = NULL;
    out_desc_ = NULL;
    conv_desc_ = NULL;

    const char *d = reinterpret_cast<const char *>(serial_buf);
    const char *a = d;
    stride_ = readFromBuffer<size_t>(d);
    pads_ = readFromBuffer<size_t>(d);
    dilation_ = readFromBuffer<size_t>(d);
    group_ = readFromBuffer<size_t>(d);

    assert(d == a + sizeof(size_t) * 4);
}

DWConv2D::DWConv2D(const std::string &name, const int &stride, const int &padding, const int &dilation, const int group)
    : layer_name_(name), stride_(stride), pads_(padding), dilation_(dilation), group_(group), conv_init_(false) {
    cudnn_  = NULL;
    in_desc_ = NULL;
    filt_desc_ = NULL;
    out_desc_ = NULL;
    conv_desc_ = NULL;
}

void DWConv2D::serialize(void* buffer) const {
    char* d = static_cast<char*>(buffer), *a = d;
    writeToBuffer<size_t>(d, stride_);
    writeToBuffer<size_t>(d, pads_);
    writeToBuffer<size_t>(d, dilation_);
    writeToBuffer<size_t>(d, group_);

    assert(d == a + getSerializationSize());
}

size_t DWConv2D::getSerializationSize() const {
    size_t size = sizeof(stride_) + sizeof(pads_) + sizeof(dilation_) + sizeof(group_);
    return size;
}

int DWConv2D::initialize() {
    if (!conv_init_) {
        CHECK_CUDNN(cudnnCreate(&cudnn_));
        CHECK_CUDNN(cudnnCreateTensorDescriptor(&in_desc_));
        CHECK_CUDNN(cudnnCreateFilterDescriptor(&filt_desc_));
        CHECK_CUDNN(cudnnCreateConvolutionDescriptor(&conv_desc_));
        CHECK_CUDNN(cudnnSetConvolution2dDescriptor(conv_desc_, pads_, pads_, stride_, stride_, dilation_, dilation_, 
            CUDNN_CONVOLUTION, CUDNN_DATA_FLOAT));
        CHECK_CUDNN(cudnnSetConvolutionGroupCount(conv_desc_, group_));
        CHECK_CUDNN(cudnnCreateTensorDescriptor(&out_desc_));

        conv_init_ = true;
    }

    return 0;
}

void DWConv2D::terminate() {
    if (conv_init_) {
        if (conv_desc_) {
            CHECK_CUDNN(cudnnDestroyConvolutionDescriptor(conv_desc_));
            conv_desc_ = NULL;
        }

        if (in_desc_) {
            CHECK_CUDNN(cudnnDestroyTensorDescriptor(in_desc_));
            in_desc_ = NULL;
        }

        if (out_desc_) {
            CHECK_CUDNN(cudnnDestroyTensorDescriptor(out_desc_));
            out_desc_ = NULL;
        }

        if (filt_desc_) {
            CHECK_CUDNN(cudnnDestroyFilterDescriptor(filt_desc_));
            filt_desc_ = NULL;
        }

        if (cudnn_) {
            CHECK_CUDNN(cudnnDestroy(cudnn_));
            cudnn_ = NULL;
        }
        
        conv_init_ = false;
    }
}

nvinfer1::DimsExprs DWConv2D::getOutputDimensions(int outputIndex, const nvinfer1::DimsExprs* inputs,
    int nbInputs, nvinfer1::IExprBuilder& exprBuilder) {
	nvinfer1::DimsExprs ret(inputs[0]);
    ret.d[1] = inputs[1].d[0];
    const auto *con_one = exprBuilder.constant(1);
    const auto *con_stride = exprBuilder.constant(stride_);
    const auto *con_pad = exprBuilder.constant(pads_ * 2);

    const auto *con_h = exprBuilder.operation(nvinfer1::DimensionOperation::kSUM, 
        *exprBuilder.operation(nvinfer1::DimensionOperation::kSUB, *con_pad, *inputs[1].d[2]), *inputs[0].d[2]);
	ret.d[2] = exprBuilder.operation(nvinfer1::DimensionOperation::kSUM, *con_one, 
        *exprBuilder.operation(nvinfer1::DimensionOperation::kFLOOR_DIV, *con_h, *con_stride));
	
    const auto *con_w = exprBuilder.operation(nvinfer1::DimensionOperation::kSUM, 
        *exprBuilder.operation(nvinfer1::DimensionOperation::kSUB, *con_pad, *inputs[1].d[3]), *inputs[0].d[3]);
	ret.d[3] = exprBuilder.operation(nvinfer1::DimensionOperation::kSUM, *con_one, 
        *exprBuilder.operation(nvinfer1::DimensionOperation::kFLOOR_DIV, *con_w, *con_stride));

    return ret;
}

int DWConv2D::enqueue(const nvinfer1::PluginTensorDesc* inputDesc, const nvinfer1::PluginTensorDesc* outputDesc,
    const void* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) {
    float alpha = 1.f;
    float beta = 0.f;
    size_t workspace_bytes;

    // have to set again
    CHECK_CUDNN(cudnnSetStream(cudnn_, stream));

    int in_n = inputDesc[0].dims.d[0];
    int in_c = inputDesc[0].dims.d[1];
    int in_h = inputDesc[0].dims.d[2];
    int in_w = inputDesc[0].dims.d[3];
    CHECK_CUDNN(cudnnSetTensor4dDescriptor(in_desc_, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, in_n, in_c, in_h, in_w));

    int filt_k = inputDesc[1].dims.d[0];
    int filt_c = inputDesc[1].dims.d[1];
    int filt_h = inputDesc[1].dims.d[2];
    int filt_w = inputDesc[1].dims.d[3];
    CHECK_CUDNN(cudnnSetFilter4dDescriptor(filt_desc_, CUDNN_DATA_FLOAT, CUDNN_TENSOR_NCHW, filt_k, filt_c, filt_h, filt_w));

    int out_n;
    int out_c;
    int out_h;
    int out_w;
    CHECK_CUDNN(cudnnGetConvolution2dForwardOutputDim(conv_desc_, in_desc_, filt_desc_, &out_n, &out_c, &out_h, &out_w));
    CHECK_CUDNN(cudnnSetTensor4dDescriptor(out_desc_, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, out_n, out_c, out_h, out_w));

    CHECK_CUDNN(cudnnGetConvolutionForwardWorkspaceSize(cudnn_, in_desc_, filt_desc_, conv_desc_, out_desc_,
        CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM, &workspace_bytes)); 
    CHECK_CUDNN(cudnnConvolutionForward(cudnn_, &alpha, in_desc_, inputs[0], filt_desc_, inputs[1], conv_desc_, 
        CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM, workspace, workspace_bytes, &beta, out_desc_, outputs[0])); 

    return 0;
}

void DWConv2D::setPluginNamespace(const char* pluginNamespace) {
    mPluginNamespace = pluginNamespace;
}

const char* DWConv2D::getPluginNamespace() const {
    return mPluginNamespace.c_str();
}

// Return the DataType of the plugin output at the requested index
nvinfer1::DataType DWConv2D::getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const {
    return nvinfer1::DataType::kFLOAT;
}

bool DWConv2D::supportsFormatCombination(int pos, const nvinfer1::PluginTensorDesc* inOut, int nbInputs, int nbOutputs) {
    assert(nbInputs == 2 && nbOutputs == 1 && pos < nbInputs + nbOutputs);
    if (pos == 0) {
        return (inOut[pos].type == nvinfer1::DataType::kFLOAT && inOut[pos].format == nvinfer1::TensorFormat::kLINEAR);
    } else {
        return inOut[pos].type == inOut[0].type && inOut[pos].format == inOut[0].format;
    }
}

void DWConv2D::configurePlugin(const nvinfer1::DynamicPluginTensorDesc* in, int nbInputs,
    const nvinfer1::DynamicPluginTensorDesc* out, int nbOutputs) {
    assert(in && nbInputs == 2);
    assert(out && nbOutputs == 1); 
}

size_t DWConv2D::getWorkspaceSize(const nvinfer1::PluginTensorDesc* inputs, int nbInputs,
    const nvinfer1::PluginTensorDesc* outputs, int nbOutputs) const {
    assert(conv_init_);

    int in_n = inputs[0].dims.d[0];
    int in_c = inputs[0].dims.d[1];
    int in_h = inputs[0].dims.d[2];
    int in_w = inputs[0].dims.d[3];
    CHECK_CUDNN(cudnnSetTensor4dDescriptor(in_desc_, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, in_n, in_c, in_h, in_w));

    int filt_k = inputs[1].dims.d[0];
    int filt_c = inputs[1].dims.d[1];
    int filt_h = inputs[1].dims.d[2];
    int filt_w = inputs[1].dims.d[3];
    CHECK_CUDNN(cudnnSetFilter4dDescriptor(filt_desc_, CUDNN_DATA_FLOAT, CUDNN_TENSOR_NCHW, filt_k, filt_c, filt_h, filt_w));

    int out_n;
    int out_c;
    int out_h;
    int out_w;
    CHECK_CUDNN(cudnnGetConvolution2dForwardOutputDim(conv_desc_, in_desc_, filt_desc_, &out_n, &out_c, &out_h, &out_w));
    CHECK_CUDNN(cudnnSetTensor4dDescriptor(out_desc_, CUDNN_TENSOR_NCHW, CUDNN_DATA_FLOAT, out_n, out_c, out_h, out_w));

    size_t workspace_bytes;
    CHECK_CUDNN(cudnnGetConvolutionForwardWorkspaceSize(cudnn_, in_desc_, filt_desc_, conv_desc_, out_desc_, 
        CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM, &workspace_bytes));

    return workspace_bytes;
}

void DWConv2D::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, nvinfer1::IGpuAllocator* gpuAllocator){

}

void DWConv2D::detachFromContext() {

}

const char* DWConv2D::getPluginType() const {
    return DWCONV2D_PLUGIN_NAME;
}

const char* DWConv2D::getPluginVersion() const {
    return DWCONV2D_PLUGIN_VERSION;
}

void DWConv2D::destroy() {
    delete this;
}

nvinfer1::IPluginV2DynamicExt* DWConv2D::clone() const {
    DWConv2D *obj = new DWConv2D(layer_name_, stride_, pads_, dilation_, group_);
    obj->setPluginNamespace(mPluginNamespace.c_str());
    obj->initialize();

    return obj;
}

DWConv2DCreator::DWConv2DCreator() {
    mPluginAttributes.emplace_back(nvinfer1::PluginField("dilations"));
    mPluginAttributes.emplace_back(nvinfer1::PluginField("pads"));
    mPluginAttributes.emplace_back(nvinfer1::PluginField("strides"));
    mPluginAttributes.emplace_back(nvinfer1::PluginField("group"));
    mFC.nbFields = mPluginAttributes.size();
    mFC.fields = mPluginAttributes.data();   
}

const char* DWConv2DCreator::getPluginName() const {
    return DWCONV2D_PLUGIN_NAME;
}

const char* DWConv2DCreator::getPluginVersion() const {
    return DWCONV2D_PLUGIN_VERSION;
}

const nvinfer1::PluginFieldCollection* DWConv2DCreator::getFieldNames() {
    return &mFC;
}

nvinfer1::IPluginV2DynamicExt* DWConv2DCreator::createPlugin(const char* name, 
    const nvinfer1::PluginFieldCollection* fc) {
    nvinfer1::Dims stride{2, {1, 1}};
    nvinfer1::Dims padding{4, {0, 0, 0, 0}};
    nvinfer1::Dims dilation{2, {1, 1}};
    size_t group;

    for (int i = 0; i < fc->nbFields; i++) {
        if (fc->fields[i].data == nullptr) {
            continue;
        }

        std::string field_name(fc->fields[i].name);

        if (field_name.compare("strides") == 0) {
            stride.nbDims = 2;
            stride.d[0] = static_cast<const int *>(fc->fields[i].data)[0];
            if (fc->fields[i].length == 1) {
                stride.d[1] = stride.d[0];
            } else {
                stride.d[1] = static_cast<const int *>(fc->fields[i].data)[1];
            }
            assert(stride.d[0] == stride.d[1]);
        }

        if (field_name.compare("pads") == 0) {
            padding.nbDims = 2;
            padding.d[0] = static_cast<const int *>(fc->fields[i].data)[0];
            if (fc->fields[i].length == 1) {
                padding.d[1] = padding.d[0];
                padding.d[2] = padding.d[0];
                padding.d[3] = padding.d[0];
            } else {
                padding.d[1] = static_cast<const int *>(fc->fields[i].data)[1];
                padding.d[2] = static_cast<const int *>(fc->fields[i].data)[2];
                padding.d[3] = static_cast<const int *>(fc->fields[i].data)[3];
            }
            assert(padding.d[0] == padding.d[1] && padding.d[0] == padding.d[2] && padding.d[0] == padding.d[3]);
        }

        if (field_name.compare("dilation") == 0) {
            dilation.nbDims = 2;
            dilation.d[0] = static_cast<const int *>(fc->fields[i].data)[0];
            if (fc->fields[i].length == 1) {
                dilation.d[1] = dilation.d[0];
            } else {
                dilation.d[1] = static_cast<const int *>(fc->fields[i].data)[1];
            }
            assert(dilation.d[0] == dilation.d[1]);
        }

        if (field_name.compare("group") == 0) {
            group = static_cast<const int *>(fc->fields[i].data)[0];
        }
    }

    DWConv2D *obj = new DWConv2D(name, stride.d[0], padding.d[0], dilation.d[0], group);
    obj->setPluginNamespace(mNamespace.c_str());
    obj->initialize();

    return obj;
}

nvinfer1::IPluginV2DynamicExt* DWConv2DCreator::deserializePlugin(const char* name, const void* serialData, size_t serialLength) {    
    DWConv2D* obj = new DWConv2D(name, serialData, serialLength);
    obj->setPluginNamespace(mNamespace.c_str());
    obj->initialize();

    return obj;
}
Ehrich wen
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
MATLAB实现CNN卷积神经网络多输入多输出预测（完整源码和数据）
11-11
MATLAB实现CNN卷积神经网络多输入多输出预测（完整源码和数据） 数据为多输入多输出预测，输入10个特征，输出3个变量,程序乱码是由于版本不一致导致，可以用记事本打开复制到你的文件。 运行环境MATLAB2018b及以上。
TensorRT多输入，多输出
weixin_37958272的博客
02-25 3862
https://zhuanlan.zhihu.com/p/64114667 code: https://github.com/mightycatty/model_deployment/blob/6fda5ae9952ed04918166545ac43981bcad72c00/inference_engine/tensorrt_ie.py https://github.com/mightycatty/model_deployment/tree/6fda5ae9952ed04918166545ac43981bc
MATLAB实现CNN卷积神经网络多输入回归预测（完整源码和数据）
10-13
MATLAB实现CNN卷积神经网络多输入回归预测（完整源码和数据） 数据为多输入回归数据，输入7个特征，输出1个变量。 运行环境MATLAB2018b及以上。
动态蛇形卷积（Dynamic Snake Convolution）
01-24
动态蛇形卷积（Dynamic Snake Convolution）是一种创新的卷积操作，它主要用于处理图像中具有复杂几何形状和拓扑结构的特征，如管状结构、血管、道路、轮廓线等。与传统卷积不同的是，动态蛇形卷积不采用固定形状或大小的滤波器，而是允许卷积核在进行特征提取时以非刚性、可变形的方式对输入特征图进行“游走”
NameError: name ‘DWConvTranspose2d‘ is not defined【yolov5自训练报错日志及解决】
owenzi0的博客
07-17 491
运行训练时报错：NameError: name 'DWConvTranspose2d' is not defined
YOLOv4-Deepstream:使用Deepstream通过TensorRT和多流输入加速YOLOv4
04-16
Deepstream 5.1 YOLOv4应用 该Deepstream应用程序展示了以高FPS吞吐量运行的YOLOv4！ PS-单击gif观看整个视频！ 指数 深度流设置 这篇文章假设您拥有功能齐全的Jetson设备。 如果没有，您可以在参考文档。 1.安装系统依赖项 sudo apt install \ libssl1.0.0 \ libgstreamer1.0-0 \ gstreamer1.0-tools \ gstreamer1.0-plugins-good \ gstreamer1.0-plugins-bad \ gstreamer1.0-plugins-ugly \ gstreamer1.0-libav \ libgstrtspserver-1.0-0 \ libjansson4=2.11-1 2.安装Deepstream 从此处将DeepStream 5.1 Jetson
ConvTranspose2d原理，深度网络如何进行上采样？
热门推荐
月下花弄影
01-11 10万+
在生成图像中，我们需要不断的扩大图像的尺寸。 目前在深度学习中，ConvTranspose2d是其中一个方法。 在DCGAN（Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks）（原文地址）中就是用这个来实现的。 别名： convTranspose2d 是pytor...
TensorRT快速上手指南
pytorch内部机制解读
09-09 1592
最近一段时间接触了TensorRT，因此顺带整理了一份TensorRT中一些常用关键组件的笔记，以方便未来能够快速查阅和上手。需要注意的是本文只是一些常用特性与关键组件的梳理，而不是一个小白入门的教程，所以后续文章内容并不会提供快速上手的样例代码，实际上TensorRT官方的example中已经挺完善了，从0到1入门的新手建议直接看官方example中的代码。
dynamic convolution动态卷积理解
lt1103725556的博客
09-23 6463
参考 代码：https://github.com/kaijieshi7/Dynamic-convolution-Pytorch 博客：https://mp.weixin.qq.com/s/mZUSH7_7ysISoSMfxo4Vjw 就是原本的一个固定的卷积核，现在变为可以根据输入自适应改变注意力的卷积核 如上图所示，现在一个卷积核由K个卷积核决定，参数量大约上升了K倍(论文中说计算量并没有上升多少) 输入经过注意力提取，得到这k个卷积核的权重，线性加权起来就是新的一个卷积核 attention部分也就
tensorRT教程——tensor RT OP理解（实现自定义层，搭建网络）
TigerZ*的博客
08-03 2464
首先如果你的自定义操作可以通过一些矩阵操作来实现，那么你大可不必自己去通过plug in的方式实现，可以使用tensor RT 的OP来组合实现。 他的OP极其类似tensor flow的操作，如果看到不理解，那就去谷歌tensor flow的操作，触类旁通即可，但仍有一些文档描述错误。 一些我使用过典型的OP备注如下，并附上一个测试OP的脚本，按需修改即可： 1、reduce层的理解： reduce主要是在各个轴上进行对应的操作。 axes...
基于matlab的彩色gui动态显示线性卷积循环卷积
03-24
基于matlab的彩色gui动态显示线性卷积循环卷积，拥有良好的色彩效果的gui显示效果
基于matlab的gui显示动态卷积，圆周卷积
03-24
基于matlab的gui显示动态卷积，圆周卷积，数字信号处理的计算机实验
tensorRT 7.0 学习笔记（五）———量化/动态输入shape（c++ api）
qq_27582707的博客
03-22 2615
1.int8 量化 首先需要为 Ibuilder 设置校准器（caliborator）主要作用就是通过一定的算法把每层的weights 和输出tensor 映射到 int范围，TRT提供了以下几种校准器： 需要在继承其中之一后实现 getBatch()方法，然后调用： 为builder设置校准器。 同时 实现 writeCalibrationCache()andreadCalibrationCache()缓存/载入校准表 builder内部的工作原理： 1.调用 getBa...
TensorRT笔记八（动态推理）
nanjono的博客
05-03 529
注： 若onnx文件，则onnx文件打开后应该看到动态或-1 模型中若存在reshape类操作，reshape参数必须随动态进行计算（大部分时候这有问题） 除非全卷积网络，大部分时候只需要为batch_size维度设置为动态，其他维度避免设置动态 2.配置profile create: set: 设置, , 的一系列输入尺寸范围 add:添加profile到网络配置中 二、推理阶段 明确当前推理时，使用的数据输入大小
反卷积(conv_transpose) vs 卷积(convolution)详解
gbyy42299的博客
08-12 3705
一直对反卷机这个操作比较迷茫，在面试的过程中也经常被面试官问到反卷机的问题，所以就写这个博客简单的介绍一下反卷机的计算，并也卷积进行对比。 ...
ConvTranspose2d（逆卷积）的原理和计算
AI浩
02-09 1万+
原理 解释什么是逆卷积，先得明白什么是卷积。 先说卷积：对于一个图片A，设定它的高度和宽度分别为Height，Width，通道数为Channels。 然后我们用卷积核（kernel * kernel）去做卷积，（这里设定卷积核为正方形，实际长方形也可以类推，相信我，不会很难），步长为stride(同样的，不区分高宽方向)，做padding。卷积后得到B。 重复上面的话就是利用一个卷积操作将A变成B。 那么，在这个前提下，逆卷积就是将B变成A。 那么怎么规定卷积核这些参数呢，这些又是什么意思？ 对于
nn.ConvTranspose2d是啥？有什么用？
qq_46330706的博客
07-29 664
通过调整参数，可以对输出特征图的分辨率和通道数进行控制，以满足特定任务的需求。在创建转置卷积层时，需要指定输入通道数、输出通道数、转置卷积核大小、步长（上采样倍数）、填充等参数。它是用于定义转置卷积层的类之一。通过转置卷积操作，可以实现上采样或反卷积操作，将低分辨率特征图转换为高分辨率特征图。是 PyTorch 提供的一个模块，用于创建和管理转置卷积层，提供了丰富的参数来定义转置卷积层的行为和特性。类，它提供了创建和管理转置卷积层的功能。类，并传递相应的参数，可以创建一个转置卷积层对象。
pytorch 29 onnx多输入多输出模型（动态尺寸）转TensorRT模型并在python与C++下用TensorRT进行部署
a486259的博客
06-08 2125
实现将多输入多输出的onnx模型转TensorRT的格式，并用TensorRT的python api进行调用，最后实现C++的调用，python结果与C++结果一模一样。在此过程中实现了，动态尺寸，也就是可以在运行是按照数据情况动态调整模型的输入数据的格式。在这里以pytorch的多输入多输出模型为例，从模型构建到转化为onnx动态size、tensorrt安装、onnx转tensorRT动态size、tensorRT模型pytthon调用、tensorRT C++项目配置，最终到tensorRT模型C++
现代循环神经网络(GRU、LSTM)（Pytorch 14）
最新发布
March_A的博客
05-04 1398
现在我们将定义隐状态的初始化函数init_gru_state。定义的nit_rnn_state函数，此函数 返回一个形状为（批量大小，隐藏单元个数）的张量，张量的值全部为零。现在我们准备定义门控循环单元模型，模型的架构与基本的循环神经网络单元是相同的，只是权重更新公式 更为复杂。
动态卷积滤波器和动态卷积
10-12
动态卷积滤波器是指在卷积过程中，卷积核的权重是动态变化的，可以根据输入数据的不同部分自适应地调整权重。而动态卷积则是指在卷积过程中，卷积核的形状也是动态变化的，可以根据输入数据的不同部分自适应地调整...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值