Merge pull request #679 from rajeevsrao/dev/gridAnchorRect

rajeevsrao · web-flow · commit ead9e8b48a23 · 2020-07-11T19:12:49.000-07:00
Re-enable GridAnchorRect_TRT plugin with rectangular feature maps
diff --git a/plugin/InferPlugin.cpp b/plugin/InferPlugin.cpp
@@ -157,6 +157,7 @@ extern "C" {
 bool initLibNvInferPlugins(void* logger, const char* libNamespace)
 {
     initializePlugin<nvinfer1::plugin::GridAnchorPluginCreator>(logger, libNamespace);
+    initializePlugin<nvinfer1::plugin::GridAnchorRectPluginCreator>(logger, libNamespace);
     initializePlugin<nvinfer1::plugin::NMSPluginCreator>(logger, libNamespace);
     initializePlugin<nvinfer1::plugin::ReorgPluginCreator>(logger, libNamespace);
     initializePlugin<nvinfer1::plugin::RegionPluginCreator>(logger, libNamespace);
diff --git a/plugin/README.md b/plugin/README.md
@@ -16,6 +16,7 @@
 | [geluPlugin](geluPlugin) | CustomGeluPluginDynamic | 1 |
 | [generateDetectionPlugin](generateDetectionPlugin) | GenerateDetection_TRT | 1 |
 | [gridAnchorPlugin](gridAnchorPlugin) | GridAnchor_TRT | 1 |
+| [gridAnchorRectPlugin](gridAnchorPlugin) | GridAnchorRect_TRT | 1 |
 | [groupNormalizationPlugin](groupNormalizationPlugin) | GroupNormalizationPlugin | 1 |
 | [instanceNormalizationPlugin](instanceNormalizationPlugin) | InstanceNormalization_TRT | 1 |
 | [multilevelCropAndResizePlugin](multilevelCropAndResizePlugin) | MultilevelCropAndResize_TRT | 1 |
diff --git a/plugin/common/kernels/gridAnchorLayer.cu b/plugin/common/kernels/gridAnchorLayer.cu
@@ -19,105 +19,73 @@
 
 using nvinfer1::plugin::reduced_divisor;
 template <unsigned nthdsPerCTA>
-        __launch_bounds__(nthdsPerCTA)
-        __global__ void gridAnchorKernel(
-                const GridAnchorParameters param,
-                const int numAspectRatios,
-                reduced_divisor divObj,
-                const float* widths,
-                const float* heights,
-                float* outputData
-                )
-        {
-            // output dims: (H, W, param.numMinSize, (1+haveMaxSize+numAR-1), 4)
-            const int dim = param.H * param.W * numAspectRatios;
-            /*
-             * Parameters used to calculate the bounding box coordinates back to input image scale
-             * Normally we calculate the anchorStride = image_input_size (in pixel) / feature_map_size
-             * Here we do not use image_input_size for the moment
-             * Instead we use 1.0
-             * The coordinates calculated are scaled by the input image size. 
-             * Most of the coordinates will be in a range of [0, 1], except for the bounding box coordinates going outside of the image
-             * Every coordinate will go back to the pixel coordinates in the input image if being multiplied by image_input_size
-             * Here we implicitly assumes the image input and feature map are square
-             */
-            float anchorStride = (1.0 / param.H);
-            float anchorOffset = 0.5 * anchorStride;
+__launch_bounds__(nthdsPerCTA)
+__global__ void gridAnchorKernel(
+    const GridAnchorParameters param,
+    const int numAspectRatios,
+    reduced_divisor divObj,
+    const float* widths,
+    const float* heights,
+    float* outputData
+    )
+{
+    // output dims: (H, W, param.numMinSize, (1+haveMaxSize+numAR-1), 4)
+    const int dim = param.H * param.W * numAspectRatios;
 
-            int tid = blockIdx.x * blockDim.x + threadIdx.x;
-            if (tid >= dim)
-                return;
-            int arId, currIndex;
-            divObj.divmod(tid, currIndex, arId);
+    /*
+     * Parameters used to calculate the bounding box coordinates back to input image scale
+     * Normally we calculate the anchorStride = image_input_size (in pixel) / feature_map_size
+     * Here we do not use image_input_size for the moment
+     * Instead we use 1.0
+     * The coordinates calculated are scaled by the input image size.
+     * Most of the coordinates will be in a range of [0, 1], except for the bounding box coordinates going outside of the image
+     * Every coordinate will go back to the pixel coordinates in the input image if being multiplied by image_input_size
+     * Here we implicitly assumes the image input and feature map are square
+     */
+    float anchorStrideH = (1.0 / param.H);
+    float anchorStrideW = (1.0 / param.W);
+    float anchorOffsetH = 0.5 * anchorStrideH;
+    float anchorOffsetW = 0.5 * anchorStrideW;
 
-            const int w = currIndex % param.W;
-            const int h = currIndex / param.W;
-            
-            // Center coordinates
-            float yC = h * anchorStride + anchorOffset;
-            float xC = w * anchorStride + anchorOffset;
-            
-            // x_min, y_min
-            float xMin = xC - 0.5 * widths[arId];
-            float yMin = yC - 0.5 * heights[arId];
+    int tid = blockIdx.x * blockDim.x + threadIdx.x;
+    if (tid >= dim)
+    {
+        return;
+    }
 
-            // x_max, y_max
-            float xMax = xC + 0.5 * widths[arId];
-            float yMax = yC + 0.5 * heights[arId];
+    int arId, currIndex;
+    divObj.divmod(tid, currIndex, arId);
 
-            outputData[tid * 4] = xMin;
-            outputData[tid * 4 + 1] = yMin;
-            outputData[tid * 4 + 2] = xMax;
-            outputData[tid * 4 + 3] = yMax;
+    const int w = currIndex % param.W;
+    const int h = currIndex / param.W;
 
-            // Remember to move the output cursor
-            float* output = outputData + dim * 4;
+    // Center coordinates
+    float yC = h * anchorStrideH + anchorOffsetH;
+    float xC = w * anchorStrideW + anchorOffsetW;
 
-            // Simply copying the variance
-            output[tid * 4] = param.variance[0];
-            output[tid * 4 + 1] = param.variance[1];
-            output[tid * 4 + 2] = param.variance[2];
-            output[tid * 4 + 3] = param.variance[3];
+    // x_min, y_min
+    float xMin = xC - 0.5 * widths[arId];
+    float yMin = yC - 0.5 * heights[arId];
 
-        }
+    // x_max, y_max
+    float xMax = xC + 0.5 * widths[arId];
+    float yMax = yC + 0.5 * heights[arId];
 
-pluginStatus_t anchorGridInference(
-        cudaStream_t stream,
-        const GridAnchorParameters param,
-        const int numAspectRatios,
-        const void* widths,
-        const void* heights,
-        void* outputData
-        )
-{
-    const int dim = param.H * param.W * numAspectRatios;
-    reduced_divisor divObj(numAspectRatios);
-    if (dim > 5120)
-    {
-        const int BS = 128;
-        const int GS = (dim + BS - 1) / BS;
-        gridAnchorKernel<BS><<<GS, BS, 0, stream>>>(param, numAspectRatios, divObj,
-                (const float*) widths, (const float*) heights,
-                (float*) outputData);
+    outputData[tid * 4] = xMin;
+    outputData[tid * 4 + 1] = yMin;
+    outputData[tid * 4 + 2] = xMax;
+    outputData[tid * 4 + 3] = yMax;
 
-    }
-    else
-    {
-        const int BS = 32;
-        const int GS = (dim + BS - 1) / BS;
-        gridAnchorKernel<BS><<<GS, BS, 0, stream>>>(param, numAspectRatios, divObj,
-                (const float*) widths, (const float*) heights,
-                (float*) outputData);
+    // Remember to move the output cursor
+    float* output = outputData + dim * 4;
 
-    }
-    CSC(cudaGetLastError(), STATUS_FAILURE);
-    return STATUS_SUCCESS;
+    // Simply copying the variance
+    output[tid * 4] = param.variance[0];
+    output[tid * 4 + 1] = param.variance[1];
+    output[tid * 4 + 2] = param.variance[2];
+    output[tid * 4 + 3] = param.variance[3];
 }
 
-namespace nvinfer1
-{
-namespace plugin
-{
 pluginStatus_t anchorGridInference(
     cudaStream_t stream,
     const GridAnchorParameters param,
@@ -134,22 +102,19 @@ pluginStatus_t anchorGridInference(
         const int BS = 128;
         const int GS = (dim + BS - 1) / BS;
         gridAnchorKernel<BS><<<GS, BS, 0, stream>>>(param, numAspectRatios, divObj,
-                (const float*) widths, (const float*) heights,
-                (float*) outputData);
+            (const float*) widths, (const float*) heights,
+            (float*) outputData);
 
     }
     else
     {
         const int BS = 32;
         const int GS = (dim + BS - 1) / BS;
         gridAnchorKernel<BS><<<GS, BS, 0, stream>>>(param, numAspectRatios, divObj,
-                (const float*) widths, (const float*) heights,
-                (float*) outputData);
-
+            (const float*) widths, (const float*) heights,
+            (float*) outputData);
     }
     CSC(cudaGetLastError(), STATUS_FAILURE);
     return STATUS_SUCCESS;
 }
 
-}
-}
diff --git a/plugin/gridAnchorPlugin/gridAnchorPlugin.cpp b/plugin/gridAnchorPlugin/gridAnchorPlugin.cpp
@@ -22,19 +22,18 @@
 #include <vector>
 
 using namespace nvinfer1;
-using nvinfer1::plugin::GridAnchorGenerator;
-using nvinfer1::plugin::GridAnchorPluginCreator;
 
 namespace
 {
-const char* GRID_ANCHOR_PLUGIN_VERSION{"1"};
-const char* GRID_ANCHOR_PLUGIN_NAME{"GridAnchor_TRT"};
+std::string GRID_ANCHOR_PLUGIN_NAMES[] = {"GridAnchor_TRT", "GridAnchorRect_TRT"};
+const char* GRID_ANCHOR_PLUGIN_VERSION = "1";
 } // namespace
-PluginFieldCollection GridAnchorPluginCreator::mFC{};
-std::vector<PluginField> GridAnchorPluginCreator::mPluginAttributes;
 
-GridAnchorGenerator::GridAnchorGenerator(const GridAnchorParameters* paramIn, int mNumLayers)
-    : mNumLayers(mNumLayers)
+PluginFieldCollection GridAnchorBasePluginCreator::mFC{};
+std::vector<PluginField> GridAnchorBasePluginCreator::mPluginAttributes;
+
+GridAnchorGenerator::GridAnchorGenerator(const GridAnchorParameters* paramIn, int numLayers, const char *name)
+    : mNumLayers(numLayers), mPluginName(name)
 {
     CUASSERT(cudaMallocHost((void**) &mNumPriors, mNumLayers * sizeof(int)));
     CUASSERT(cudaMallocHost((void**) &mDeviceWidths, mNumLayers * sizeof(Weights)));
@@ -121,7 +120,8 @@ GridAnchorGenerator::GridAnchorGenerator(const GridAnchorParameters* paramIn, in
     }
 }
 
-GridAnchorGenerator::GridAnchorGenerator(const void* data, size_t length)
+GridAnchorGenerator::GridAnchorGenerator(const void* data, size_t length, const char *name) :
+    mPluginName(name)
 {
     const char *d = reinterpret_cast<const char*>(data), *a = d;
     mNumLayers = read<int>(d);
@@ -276,14 +276,15 @@ bool GridAnchorGenerator::supportsFormat(DataType type, PluginFormat format) con
 
 const char* GridAnchorGenerator::getPluginType() const
 {
-    return GRID_ANCHOR_PLUGIN_NAME;
+    return mPluginName.c_str();
 }
 
 const char* GridAnchorGenerator::getPluginVersion() const
 {
     return GRID_ANCHOR_PLUGIN_VERSION;
 }
 
+
 // Set plugin namespace
 void GridAnchorGenerator::setPluginNamespace(const char* pluginNamespace)
 {
@@ -341,12 +342,12 @@ void GridAnchorGenerator::destroy()
 
 IPluginV2Ext* GridAnchorGenerator::clone() const
 {
-    IPluginV2Ext* plugin = new GridAnchorGenerator(mParam.data(), mNumLayers);
+    IPluginV2Ext* plugin = new GridAnchorGenerator(mParam.data(), mNumLayers, mPluginName.c_str());
     plugin->setPluginNamespace(mPluginNamespace.c_str());
     return plugin;
 }
 
-GridAnchorPluginCreator::GridAnchorPluginCreator()
+GridAnchorBasePluginCreator::GridAnchorBasePluginCreator()
 {
     mPluginAttributes.emplace_back(PluginField("minSize", nullptr, PluginFieldType::kFLOAT32, 1));
     mPluginAttributes.emplace_back(PluginField("maxSize", nullptr, PluginFieldType::kFLOAT32, 1));
@@ -359,29 +360,31 @@ GridAnchorPluginCreator::GridAnchorPluginCreator()
     mFC.fields = mPluginAttributes.data();
 }
 
-const char* GridAnchorPluginCreator::getPluginName() const
+const char* GridAnchorBasePluginCreator::getPluginName() const
 {
-    return GRID_ANCHOR_PLUGIN_NAME;
+    return mPluginName.c_str();
 }
 
-const char* GridAnchorPluginCreator::getPluginVersion() const
+const char* GridAnchorBasePluginCreator::getPluginVersion() const
 {
     return GRID_ANCHOR_PLUGIN_VERSION;
 }
 
-const PluginFieldCollection* GridAnchorPluginCreator::getFieldNames()
+const PluginFieldCollection* GridAnchorBasePluginCreator::getFieldNames()
 {
     return &mFC;
 }
 
-IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const PluginFieldCollection* fc)
+IPluginV2Ext* GridAnchorBasePluginCreator::createPlugin(const char* name, const PluginFieldCollection* fc)
 {
     float minScale = 0.2F, maxScale = 0.95F;
     int numLayers = 6;
     std::vector<float> aspectRatios;
     std::vector<int> fMapShapes;
     std::vector<float> layerVariances;
     const PluginField* fields = fc->fields;
+
+    const bool isFMapRect = (GRID_ANCHOR_PLUGIN_NAMES[1] == mPluginName);
     for (int i = 0; i < fc->nbFields; ++i)
     {
         const char* attrName = fields[i].name;
@@ -428,6 +431,7 @@ IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const Plug
         {
             ASSERT(fields[i].type == PluginFieldType::kINT32);
             int size = fields[i].length;
+            ASSERT(!isFMapRect || (size % 2 == 0));
             fMapShapes.reserve(size);
             const int* fMap = static_cast<const int*>(fields[i].data);
             for (int j = 0; j < size; j++)
@@ -442,7 +446,8 @@ IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const Plug
     std::vector<float> firstLayerAspectRatios;
 
     ASSERT(numLayers > 0);
-    ASSERT((int) fMapShapes.size() == numLayers);
+    const int numExpectedLayers = static_cast<int>(fMapShapes.size()) >> (isFMapRect ? 1 : 0);
+    ASSERT(numExpectedLayers == numLayers);
 
     int numFirstLayerARs = 3;
     // First layer only has the first 3 aspect ratios from aspectRatios
@@ -457,30 +462,42 @@ IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const Plug
     // One set of box parameters for one layer
     for (int i = 0; i < numLayers; i++)
     {
+        int hOffset = (isFMapRect ? i * 2 : i);
+        int wOffset = (isFMapRect ? i * 2 + 1 : i);
         // Only the first layer is different
         if (i == 0)
         {
             boxParams[i] = {minScale, maxScale, firstLayerAspectRatios.data(), (int) firstLayerAspectRatios.size(),
-                fMapShapes[i], fMapShapes[i],
+                fMapShapes[hOffset], fMapShapes[wOffset],
                 {layerVariances[0], layerVariances[1], layerVariances[2], layerVariances[3]}};
         }
         else
         {
-            boxParams[i] = {minScale, maxScale, aspectRatios.data(), (int) aspectRatios.size(), fMapShapes[i],
-                fMapShapes[i], {layerVariances[0], layerVariances[1], layerVariances[2], layerVariances[3]}};
+            boxParams[i] = {minScale, maxScale, aspectRatios.data(), (int) aspectRatios.size(), fMapShapes[hOffset],
+                fMapShapes[wOffset], {layerVariances[0], layerVariances[1], layerVariances[2], layerVariances[3]}};
         }
     }
 
-    GridAnchorGenerator* obj = new GridAnchorGenerator(boxParams.data(), numLayers);
+    GridAnchorGenerator* obj = new GridAnchorGenerator(boxParams.data(), numLayers, mPluginName.c_str());
     obj->setPluginNamespace(mNamespace.c_str());
     return obj;
 }
 
-IPluginV2Ext* GridAnchorPluginCreator::deserializePlugin(const char* name, const void* serialData, size_t serialLength)
+IPluginV2Ext* GridAnchorBasePluginCreator::deserializePlugin(const char* name, const void* serialData, size_t serialLength)
 {
     // This object will be deleted when the network is destroyed, which will
     // call GridAnchor::destroy()
-    GridAnchorGenerator* obj = new GridAnchorGenerator(serialData, serialLength);
+    GridAnchorGenerator* obj = new GridAnchorGenerator(serialData, serialLength, mPluginName.c_str());
     obj->setPluginNamespace(mNamespace.c_str());
     return obj;
 }
+
+GridAnchorPluginCreator::GridAnchorPluginCreator()
+{
+    mPluginName = GRID_ANCHOR_PLUGIN_NAMES[0];
+}
+
+GridAnchorRectPluginCreator::GridAnchorRectPluginCreator()
+{
+    mPluginName = GRID_ANCHOR_PLUGIN_NAMES[1];
+}
diff --git a/plugin/gridAnchorPlugin/gridAnchorPlugin.h b/plugin/gridAnchorPlugin/gridAnchorPlugin.h
diff --git a/samples/opensource/sampleUffSSD/README.md b/samples/opensource/sampleUffSSD/README.md

Original file line number	Diff line number	Diff line change
`@@ -157,6 +157,7 @@ extern "C" {`
`157`	`157`	`bool initLibNvInferPlugins(void* logger, const char* libNamespace)`
`158`	`158`	`{`
`159`	`159`	`initializePlugin<nvinfer1::plugin::GridAnchorPluginCreator>(logger, libNamespace);`
	`160`	`+ initializePlugin<nvinfer1::plugin::GridAnchorRectPluginCreator>(logger, libNamespace);`
`160`	`161`	`initializePlugin<nvinfer1::plugin::NMSPluginCreator>(logger, libNamespace);`
`161`	`162`	`initializePlugin<nvinfer1::plugin::ReorgPluginCreator>(logger, libNamespace);`
`162`	`163`	`initializePlugin<nvinfer1::plugin::RegionPluginCreator>(logger, libNamespace);`
Original file line number	Diff line number	Diff line change
`@@ -22,19 +22,18 @@`
`22`	`22`	`#include <vector>`
`23`	`23`
`24`	`24`	`using namespace nvinfer1;`
`25`		`-using nvinfer1::plugin::GridAnchorGenerator;`
`26`		`-using nvinfer1::plugin::GridAnchorPluginCreator;`
`27`	`25`
`28`	`26`	`namespace`
`29`	`27`	`{`
`30`		`-const char* GRID_ANCHOR_PLUGIN_VERSION{"1"};`
`31`		`-const char* GRID_ANCHOR_PLUGIN_NAME{"GridAnchor_TRT"};`
	`28`	`+std::string GRID_ANCHOR_PLUGIN_NAMES[] = {"GridAnchor_TRT", "GridAnchorRect_TRT"};`
	`29`	`+const char* GRID_ANCHOR_PLUGIN_VERSION = "1";`
`32`	`30`	`} // namespace`
`33`		`-PluginFieldCollection GridAnchorPluginCreator::mFC{};`
`34`		`-std::vector<PluginField> GridAnchorPluginCreator::mPluginAttributes;`
`35`	`31`
`36`		`-GridAnchorGenerator::GridAnchorGenerator(const GridAnchorParameters* paramIn, int mNumLayers)`
`37`		`- : mNumLayers(mNumLayers)`
	`32`	`+PluginFieldCollection GridAnchorBasePluginCreator::mFC{};`
	`33`	`+std::vector<PluginField> GridAnchorBasePluginCreator::mPluginAttributes;`
	`34`	`+`
	`35`	`+GridAnchorGenerator::GridAnchorGenerator(const GridAnchorParameters* paramIn, int numLayers, const char *name)`
	`36`	`+ : mNumLayers(numLayers), mPluginName(name)`
`38`	`37`	`{`
`39`	`38`	`CUASSERT(cudaMallocHost((void*) &mNumPriors, mNumLayers sizeof(int)));`
`40`	`39`	`CUASSERT(cudaMallocHost((void*) &mDeviceWidths, mNumLayers sizeof(Weights)));`
`@@ -121,7 +120,8 @@ GridAnchorGenerator::GridAnchorGenerator(const GridAnchorParameters* paramIn, in`
`121`	`120`	`}`
`122`	`121`	`}`
`123`	`122`
`124`		`-GridAnchorGenerator::GridAnchorGenerator(const void* data, size_t length)`
	`123`	`+GridAnchorGenerator::GridAnchorGenerator(const void* data, size_t length, const char *name) :`
	`124`	`+ mPluginName(name)`
`125`	`125`	`{`
`126`	`126`	`const char d = reinterpret_cast<const char>(data), *a = d;`
`127`	`127`	`mNumLayers = read<int>(d);`
`@@ -276,14 +276,15 @@ bool GridAnchorGenerator::supportsFormat(DataType type, PluginFormat format) con`
`276`	`276`
`277`	`277`	`const char* GridAnchorGenerator::getPluginType() const`
`278`	`278`	`{`
`279`		`- return GRID_ANCHOR_PLUGIN_NAME;`
	`279`	`+ return mPluginName.c_str();`
`280`	`280`	`}`
`281`	`281`
`282`	`282`	`const char* GridAnchorGenerator::getPluginVersion() const`
`283`	`283`	`{`
`284`	`284`	`return GRID_ANCHOR_PLUGIN_VERSION;`
`285`	`285`	`}`
`286`	`286`
	`287`	`+`
`287`	`288`	`// Set plugin namespace`
`288`	`289`	`void GridAnchorGenerator::setPluginNamespace(const char* pluginNamespace)`
`289`	`290`	`{`
`@@ -341,12 +342,12 @@ void GridAnchorGenerator::destroy()`
`341`	`342`
`342`	`343`	`IPluginV2Ext* GridAnchorGenerator::clone() const`
`343`	`344`	`{`
`344`		`- IPluginV2Ext* plugin = new GridAnchorGenerator(mParam.data(), mNumLayers);`
	`345`	`+ IPluginV2Ext* plugin = new GridAnchorGenerator(mParam.data(), mNumLayers, mPluginName.c_str());`
`345`	`346`	`plugin->setPluginNamespace(mPluginNamespace.c_str());`
`346`	`347`	`return plugin;`
`347`	`348`	`}`
`348`	`349`
`349`		`-GridAnchorPluginCreator::GridAnchorPluginCreator()`
	`350`	`+GridAnchorBasePluginCreator::GridAnchorBasePluginCreator()`
`350`	`351`	`{`
`351`	`352`	`mPluginAttributes.emplace_back(PluginField("minSize", nullptr, PluginFieldType::kFLOAT32, 1));`
`352`	`353`	`mPluginAttributes.emplace_back(PluginField("maxSize", nullptr, PluginFieldType::kFLOAT32, 1));`
`@@ -359,29 +360,31 @@ GridAnchorPluginCreator::GridAnchorPluginCreator()`
`359`	`360`	`mFC.fields = mPluginAttributes.data();`
`360`	`361`	`}`
`361`	`362`
`362`		`-const char* GridAnchorPluginCreator::getPluginName() const`
	`363`	`+const char* GridAnchorBasePluginCreator::getPluginName() const`
`363`	`364`	`{`
`364`		`- return GRID_ANCHOR_PLUGIN_NAME;`
	`365`	`+ return mPluginName.c_str();`
`365`	`366`	`}`
`366`	`367`
`367`		`-const char* GridAnchorPluginCreator::getPluginVersion() const`
	`368`	`+const char* GridAnchorBasePluginCreator::getPluginVersion() const`
`368`	`369`	`{`
`369`	`370`	`return GRID_ANCHOR_PLUGIN_VERSION;`
`370`	`371`	`}`
`371`	`372`
`372`		`-const PluginFieldCollection* GridAnchorPluginCreator::getFieldNames()`
	`373`	`+const PluginFieldCollection* GridAnchorBasePluginCreator::getFieldNames()`
`373`	`374`	`{`
`374`	`375`	`return &mFC;`
`375`	`376`	`}`
`376`	`377`
`377`		`-IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const PluginFieldCollection* fc)`
	`378`	`+IPluginV2Ext* GridAnchorBasePluginCreator::createPlugin(const char* name, const PluginFieldCollection* fc)`
`378`	`379`	`{`
`379`	`380`	`float minScale = 0.2F, maxScale = 0.95F;`
`380`	`381`	`int numLayers = 6;`
`381`	`382`	`std::vector<float> aspectRatios;`
`382`	`383`	`std::vector<int> fMapShapes;`
`383`	`384`	`std::vector<float> layerVariances;`
`384`	`385`	`const PluginField* fields = fc->fields;`
	`386`	`+`
	`387`	`+ const bool isFMapRect = (GRID_ANCHOR_PLUGIN_NAMES[1] == mPluginName);`
`385`	`388`	`for (int i = 0; i < fc->nbFields; ++i)`
`386`	`389`	`{`
`387`	`390`	`const char* attrName = fields[i].name;`
`@@ -428,6 +431,7 @@ IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const Plug`
`428`	`431`	`{`
`429`	`432`	`ASSERT(fields[i].type == PluginFieldType::kINT32);`
`430`	`433`	`int size = fields[i].length;`
	`434`	`+ ASSERT(!isFMapRect \|\| (size % 2 == 0));`
`431`	`435`	`fMapShapes.reserve(size);`
`432`	`436`	`const int* fMap = static_cast<const int*>(fields[i].data);`
`433`	`437`	`for (int j = 0; j < size; j++)`
`@@ -442,7 +446,8 @@ IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const Plug`
`442`	`446`	`std::vector<float> firstLayerAspectRatios;`
`443`	`447`
`444`	`448`	`ASSERT(numLayers > 0);`
`445`		`- ASSERT((int) fMapShapes.size() == numLayers);`
	`449`	`+ const int numExpectedLayers = static_cast<int>(fMapShapes.size()) >> (isFMapRect ? 1 : 0);`
	`450`	`+ ASSERT(numExpectedLayers == numLayers);`
`446`	`451`
`447`	`452`	`int numFirstLayerARs = 3;`
`448`	`453`	`// First layer only has the first 3 aspect ratios from aspectRatios`
`@@ -457,30 +462,42 @@ IPluginV2Ext* GridAnchorPluginCreator::createPlugin(const char* name, const Plug`
`457`	`462`	`// One set of box parameters for one layer`
`458`	`463`	`for (int i = 0; i < numLayers; i++)`
`459`	`464`	`{`
	`465`	`+ int hOffset = (isFMapRect ? i * 2 : i);`
	`466`	`+ int wOffset = (isFMapRect ? i * 2 + 1 : i);`
`460`	`467`	`// Only the first layer is different`
`461`	`468`	`if (i == 0)`
`462`	`469`	`{`
`463`	`470`	`boxParams[i] = {minScale, maxScale, firstLayerAspectRatios.data(), (int) firstLayerAspectRatios.size(),`
`464`		`- fMapShapes[i], fMapShapes[i],`
	`471`	`+ fMapShapes[hOffset], fMapShapes[wOffset],`
`465`	`472`	`{layerVariances[0], layerVariances[1], layerVariances[2], layerVariances[3]}};`
`466`	`473`	`}`
`467`	`474`	`else`
`468`	`475`	`{`
`469`		`- boxParams[i] = {minScale, maxScale, aspectRatios.data(), (int) aspectRatios.size(), fMapShapes[i],`
`470`		`- fMapShapes[i], {layerVariances[0], layerVariances[1], layerVariances[2], layerVariances[3]}};`
	`476`	`+ boxParams[i] = {minScale, maxScale, aspectRatios.data(), (int) aspectRatios.size(), fMapShapes[hOffset],`
	`477`	`+ fMapShapes[wOffset], {layerVariances[0], layerVariances[1], layerVariances[2], layerVariances[3]}};`
`471`	`478`	`}`
`472`	`479`	`}`
`473`	`480`
`474`		`- GridAnchorGenerator* obj = new GridAnchorGenerator(boxParams.data(), numLayers);`
	`481`	`+ GridAnchorGenerator* obj = new GridAnchorGenerator(boxParams.data(), numLayers, mPluginName.c_str());`
`475`	`482`	`obj->setPluginNamespace(mNamespace.c_str());`
`476`	`483`	`return obj;`
`477`	`484`	`}`
`478`	`485`
`479`		`-IPluginV2Ext* GridAnchorPluginCreator::deserializePlugin(const char* name, const void* serialData, size_t serialLength)`
	`486`	`+IPluginV2Ext* GridAnchorBasePluginCreator::deserializePlugin(const char* name, const void* serialData, size_t serialLength)`
`480`	`487`	`{`
`481`	`488`	`// This object will be deleted when the network is destroyed, which will`
`482`	`489`	`// call GridAnchor::destroy()`
`483`		`- GridAnchorGenerator* obj = new GridAnchorGenerator(serialData, serialLength);`
	`490`	`+ GridAnchorGenerator* obj = new GridAnchorGenerator(serialData, serialLength, mPluginName.c_str());`
`484`	`491`	`obj->setPluginNamespace(mNamespace.c_str());`
`485`	`492`	`return obj;`
`486`	`493`	`}`
	`494`	`+`
	`495`	`+GridAnchorPluginCreator::GridAnchorPluginCreator()`
	`496`	`+{`
	`497`	`+ mPluginName = GRID_ANCHOR_PLUGIN_NAMES[0];`
	`498`	`+}`
	`499`	`+`
	`500`	`+GridAnchorRectPluginCreator::GridAnchorRectPluginCreator()`
	`501`	`+{`
	`502`	`+ mPluginName = GRID_ANCHOR_PLUGIN_NAMES[1];`
	`503`	`+}`