chore: import upstream snapshot with attribution
Docker Image CI / build-ubuntu2004 (push) Waiting to run
Docker Image CI / build-ubuntu2004 (push) Waiting to run
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,529 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: Copyright (c) 1993-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
#include "nvFasterRCNNPlugin.h"
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
#include <string_view>
|
||||
|
||||
namespace nvinfer1::plugin
|
||||
{
|
||||
namespace
|
||||
{
|
||||
char const* const kRPROI_PLUGIN_VERSION{"1"};
|
||||
char const* const kRPROI_PLUGIN_NAME{"RPROI_TRT"};
|
||||
} // namespace
|
||||
|
||||
RPROIPlugin::RPROIPlugin(RPROIParams params, float const* anchorsRatios, float const* anchorsScales)
|
||||
: params(params)
|
||||
{
|
||||
/*
|
||||
* It only supports the scenario where params.featureStride == params.minBoxSize
|
||||
* assert(params.featureStride == params.minBoxSize);
|
||||
*/
|
||||
PLUGIN_VALIDATE(params.anchorsRatioCount > 0 && params.anchorsScaleCount > 0);
|
||||
anchorsRatiosHost = copyToHost(anchorsRatios, params.anchorsRatioCount);
|
||||
anchorsScalesHost = copyToHost(anchorsScales, params.anchorsScaleCount);
|
||||
|
||||
PLUGIN_CHECK(
|
||||
cudaMalloc((void**) &anchorsDev, 4 * params.anchorsRatioCount * params.anchorsScaleCount * sizeof(float)));
|
||||
pluginStatus_t status = generateAnchors(0, params.anchorsRatioCount, anchorsRatiosHost, params.anchorsScaleCount,
|
||||
anchorsScalesHost, params.featureStride, anchorsDev);
|
||||
PLUGIN_VALIDATE(status == STATUS_SUCCESS);
|
||||
|
||||
deviceSmemSize = getSmemSize();
|
||||
}
|
||||
|
||||
// Constructor for cloning one plugin instance to another
|
||||
RPROIPlugin::RPROIPlugin(RPROIParams params, float const* anchorsRatios, float const* anchorsScales, int32_t A,
|
||||
int32_t C, int32_t H, int32_t W, float const* _anchorsDev, size_t deviceSmemSize, DataType inFeatureType,
|
||||
DataType outFeatureType, DLayout_t inFeatureLayout)
|
||||
: deviceSmemSize(deviceSmemSize)
|
||||
, params(params)
|
||||
, A(A)
|
||||
, C(C)
|
||||
, H(H)
|
||||
, W(W)
|
||||
, inFeatureType(inFeatureType)
|
||||
, outFeatureType(outFeatureType)
|
||||
, inFeatureLayout(inFeatureLayout)
|
||||
{
|
||||
PLUGIN_VALIDATE(params.anchorsRatioCount > 0 && params.anchorsScaleCount > 0);
|
||||
anchorsRatiosHost = copyToHost(anchorsRatios, params.anchorsRatioCount);
|
||||
anchorsScalesHost = copyToHost(anchorsScales, params.anchorsScaleCount);
|
||||
|
||||
PLUGIN_CHECK(
|
||||
cudaMalloc((void**) &anchorsDev, 4 * params.anchorsRatioCount * params.anchorsScaleCount * sizeof(float)));
|
||||
// Perform deep copy
|
||||
if (_anchorsDev != nullptr)
|
||||
{
|
||||
PLUGIN_CHECK(cudaMemcpy(anchorsDev, _anchorsDev,
|
||||
4 * params.anchorsRatioCount * params.anchorsScaleCount * sizeof(float), cudaMemcpyDeviceToDevice));
|
||||
}
|
||||
}
|
||||
|
||||
RPROIPlugin::RPROIPlugin(void const* data, size_t length)
|
||||
{
|
||||
deserialize(static_cast<int8_t const*>(data), length);
|
||||
}
|
||||
|
||||
void RPROIPlugin::deserialize(int8_t const* data, size_t length)
|
||||
{
|
||||
auto const* d{data};
|
||||
params = *reinterpret_cast<RPROIParams const*>(d);
|
||||
d += sizeof(RPROIParams);
|
||||
A = read<int32_t>(d);
|
||||
C = read<int32_t>(d);
|
||||
H = read<int32_t>(d);
|
||||
W = read<int32_t>(d);
|
||||
inFeatureType = read<DataType>(d);
|
||||
outFeatureType = read<DataType>(d);
|
||||
inFeatureLayout = read<DLayout_t>(d);
|
||||
anchorsRatiosHost = copyToHost(d, params.anchorsRatioCount);
|
||||
d += params.anchorsRatioCount * sizeof(float);
|
||||
anchorsScalesHost = copyToHost(d, params.anchorsScaleCount);
|
||||
d += params.anchorsScaleCount * sizeof(float);
|
||||
PLUGIN_VALIDATE(d == data + length);
|
||||
|
||||
PLUGIN_CHECK(
|
||||
cudaMalloc((void**) &anchorsDev, 4 * params.anchorsRatioCount * params.anchorsScaleCount * sizeof(float)));
|
||||
pluginStatus_t status = generateAnchors(0, params.anchorsRatioCount, anchorsRatiosHost, params.anchorsScaleCount,
|
||||
anchorsScalesHost, params.featureStride, anchorsDev);
|
||||
PLUGIN_VALIDATE(status == STATUS_SUCCESS);
|
||||
|
||||
deviceSmemSize = getSmemSize();
|
||||
}
|
||||
|
||||
RPROIPlugin::~RPROIPlugin()
|
||||
{
|
||||
if (anchorsDev != nullptr)
|
||||
{
|
||||
PLUGIN_CHECK(cudaFree(anchorsDev));
|
||||
anchorsDev = nullptr;
|
||||
}
|
||||
if (anchorsRatiosHost != nullptr)
|
||||
{
|
||||
PLUGIN_CHECK(cudaFreeHost(anchorsRatiosHost));
|
||||
anchorsRatiosHost = nullptr;
|
||||
}
|
||||
if (anchorsScalesHost != nullptr)
|
||||
{
|
||||
PLUGIN_CHECK(cudaFreeHost(anchorsScalesHost));
|
||||
anchorsScalesHost = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RPROIPlugin::initialize() noexcept
|
||||
{
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
size_t RPROIPlugin::getSmemSize() const noexcept
|
||||
{
|
||||
int32_t devId{-1};
|
||||
PLUGIN_CHECK(cudaGetDevice(&devId));
|
||||
cudaDeviceProp prop{};
|
||||
PLUGIN_CHECK(cudaGetDeviceProperties(&prop, devId));
|
||||
return prop.sharedMemPerBlockOptin;
|
||||
}
|
||||
|
||||
int32_t RPROIPlugin::getNbOutputs() const noexcept
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
|
||||
Dims RPROIPlugin::getOutputDimensions(int32_t index, Dims const* inputs, int32_t nbInputDims) noexcept
|
||||
{
|
||||
PLUGIN_ASSERT(index >= 0 && index < 2);
|
||||
PLUGIN_ASSERT(nbInputDims == 4);
|
||||
PLUGIN_ASSERT(inputs[0].nbDims == 3 && inputs[1].nbDims == 3 && inputs[2].nbDims == 3 && inputs[3].nbDims == 3);
|
||||
if (index == 0) // rois
|
||||
{
|
||||
return Dims3(1, params.nmsMaxOut, 4);
|
||||
}
|
||||
// Feature map of each ROI after ROI Pooling
|
||||
// pool5
|
||||
return Dims4(params.nmsMaxOut, inputs[2].d[0], params.poolingH, params.poolingW);
|
||||
}
|
||||
|
||||
size_t RPROIPlugin::getWorkspaceSize(int32_t maxBatchSize) const noexcept
|
||||
{
|
||||
return RPROIInferenceFusedWorkspaceSize(maxBatchSize, A, H, W, params.nmsMaxOut);
|
||||
}
|
||||
|
||||
int32_t RPROIPlugin::enqueue(
|
||||
int32_t batchSize, void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept
|
||||
{
|
||||
// Bounding box (region proposal) objectness scores.
|
||||
void const* const scores = inputs[0];
|
||||
// Predicted bounding box offsets.
|
||||
void const* const deltas = inputs[1];
|
||||
// Feature map using for bounding box regression and classification.
|
||||
void const* const fmap = inputs[2];
|
||||
// Original image input information.
|
||||
void const* const iinfo = inputs[3];
|
||||
|
||||
// Coordinates of region of interest (ROI) bounding boxes on the original input image.
|
||||
void* rois = outputs[0];
|
||||
// ROI pooled feature map corresponding to the region of interest (ROI).
|
||||
void* pfmap = outputs[1];
|
||||
|
||||
pluginStatus_t status = RPROIInferenceFused(stream, batchSize, A, C, H, W, params.poolingH, params.poolingW,
|
||||
params.featureStride, params.preNmsTop, params.nmsMaxOut, params.iouThreshold, params.minBoxSize,
|
||||
params.spatialScale, (float const*) iinfo, this->anchorsDev, nvinfer1::DataType::kFLOAT, NCHW, scores,
|
||||
nvinfer1::DataType::kFLOAT, NCHW, deltas, inFeatureType, inFeatureLayout, fmap, workspace,
|
||||
nvinfer1::DataType::kFLOAT, rois, outFeatureType, NCHW, pfmap, deviceSmemSize);
|
||||
return status;
|
||||
}
|
||||
|
||||
size_t RPROIPlugin::getSerializationSize() const noexcept
|
||||
{
|
||||
size_t paramSize = sizeof(RPROIParams);
|
||||
size_t intSize = sizeof(int32_t) * 4;
|
||||
size_t ratiosSize = sizeof(float) * params.anchorsRatioCount;
|
||||
size_t scalesSize = sizeof(float) * params.anchorsScaleCount;
|
||||
size_t typeSize = sizeof(DataType) * 2;
|
||||
size_t layoutSize = sizeof(DLayout_t);
|
||||
return paramSize + intSize + ratiosSize + scalesSize + typeSize + layoutSize;
|
||||
}
|
||||
|
||||
void RPROIPlugin::serialize(void* buffer) const noexcept
|
||||
{
|
||||
char *d = reinterpret_cast<char*>(buffer), *a = d;
|
||||
*reinterpret_cast<RPROIParams*>(d) = params;
|
||||
d += sizeof(RPROIParams);
|
||||
*reinterpret_cast<int32_t*>(d) = A;
|
||||
d += sizeof(int32_t);
|
||||
*reinterpret_cast<int32_t*>(d) = C;
|
||||
d += sizeof(int32_t);
|
||||
*reinterpret_cast<int32_t*>(d) = H;
|
||||
d += sizeof(int32_t);
|
||||
*reinterpret_cast<int32_t*>(d) = W;
|
||||
d += sizeof(int32_t);
|
||||
*reinterpret_cast<DataType*>(d) = inFeatureType;
|
||||
d += sizeof(DataType);
|
||||
*reinterpret_cast<DataType*>(d) = outFeatureType;
|
||||
d += sizeof(DataType);
|
||||
*reinterpret_cast<DLayout_t*>(d) = inFeatureLayout;
|
||||
d += sizeof(DLayout_t);
|
||||
d += copyFromHost(d, anchorsRatiosHost, params.anchorsRatioCount);
|
||||
d += copyFromHost(d, anchorsScalesHost, params.anchorsScaleCount);
|
||||
PLUGIN_ASSERT(d == a + getSerializationSize());
|
||||
}
|
||||
|
||||
float* RPROIPlugin::copyToHost(void const* srcHostData, int32_t count) noexcept
|
||||
{
|
||||
float* dstHostPtr = nullptr;
|
||||
PLUGIN_CHECK(cudaMallocHost(&dstHostPtr, count * sizeof(float)));
|
||||
PLUGIN_CHECK(cudaMemcpy(dstHostPtr, srcHostData, count * sizeof(float), cudaMemcpyHostToHost));
|
||||
return dstHostPtr;
|
||||
}
|
||||
|
||||
int32_t RPROIPlugin::copyFromHost(char* dstHostBuffer, void const* source, int32_t count) const noexcept
|
||||
{
|
||||
PLUGIN_CHECK(cudaMemcpy(dstHostBuffer, source, count * sizeof(float), cudaMemcpyHostToHost));
|
||||
return count * sizeof(float);
|
||||
}
|
||||
|
||||
bool RPROIPlugin::supportsFormatCombination(
|
||||
int32_t pos, PluginTensorDesc const* inOut, int32_t nbInputs, int32_t nbOutputs) const noexcept
|
||||
{
|
||||
PLUGIN_ASSERT(nbInputs == PluginNbInputs && nbOutputs == PluginNbOutputs && pos < nbInputs + nbOutputs);
|
||||
bool isValidCombination = false;
|
||||
|
||||
// input: bbox confindence, bbox offset, image info and output: rois
|
||||
if (pos == 0 || pos == 1 || pos == 3 || pos == 4)
|
||||
{
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kLINEAR && inOut[pos].type == DataType::kFLOAT);
|
||||
}
|
||||
// input: feature map
|
||||
else if (pos == 2)
|
||||
{
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kLINEAR && inOut[pos].type == DataType::kINT8);
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kLINEAR && inOut[pos].type == DataType::kFLOAT);
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kCHW4 && inOut[pos].type == DataType::kINT8);
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kCHW32 && inOut[pos].type == DataType::kINT8);
|
||||
}
|
||||
// output: pooled feature map (data type should be the same with input feature map)
|
||||
else if (pos == 5)
|
||||
{
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kLINEAR && inOut[pos].type == DataType::kINT8);
|
||||
isValidCombination |= (inOut[pos].format == TensorFormat::kLINEAR && inOut[pos].type == DataType::kFLOAT);
|
||||
isValidCombination &= inOut[pos].type == inOut[2].type;
|
||||
}
|
||||
return isValidCombination;
|
||||
}
|
||||
|
||||
char const* RPROIPlugin::getPluginType() const noexcept
|
||||
{
|
||||
return kRPROI_PLUGIN_NAME;
|
||||
}
|
||||
|
||||
char const* RPROIPlugin::getPluginVersion() const noexcept
|
||||
{
|
||||
return kRPROI_PLUGIN_VERSION;
|
||||
}
|
||||
|
||||
void RPROIPlugin::terminate() noexcept {}
|
||||
|
||||
void RPROIPlugin::destroy() noexcept
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
|
||||
IPluginV2Ext* RPROIPlugin::clone() const noexcept
|
||||
{
|
||||
try
|
||||
{
|
||||
auto plugin = std::make_unique<RPROIPlugin>(params, anchorsRatiosHost, anchorsScalesHost, A, C, H, W,
|
||||
anchorsDev, deviceSmemSize, inFeatureType, outFeatureType, inFeatureLayout);
|
||||
plugin->setPluginNamespace(mPluginNamespace.c_str());
|
||||
return plugin.release();
|
||||
}
|
||||
catch (std::exception const& e)
|
||||
{
|
||||
caughtError(e);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Set plugin namespace
|
||||
void RPROIPlugin::setPluginNamespace(char const* pluginNamespace) noexcept
|
||||
{
|
||||
mPluginNamespace = pluginNamespace;
|
||||
}
|
||||
|
||||
char const* RPROIPlugin::getPluginNamespace() const noexcept
|
||||
{
|
||||
return mPluginNamespace.c_str();
|
||||
}
|
||||
|
||||
// Return the DataType of the plugin output at the requested index.
|
||||
DataType RPROIPlugin::getOutputDataType(
|
||||
int32_t index, nvinfer1::DataType const* inputTypes, int32_t nbInputs) const noexcept
|
||||
{
|
||||
// Two outputs
|
||||
PLUGIN_ASSERT(index == 0 || index == 1);
|
||||
return DataType::kFLOAT;
|
||||
}
|
||||
|
||||
DLayout_t RPROIPlugin::convertTensorFormat(TensorFormat const& srcFormat) const noexcept
|
||||
{
|
||||
PLUGIN_ASSERT(
|
||||
srcFormat == TensorFormat::kLINEAR || srcFormat == TensorFormat::kCHW4 || srcFormat == TensorFormat::kCHW32);
|
||||
switch (srcFormat)
|
||||
{
|
||||
case nvinfer1::TensorFormat::kLINEAR: return DLayout_t::NCHW;
|
||||
case nvinfer1::TensorFormat::kCHW4: return DLayout_t::NC4HW;
|
||||
case nvinfer1::TensorFormat::kCHW32: return DLayout_t::NC32HW;
|
||||
default: return DLayout_t::NCHW;
|
||||
}
|
||||
}
|
||||
|
||||
void RPROIPlugin::configurePlugin(
|
||||
PluginTensorDesc const* in, int32_t nbInput, PluginTensorDesc const* out, int32_t nbOutput) noexcept
|
||||
{
|
||||
PLUGIN_ASSERT(nbInput == PluginNbInputs);
|
||||
PLUGIN_ASSERT(nbOutput == PluginNbOutputs);
|
||||
|
||||
A = params.anchorsRatioCount * params.anchorsScaleCount;
|
||||
C = in[2].dims.d[0];
|
||||
H = in[2].dims.d[1];
|
||||
W = in[2].dims.d[2];
|
||||
inFeatureType = in[2].type;
|
||||
outFeatureType = out[1].type;
|
||||
inFeatureLayout = convertTensorFormat(in[2].format);
|
||||
|
||||
PLUGIN_ASSERT(in[0].dims.d[0] == (2 * A) && in[1].dims.d[0] == (4 * A));
|
||||
PLUGIN_ASSERT(in[0].dims.d[1] == in[1].dims.d[1] && in[0].dims.d[1] == in[2].dims.d[1]);
|
||||
PLUGIN_ASSERT(in[0].dims.d[2] == in[1].dims.d[2] && in[0].dims.d[2] == in[2].dims.d[2]);
|
||||
PLUGIN_ASSERT(out[0].dims.nbDims == 3 // rois
|
||||
&& out[1].dims.nbDims == 4); // pooled feature map
|
||||
PLUGIN_ASSERT(out[0].dims.d[0] == 1 && out[0].dims.d[1] == params.nmsMaxOut && out[0].dims.d[2] == 4);
|
||||
PLUGIN_ASSERT(out[1].dims.d[0] == params.nmsMaxOut && out[1].dims.d[1] == C && out[1].dims.d[2] == params.poolingH
|
||||
&& out[1].dims.d[3] == params.poolingW);
|
||||
}
|
||||
|
||||
// Attach the plugin object to an execution context and grant the plugin the access to some context resource.
|
||||
void RPROIPlugin::attachToContext(
|
||||
cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) noexcept
|
||||
{
|
||||
}
|
||||
|
||||
// Detach the plugin object from its execution context.
|
||||
void RPROIPlugin::detachFromContext() noexcept {}
|
||||
|
||||
RPROIPluginCreator::RPROIPluginCreator()
|
||||
{
|
||||
mPluginAttributes.clear();
|
||||
mPluginAttributes.emplace_back(PluginField("poolingH", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("poolingW", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("featureStride", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("preNmsTop", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("nmsMaxOut", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("anchorsRatioCount", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("anchorsScaleCount", nullptr, PluginFieldType::kINT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("iouThreshold", nullptr, PluginFieldType::kFLOAT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("minBoxSize", nullptr, PluginFieldType::kFLOAT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("spatialScale", nullptr, PluginFieldType::kFLOAT32, 1));
|
||||
|
||||
// TODO Do we need to pass the size attribute here for float arrarys, we
|
||||
// dont have that information at this point.
|
||||
mPluginAttributes.emplace_back(PluginField("anchorsRatios", nullptr, PluginFieldType::kFLOAT32, 1));
|
||||
mPluginAttributes.emplace_back(PluginField("anchorsScales", nullptr, PluginFieldType::kFLOAT32, 1));
|
||||
|
||||
mFC.nbFields = mPluginAttributes.size();
|
||||
mFC.fields = mPluginAttributes.data();
|
||||
}
|
||||
|
||||
RPROIPluginCreator::~RPROIPluginCreator()
|
||||
{
|
||||
// Free allocated memory (if any) here
|
||||
}
|
||||
|
||||
char const* RPROIPluginCreator::getPluginName() const noexcept
|
||||
{
|
||||
return kRPROI_PLUGIN_NAME;
|
||||
}
|
||||
|
||||
char const* RPROIPluginCreator::getPluginVersion() const noexcept
|
||||
{
|
||||
return kRPROI_PLUGIN_VERSION;
|
||||
}
|
||||
|
||||
PluginFieldCollection const* RPROIPluginCreator::getFieldNames() noexcept
|
||||
{
|
||||
return &mFC;
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(readability-function-cognitive-complexity)
|
||||
IPluginV2Ext* RPROIPluginCreator::createPlugin(char const* name, PluginFieldCollection const* fc) noexcept
|
||||
{
|
||||
try
|
||||
{
|
||||
using namespace std::string_view_literals;
|
||||
PluginField const* fields = fc->fields;
|
||||
int32_t nbFields = fc->nbFields;
|
||||
|
||||
for (int32_t i = 0; i < nbFields; ++i)
|
||||
{
|
||||
std::string_view const attrName = fields[i].name;
|
||||
if (attrName == "poolingH"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.poolingH = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "poolingW"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.poolingW = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "featureStride"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.featureStride = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "preNmsTop"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.preNmsTop = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "nmsMaxOut"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.nmsMaxOut = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "anchorsRatioCount"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.anchorsRatioCount = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "anchorsScaleCount"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kINT32);
|
||||
params.anchorsScaleCount = *(static_cast<int32_t const*>(fields[i].data));
|
||||
}
|
||||
if (attrName == "iouThreshold"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kFLOAT32);
|
||||
params.iouThreshold = static_cast<float>(*(static_cast<float const*>(fields[i].data)));
|
||||
}
|
||||
if (attrName == "minBoxSize"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kFLOAT32);
|
||||
params.minBoxSize = static_cast<float>(*(static_cast<float const*>(fields[i].data)));
|
||||
}
|
||||
if (attrName == "spatialScale"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kFLOAT32);
|
||||
params.spatialScale = static_cast<float>(*(static_cast<float const*>(fields[i].data)));
|
||||
}
|
||||
if (attrName == "anchorsRatios"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kFLOAT32);
|
||||
anchorsRatios.reserve(params.anchorsRatioCount);
|
||||
float const* ratios = static_cast<float const*>(fields[i].data);
|
||||
for (int32_t j = 0; j < params.anchorsRatioCount; ++j)
|
||||
{
|
||||
anchorsRatios.push_back(*ratios);
|
||||
ratios++;
|
||||
}
|
||||
}
|
||||
if (attrName == "anchorsScales"sv)
|
||||
{
|
||||
PLUGIN_VALIDATE(fields[i].type == PluginFieldType::kFLOAT32);
|
||||
anchorsScales.reserve(params.anchorsScaleCount);
|
||||
float const* scales = static_cast<float const*>(fields[i].data);
|
||||
for (int32_t j = 0; j < params.anchorsScaleCount; ++j)
|
||||
{
|
||||
anchorsScales.push_back(*scales);
|
||||
scales++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// This object will be deleted when the network is destroyed, which will
|
||||
// call RPROIPlugin::terminate()
|
||||
auto plugin = std::make_unique<RPROIPlugin>(params, anchorsRatios.data(), anchorsScales.data());
|
||||
plugin->setPluginNamespace(mNamespace.c_str());
|
||||
return plugin.release();
|
||||
}
|
||||
catch (std::exception const& e)
|
||||
{
|
||||
caughtError(e);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
IPluginV2Ext* RPROIPluginCreator::deserializePlugin(
|
||||
char const* name, void const* serialData, size_t serialLength) noexcept
|
||||
{
|
||||
try
|
||||
{
|
||||
// This object will be deleted when the network is destroyed, which will
|
||||
// call RPROIPlugin::terminate()
|
||||
auto plugin = std::make_unique<RPROIPlugin>(serialData, serialLength);
|
||||
plugin->setPluginNamespace(mNamespace.c_str());
|
||||
return plugin.release();
|
||||
}
|
||||
catch (std::exception const& e)
|
||||
{
|
||||
caughtError(e);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
} // namespace nvinfer1::plugin
|
||||
Reference in New Issue
Block a user