three_interpolate自定义tensorrt算子编写

最新推荐文章于 2025-12-07 21:21:31 发布
原创 最新推荐文章于 2025-12-07 21:21:31 发布 · 675 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#pytorch #onnx #tensorrt

部署运行你感兴趣的模型镜像

导出onnx模型

import torch
import numpy as np
import pointnet2_utils

    
class CustomModel(torch.nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        
    def forward(self, features, idx, weight):
        return tpointnet2_utils.three_interpolate(features, idx, weight) p
    
    
model = CustomModel().cuda()
features = torch.randn(1, 256, 256).cuda()  
idx = torch.randn(1, 512, 3).cuda().to(torch.int32)
weight = torch.randn(1, 512, 3).cuda()
np.savetxt("features.txt", features.reshape(256, 256).detach().cpu().numpy())
np.savetxt("idx.txt", idx.reshape(512, 3).detach().cpu().numpy())
np.savetxt("weight.txt", weight.reshape(512, 3).detach().cpu().numpy())

torch.onnx.export(model, (features, idx, weight), "three_interpolate.onnx", opset_version=13)

其中pointnet2_utils来自https://github.com/erikwijmans/Pointnet2_PyTorch。
导出onnx模型结构如下：在这里插入图片描述
在这里插入图片描述

编写tensorrt插件

采用TensorRT-10.6.0.26。由于TensorRT是部分开源，首先在https://developer.nvidia.com/tensorrt/download/10x下载TensorRT-10.6.0.26的库，然后在https://github.com/NVIDIA/TensorRT/tree/v10.6.0下载源代码。
在TensorRT/plugin下新建threeInterpolate文件夹，添加下面文件：
threeInterpolate.h

#ifndef TRT_THREE_INTERPOLATE_PLUGIN_H
#define TRT_THREE_INTERPOLATE_PLUGIN_H


#include "NvInfer.h"
#include "NvInferPlugin.h"
#include "common/plugin.h"
#include "common/cuda_utils.h"

#include <vector>
#include <cstring>

namespace nvinfer1
{
namespace plugin
{
void three_interpolate_kernel_wrapper(int b, int c, int m, int n,
                                      const float *points, const int *idx,
                                      const float *weight, float *out, cudaStream_t stream);

class ThreeInterpolate : public nvinfer1::IPluginV2DynamicExt 
{
public:
    ThreeInterpolate();

    ThreeInterpolate(void const* data, size_t length);

    ~ThreeInterpolate() override;

    // 插件基本信息
    char const* getPluginType() const noexcept override;
    char const* getPluginVersion() const noexcept override;
    int getNbOutputs() const noexcept override;

    // 输出维度计算
    nvinfer1::DimsExprs getOutputDimensions(int outputIndex,
		const nvinfer1::DimsExprs* inputs, int nbInputs, nvinfer1::IExprBuilder& exprBuilder) noexcept override;

    // 初始化与销毁
    int initialize() noexcept override;
    void terminate() noexcept override;

    // 执行相关
    int enqueue(const nvinfer1::PluginTensorDesc* inputDesc, const nvinfer1::PluginTensorDesc* outputDesc,
		const void* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept override;
    size_t getWorkspaceSize(const nvinfer1::PluginTensorDesc* inputs,
		int nbInputs, const nvinfer1::PluginTensorDesc* outputs,
		int nbOutputs) const noexcept override;

    // 数据类型与格式支持
    DataType getOutputDataType(int index, DataType const* inputTypes, int nbInputs) const noexcept override;
    bool supportsFormatCombination(int pos, const nvinfer1::PluginTensorDesc* inOut, int nbInputs,int nbOutputs) noexcept override;

    // 配置插件
    void configurePlugin(const  nvinfer1::DynamicPluginTensorDesc* in, int nbInputs,
		const  nvinfer1::DynamicPluginTensorDesc* out, int nbOutputs) noexcept override;

    // 序列化
    size_t getSerializationSize() const noexcept override;
    void serialize(void* buffer) const noexcept override;  

    // 其他接口
    nvinfer1::IPluginV2DynamicExt* clone() const noexcept override;
    void destroy() noexcept override;
    void setPluginNamespace(char const* libNamespace) noexcept override;
    char const* getPluginNamespace() const noexcept override;

private:
    std::string mPluginNamespace;
    Dims mInputDims;    // 点云输入维度 (B, N, 3)
    Dims mSampleDims;   // 采样点数输入维度（通常是标量或 (B,)）
};

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

    char const* getPluginName() const noexcept override;
    char const* getPluginVersion() const noexcept override;
    PluginFieldCollection const* getFieldNames() noexcept override;
    IPluginV2* createPlugin(char const* name, PluginFieldCollection const* fc) noexcept override;
    IPluginV2* deserializePlugin(char const* name, void const* serialData, size_t serialLength) noexcept override;
    void setPluginNamespace(nvinfer1::AsciiChar const* pluginNamespace) noexcept override;
	const char* getPluginNamespace() const noexcept override;

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

} // namespace plugin
} // namespace nvinfer1

#endif // TRT_THREE_INTERPOLATE_PLUGIN_H

threeInterpolate.cpp

#include "threeInterpolate.h"
#include "common/dimsHelpers.h"

using namespace nvinfer1;
using namespace nvinfer1::pluginInternal;
using nvinfer1::plugin::ThreeInterpolate;
using nvinfer1::plugin::ThreeInterpolateCreator;

// 插件实现
ThreeInterpolate::ThreeInterpolate()
{
    //std::cout<<"ThreeInterpolate"<<std::endl;
}

ThreeInterpolate::ThreeInterpolate(void const* data, size_t length) 
{

}

ThreeInterpolate::~ThreeInterpolate() {}

// 插件基本信息
char const* ThreeInterpolate::getPluginType() const noexcept 
{ 
    //std::cout<<"getPluginType"<<std::endl;
    return "three_interpolate"; 
}

char const* ThreeInterpolate::getPluginVersion() const noexcept 
{ 
    //std::cout<<"getPluginVersion"<<std::endl;
    return "1"; 
}

int ThreeInterpolate::getNbOutputs() const noexcept 
{ 
    //std::cout<<"getNbOutputs"<<std::endl;
    return 1; 
}

nvinfer1::DimsExprs ThreeInterpolate::getOutputDimensions(int outputIndex,
	const nvinfer1::DimsExprs* inputs, int nbInputs, nvinfer1::IExprBuilder& exprBuilder) noexcept 
{
    //std::cout << "getOutputDimensions" << std::endl;
    // 验证输出索引和输入数量
    PLUGIN_ASSERT(outputIndex == 0 && nbInputs == 3);
    
    nvinfer1::DimsExprs outputDims;
    outputDims.nbDims = 3;
    
    outputDims.d[0] = exprBuilder.constant(static_cast<int>(inputs[0].d[0]->getConstantValue()));
    outputDims.d[1] = exprBuilder.constant(static_cast<int>(inputs[0].d[1]->getConstantValue()));
    outputDims.d[2] = exprBuilder.constant(static_cast<int>(inputs[1].d[1]->getConstantValue()));
    return outputDims;
}

// 初始化
int ThreeInterpolate::initialize() noexcept 
{ 
    return STATUS_SUCCESS; 
}

// 销毁资源
void ThreeInterpolate::terminate() noexcept {}

// 执行核函数
int ThreeInterpolate::enqueue(const nvinfer1::PluginTensorDesc* inputDesc, const nvinfer1::PluginTensorDesc* outputDesc,
	const void* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept
{
    //std::cout << "enqueue" << std::endl;
    try 
    {
        // 输入维度校验
        PLUGIN_ASSERT(inputDesc[0].dims.nbDims == 3); 
        PLUGIN_ASSERT(inputDesc[1].dims.nbDims == 3);  
        PLUGIN_ASSERT(inputDesc[2].dims.nbDims == 3);  
        PLUGIN_ASSERT(outputDesc[0].dims.nbDims == 3); 

        // 数据类型校验
        PLUGIN_ASSERT(inputDesc[0].type == nvinfer1::DataType::kFLOAT);   
        PLUGIN_ASSERT(inputDesc[1].type == nvinfer1::DataType::kINT32);   
        PLUGIN_ASSERT(inputDesc[2].type == nvinfer1::DataType::kFLOAT);    
        PLUGIN_ASSERT(outputDesc[0].type == nvinfer1::DataType::kFLOAT);  

        // 提取维度信息
        int b = inputDesc[0].dims.d[0];  // 批次大小
        int c = inputDesc[0].dims.d[1];  // 特征通道数
        int m = inputDesc[0].dims.d[2];  // 原始点数量
        int n = inputDesc[1].dims.d[1];  // 插值后点数量

        // 验证维度有效性
        PLUGIN_ASSERT(b > 0 && c > 0 && m > 0 && n > 0);
        PLUGIN_ASSERT(inputDesc[1].dims.d[2] == 3);  // 每个目标点对应3个源点索引
        PLUGIN_ASSERT(inputDesc[2].dims.d[1] == n && inputDesc[2].dims.d[2] == 3);  // weight维度与idx匹配

        // 转换输入输出数据指针
        const float* points = static_cast<const float*>(inputs[0]);  // 源点特征 (B, C, M)
        const int* idx = static_cast<const int*>(inputs[1]);         // 索引 (B, N, 3)
        const float* weight = static_cast<const float*>(inputs[2]);  // 权重 (B, N, 3)
        float* out = static_cast<float*>(outputs[0]);                // 输出特征 (B, C, N)
        
        // 调用CUDA核函数包装器执行插值计算
        three_interpolate_kernel_wrapper(b, c, m, n, points, idx, weight,out, stream);

        return STATUS_SUCCESS;
    } 
    catch (std::exception const& e) 
    {
        caughtError(e);
    }
    return -1;
}

// 工作空间大小
size_t ThreeInterpolate::getWorkspaceSize(const nvinfer1::PluginTensorDesc* inputs,
		int nbInputs, const nvinfer1::PluginTensorDesc* outputs,
		int nbOutputs) const noexcept 
{ 
    return 0;
}

// 输出数据类型：索引为INT32
DataType ThreeInterpolate::getOutputDataType(int index, DataType const* inputTypes, int nbInputs) const noexcept 
{
    //std::cout<<"getOutputDataType"<<std::endl;  
    PLUGIN_ASSERT(index == 0 && nbInputs == 3);
    return DataType::kFLOAT;
}

// 支持的格式：输入float32，输出int32，均为线性格式
bool ThreeInterpolate::supportsFormatCombination(int pos, const nvinfer1::PluginTensorDesc* inOut, int nbInputs, int nbOutputs) noexcept
{
    //std::cout << "supportsFormatCombination" << std::endl;
    PLUGIN_ASSERT(pos < nbInputs + nbOutputs);

    if (pos == 0)
    {
        return (inOut[pos].type == nvinfer1::DataType::kFLOAT) 
            && (inOut[pos].format == nvinfer1::PluginFormat::kLINEAR);
    }
    else if (pos == 1)
    {
        return (inOut[pos].type == nvinfer1::DataType::kINT32) 
            && (inOut[pos].format == nvinfer1::PluginFormat::kLINEAR);
    }
    else if (pos == 2)
    {
        return (inOut[pos].type == nvinfer1::DataType::kFLOAT) 
            && (inOut[pos].format == nvinfer1::PluginFormat::kLINEAR);
    }
    else if (pos == 3)
    {
        return (inOut[pos].type == nvinfer1::DataType::kFLOAT) 
            && (inOut[pos].format == nvinfer1::PluginFormat::kLINEAR);
    }

    return false;
}

void ThreeInterpolate::configurePlugin(const nvinfer1::DynamicPluginTensorDesc* in, int nbInputs,
		const nvinfer1::DynamicPluginTensorDesc* out, int nbOutputs) noexcept
{
    //std::cout<<"configurePlugin"<<std::endl;
    try 
    {
        PLUGIN_ASSERT(nbInputs == 3 && nbOutputs == 1); // 确认3个输入和1个输出
    } 
    catch (std::exception const& e) 
    {
        caughtError(e);
    }
}

// 序列化：仅需保存采样点数
size_t ThreeInterpolate::getSerializationSize() const noexcept 
{ 
    //std::cout<<"getSerializationSize"<<std::endl;
    return 0 ; 
}

void ThreeInterpolate::serialize(void* buffer) const noexcept 
{

}

// 克隆插件
nvinfer1::IPluginV2DynamicExt* ThreeInterpolate::clone() const noexcept 
{
    //std::cout<<"clone"<<std::endl;
    try
    {
        return new ThreeInterpolate();
    }
    catch (std::exception const& e)
    {
        caughtError(e);
    }
    return nullptr;
}

void ThreeInterpolate::destroy() noexcept 
{ 
    delete this; 
}

// 命名空间管理
void ThreeInterpolate::setPluginNamespace(char const* pluginNamespace) noexcept 
{ 
    //std::cout<<"setPluginNamespace"<<std::endl;
    try
    {
        mPluginNamespace = pluginNamespace;
    }
    catch (std::exception const& e)
    {
        caughtError(e);
    }
}

char const* ThreeInterpolate::getPluginNamespace() const noexcept 
{ 
    //std::cout<<"getPluginNamespace"<<std::endl;
    return mPluginNamespace.c_str(); 
}

// 插件创建器实现
PluginFieldCollection ThreeInterpolateCreator::mFC{};
std::vector<PluginField> ThreeInterpolateCreator::mPluginAttributes;

ThreeInterpolateCreator::ThreeInterpolateCreator() 
{
    //std::cout<<"ThreeInterpolateCreator"<<std::endl;
    mPluginAttributes.clear();
    mFC.nbFields = mPluginAttributes.size();
    mFC.nbFields = mPluginAttributes.size();
    mFC.fields = mPluginAttributes.data();
}

char const* ThreeInterpolateCreator::getPluginName() const noexcept 
{ 
    //std::cout<<"getPluginName"<<std::endl;
    return "three_interpolate"; 
}

char const* ThreeInterpolateCreator::getPluginVersion() const noexcept 
{ 
    //std::cout<<"getPluginVersion"<<std::endl;
    return "1"; 
}

PluginFieldCollection const* ThreeInterpolateCreator::getFieldNames() noexcept 
{ 
    //std::cout<<"getFieldNames"<<std::endl;
    return &mFC; 
}

IPluginV2* ThreeInterpolateCreator::createPlugin(char const* name, PluginFieldCollection const* fc) noexcept 
{
    //std::cout<<"createPlugin"<<std::endl;
    try 
    {
        return new ThreeInterpolate();
    }
    catch (std::exception const& e) 
    {
        caughtError(e);
    }
    return nullptr;
}

IPluginV2* ThreeInterpolateCreator::deserializePlugin(char const* name, void const* serialData, size_t serialLength) noexcept 
{
    //std::cout<<"deserializePlugin"<<std::endl;
    try
    {
        // This object will be deleted when the network is destroyed, which will
        // call Concat::destroy()
        IPluginV2Ext* plugin = new ThreeInterpolate();
        plugin->setPluginNamespace(mNamespace.c_str());
        return plugin;
    }
    catch (std::exception const& e)
    {
        caughtError(e);
    }
    return nullptr;
}

void ThreeInterpolateCreator::setPluginNamespace(char const* libNamespace) noexcept
{  
	//std::cout<<"setPluginNamespace"<<std::endl;        
	mNamespace = libNamespace;
}

char const* ThreeInterpolateCreator::getPluginNamespace() const noexcept
{    
	//std::cout<<"getPluginNamespace"<<std::endl;      
	return mNamespace.c_str();
}

threeInterpolate.cu

#include <stdio.h>
#include <stdlib.h>

#include "NvInfer.h"
#include "threeInterpolate.h"
#include <cuda_runtime.h>

namespace nvinfer1
{
namespace plugin
{

// input: points(b, c, m), idx(b, n, 3), weight(b, n, 3)
// output: out(b, c, n)
__global__ void three_interpolate_kernel(int b, int c, int m, int n,
                                         const float *__restrict__ points,
                                         const int *__restrict__ idx,
                                         const float *__restrict__ weight,
                                         float *__restrict__ out) {
  int batch_index = blockIdx.x;
  points += batch_index * m * c;

  idx += batch_index * n * 3;
  weight += batch_index * n * 3;

  out += batch_index * n * c;

  const int index = threadIdx.y * blockDim.x + threadIdx.x;
  const int stride = blockDim.y * blockDim.x;
  for (int i = index; i < c * n; i += stride) {
    const int l = i / n;
    const int j = i % n;
    float w1 = weight[j * 3 + 0];
    float w2 = weight[j * 3 + 1];
    float w3 = weight[j * 3 + 2];

    int i1 = idx[j * 3 + 0];
    int i2 = idx[j * 3 + 1];
    int i3 = idx[j * 3 + 2];

    out[i] = points[l * m + i1] * w1 + points[l * m + i2] * w2 +
             points[l * m + i3] * w3;
  }
}

void three_interpolate_kernel_wrapper(int b, int c, int m, int n,
                                      const float *points, const int *idx,
                                      const float *weight, float *out, cudaStream_t stream) {
  three_interpolate_kernel<<<b, opt_block_config(n, c), 0, stream>>>(
      b, c, m, n, points, idx, weight, out);

  CUDA_CHECK_ERRORS();
}

}
}

CMakeLists.txt

file(GLOB SRCS *.cpp)
set(PLUGIN_SOURCES ${PLUGIN_SOURCES} ${SRCS})
set(PLUGIN_SOURCES ${PLUGIN_SOURCES} PARENT_SCOPE)
file(GLOB CU_SRCS *.cu)
set(PLUGIN_CU_SOURCES ${PLUGIN_CU_SOURCES} ${CU_SRCS})
set(PLUGIN_CU_SOURCES ${PLUGIN_CU_SOURCES} PARENT_SCOPE)

在TensorRT/plugin/inferPlugin.cpp的开头添加

#include "threeInterpolate/threeInterpolate.h"

并在initLibNvInferPlugins函数中添加

initializePlugin<nvinfer1::plugin::ThreeInterpolateCreator>(logger, libNamespace);

在TensorRT/plugin/CMakeLists.txt的set(PLUGIN_LISTS添加

threeInterpolate

在TensorRT/CMakeLists.txt中设置TRT_LIB_DIR、TRT_OUT_DIR，再重新编译tensorrt。

tensorrt推理测试

运行下面的命令把onnx 转为engine模型：

TensorRT-10.6.0.26/bin/trtexec --onnx=three_interpolate.onnx --saveEngine=three_interpolate.engine

编写python推理脚本：

import numpy as np
import tensorrt as trt
import common


logger = trt.Logger(trt.Logger.WARNING)
trt.init_libnvinfer_plugins(logger, "")
with open("three_interpolate.engine", "rb") as f, trt.Runtime(logger) as runtime:
    engine = runtime.deserialize_cuda_engine(f.read())
context = engine.create_execution_context()
inputs, outputs, bindings, stream = common.allocate_buffers(engine)

features = np.loadtxt("features.txt").reshape(1, 256, 256).astype(np.float32)
idx = np.loadtxt("idx.txt").reshape(1, 512, 3).astype(np.int32)
weight = np.loadtxt("weight.txt").reshape(1, 512, 3).astype(np.float32)
np.copyto(inputs[0].host, features.ravel())
np.copyto(inputs[1].host, idx.ravel())
np.copyto(inputs[2].host, weight.ravel())

output = common.do_inference(context,engine=engine, bindings=bindings, inputs=inputs, outputs=outputs, stream=stream)
print(output[0].reshape(1, 256, 512))
np.savetxt("output[0].txt", output[0].reshape(256, 512))

您可能感兴趣的与本文相关的镜像

PyTorch 2.5

PyTorch 2.5

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

添加动态resize的TensorRT算子
qq_35435798的博客
04-01 458
添加动态resize的TensorRT算子
boost::geometry::line_interpolate用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-02 613
boost::geometry::line_interpolate用法的测试程序实现功能C++实现代码 实现功能 boost::geometry::line_interpolate用法的测试程序 C++实现代码 #include <geometry_test_common.hpp> #include <boost/geometry.hpp> #include <boost/geometry/geometries/geometries.hpp> #include <b
onnx入门教程（七）——如何添加 TensorRT 自定义算子
图像学习之旅
08-26 1022
在前面的模型入门系列文章中，我们介绍了部署一个 PyTorch 模型到推理后端，如 ONNXRuntime，这其中可能遇到很多工程性的问题。有些可以通过创建 ONNX 节点来解决，该节点仍然使用后端原生的实现进行推理。而有些无法导出到后端的算法，可以通过重写代码改变算法的实现过程，同样可以导出到 ONNX ，达到一致的效果。以上两种方式一般可以处理绝大多数的部署问题，同时也不需要向推理框架引入新的内容，是我们进行模型部署时候的优先选择。
小白科研笔记：理解PointNet++中的three_interpolate前向计算和反向求导
Niuip的博客
04-17 2502
1. 前言 处于科研需要，我需要理解PointNet++中的Interpolated (propogated) features，即特征插值计算过程（如果不需要当然就不去理解它啦）。它如SA-SSD论文中的公式所示： 它在代码中的实现如下所示： # known 表示已知点的位置信息 [m,4] # known_feats 表示已知点的特征信息 [m,C] # unknown 表示需要插值点的位置...
模型部署入门教程（八）：如何添加 TensorRT 自定义算子
qq_39967751的博客
08-19 4527
本篇教程我们主要讲述如何在 MMDeploy 代码库中添加一个自定义的 TensorRT 插件，整个过程不涉及太多更复杂的 CUDA 编程，相信小伙伴们学完可以自己实现想要的插件
【模型部署】入门教程（八）：如何添加 TensorRT 自定义算子
qq_43456016的博客
04-20 1407
本篇教程我们主要讲述如何在 MMDeploy 代码库中添加一个自定义的 TensorRT 插件，整个过程不涉及太多更复杂的 CUDA 编程，相信小伙伴们学完可以自己实现想要的插件。至此，我们的模型部署入门系列教程已经更新了八期，那到这里可能就先暂时告一段落啦！所有跟模型部署相关的内容，都整理在这个专栏啦，欢迎大家关注~模型部署那些事​www.zhihu.com/column/c_1497987564452114432正在上传…重新上传取消。
【机器视觉】 dev_set_part算子
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师、鸿蒙讲师---欢迎大家一起交流(私信添加博主微信)
06-19 1690
00. 目录 文章目录00. 目录01. 概述02. 签名03. 描述04. 注意05. 参数06. 结果07. 附录 01. 概述 dev_set_part - 修改要显示的图像部分。 02. 签名 dev_set_part( : : Row1, Column1, Row2, Column2 : ) 03. 描述 dev_set_part用于设置图形窗口中要显示的图像部分。 参数Row1和Column1指定左上角，Row2和Column2指定要显示的图像部分的右下角。 有关更多信息，请参阅算子set_pa
pytorch自定义算子导出onnx
MAX的专栏
11-20 1715
1、没有现成可用的算子，需要根据自己的接口重写。2、现有的算子接口不兼容，需要在原有的算子上进行封装。继承类，实现其forward()和backward()方法,就可以成为一个pytorch自定义算子。就可以在模型训练推理中完成前向推理和反向传播。forward() 函数的第一个参数必须是ctx, 后面是输出。在工程部署上，一般为了加快计算，自定义算子需要用cuda 实现forward()、backward（）kernel 函数。实现其symbolic 静态方法。
初步认识torch自定义算子
微凉的博客
10-13 1457
此篇为的代码详解这篇是为了展示setup在构建简单的cpp算子的使用。
graspnet模型tensorrt推理部署
taifyang的博客
09-27 455
本文介绍了对GraspNet代码库的修改过程，主要包括两部分：基础环境适配和ONNX模型导出。首先针对CUDA和PyTorch版本问题，修改了import语句和删除了冗余代码。其次为支持ONNX导出，对模型结构进行了调整，包括修改GraspNet类的前向传播逻辑、修正池化操作参数类型，以及重构pointnet2工具库。这些修改使代码能够兼容不同环境并支持模型导出，同时参考了相关部署指南确保正常运行。修改后的代码保留了原始功能，同时增加了模型转换的灵活性。
第 11 号算子集）不支持在插值中设置动态的放缩系数。这个系数对应 torch.onnx.symbolic_helper._interpolate_helper的symbolic_fn的 Resize 算子映射关系中的哪个参数？我们是如何修改这一参数的？
07-22
这里主要涉及的是`torch.onnx.symbolic_helper._interpolate_helper`函数中的`Resize`算子映射关系。 ### 1. Resize算子动态放缩系数参数 在ONNX的`Resize`算子中，控制放缩的参数主要有两个： - `scales`：一个...
使用householder反射推广ROPE相对位置编码
LYF1993的博客
12-04 166
的值只与相对位置有关，每个反射向量必按照某个二维平面均匀分布。假设该二维平面的单位正交基为m和n。有明确的几何意义，为在u和v所张成的二维平面上旋转，旋转角度为u和v的夹角。对向量a和b，分别使用u和v进行householder反射，得到。其中m和n是可学习参数。则a'和b'的向量内积为。
云主机GPU pyTorch部署
宝安小雨
12-02 263
直接装最新稳定版（当前是 2.5.0，支持 CUDA 11.8 和 12.1，T4 完美支持）这样安装的三个都是GPU版本。
【ML|DL |python|pytorch|】基础学习
十二_的博客
12-03 821
本文介绍了Anaconda环境配置与PyTorch基础操作。主要内容包括：1）使用conda检查和管理Python、PyTorch等环境；2）创建/删除conda环境的技巧；3）PyTorch张量(tensor)的基本创建方法(ones_like, rand等)和属性(dtype, shape等)；4）关键张量操作函数(is_tensor, numel, cat等)的用法，重点讲解了torch.cat()在不同维度拼接三维张量的原理和效果。文章通过代码示例和形象比喻(如"千层饼"、&qu
PyTorch：深度学习研究的核心引擎（下）
最新发布
宁静致远
12-07 123
介绍了PyTorch的生态系统与扩展能力、应用场景与社区生态等。
PyTorch：深度学习研究的核心引擎（上）
宁静致远
12-07 316
简单介绍了深度学习框架pytorch的一些核心特性。
PyTorch DDP分布式训练Pytorch代码讲解
Younai2021的博客
12-05 920
if is_ddp:# 开始 DDP 时用了 init_process_group# 结束 DDP 时要调用 destroy_process_group。
[免费]基于Python的车辆车牌识别系统（PyTorch2卷积神经网络CNN+OpenCV实现）【论文+源码+SQL脚本】
java1234的博客
12-04 2502
[免费]基于Python的车辆车牌识别系统（PyTorch2卷积神经网络CNN+OpenCV实现）【论文+源码+SQL脚本】
CNN计算|原始矩阵扩充后的多维度卷积核计算效果
专注python+工程实践的热心婶子
12-02 405
本文探讨了在多通道卷积计算中结合原始矩阵扩充的方法。首先介绍了3通道5×5输入矩阵和3×3卷积核的基本计算过程，通过三层循环实现多通道卷积运算。然后演示了如何使用torch.zeros对原始矩阵进行外圈0值扩充，保持输入输出尺寸一致。最后将扩充后的矩阵应用于相同的卷积计算流程，验证了扩充方法的有效性。文章提供了完整的Python实现代码，展示了从基本卷积到带扩充卷积的计算过程，为理解卷积神经网络中的padding操作提供了实践参考。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

给算法爸爸上香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值