opencv自定义深度学习层官方实例解析笔记

╰+哭是因爲堅強的太久メ 2021-11-08 16:00 289阅读 0赞

环境 Windows，visual studio 15，opencv3.4.2，c++

## 1、代码地址 ##

[https://docs.opencv.org/3.4.2/dc/db1/tutorial\_dnn\_custom\_layers.html][https_docs.opencv.org_3.4.2_dc_db1_tutorial_dnn_custom_layers.html]

## 2、自定义层 ##

类名称就是层的名称

class InterpLayer : public cv::dnn::Layer
    //新层是Layer基类的派生类

类方法

public：
    InterpLayer(const cv::dnn::LayerParams &params) : Layer(params){} 
    //读取层当中输入的参数
    static cv::Ptr<cv::dnn::Layer> create(cv::dnn::LayerParams& params){}
    //创建层
    virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs,
    		const int requiredOutputs,
    		std::vector<std::vector<int> > &outputs,
    		std::vector<std::vector<int> > &internals) const CV_OVERRIDE{}
    //定义输出数据的形状
    virtual void forward(std::vector<cv::Mat*> &inputs, std::vector<cv::Mat> &outputs, std::vector<cv::Mat> &internals) CV_OVERRIDE{}
    //层当中的主要执行过程卸载这里
    virtual void forward(cv::InputArrayOfArrays, cv::OutputArrayOfArrays, cv::OutputArrayOfArrays) CV_OVERRIDE {}
    //Layer基类当中的纯虚拟函数，如果不写上去的话会一直提醒你，新建层是一个抽象类

## getMemoryShapes函数理解 ##

virtual bool getMemoryShapes(const std::vector<std::vector<int> > &inputs,
    		const int requiredOutputs,
    		std::vector<std::vector<int> > &outputs,
    		std::vector<std::vector<int> > &internals) const CV_OVERRIDE
    	{
    		CV_UNUSED(requiredOutputs); CV_UNUSED(internals);
    		std::vector<int> outShape(4); 
    		outShape[0] = inputs[0][0];  // batch size
    		outShape[1] = inputs[0][1];  // number of channels
    		outShape[2] = outHeight;
    		outShape[3] = outWidth;
    		outputs.assign(1, outShape);
    		return false;
    	}

输入参数

const std::vector<std::vector<int> > &inputs
    //首先是一个二维数组，类型为int，
    //然后是一个引用类型，就是给第一个输入参数去了一个别称叫做inputs
    //最后是一个常量，将指针指向的对象设置为常量，全局化

//一共涉及到四个参数
    const std::vector<std::vector<int> > &inputs,//这个参数获取的是层的bottom值，是当前层的输入
    const int requiredOutputs,                   //
    std::vector<std::vector<int> > &outputs,     //这个参数表示的是层的top值，是当前层的输出
    std::vector<std::vector<int> > &internals    //

函数声明

const CV_OVERRIDE
    //OVERRIDE时，函数声明必须完全不变，否则报错。
    //在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误。

具体过程

std::vector<int> outShape(4); //创建一个长度为4的数组
    // 在mnist里面输入的input大小是[1,1,28,28]
    outShape[0] = inputs[0][0];  // batch size
    outShape[1] = inputs[0][1];  // number of channels
    outShape[2] = outHeight;     
    outShape[3] = outWidth;
    outputs.assign(1, outShape); //将outShape复制给outputs[1,1,8,9]

## forward层 ##

virtual void forward(std::vector<cv::Mat*> &inputs, std::vector<cv::Mat> &outputs, std::vector<cv::Mat> &internals) CV_OVERRIDE
    	{
    		CV_UNUSED(internals);
    		cv::Mat& inp = *inputs[0];
    		cv::Mat& out = outputs[0];
    		const float* inpData = (float*)inp.data;
    		float* outData = (float*)out.data;
    		const int batchSize = inp.size[0];
    		const int numChannels = inp.size[1];
    		const int inpHeight = inp.size[2];
    		const int inpWidth = inp.size[3];
    		const float rheight = (outHeight > 1) ? static_cast<float>(inpHeight - 1) / (outHeight - 1) : 0.f;
    		const float rwidth = (outWidth > 1) ? static_cast<float>(inpWidth - 1) / (outWidth - 1) : 0.f;
    		for (int h2 = 0; h2 < outHeight; ++h2)
    		{
    			const float h1r = rheight * h2;
    			const int h1 = static_cast<int>(h1r);
    			const int h1p = (h1 < inpHeight - 1) ? 1 : 0;
    			const float h1lambda = h1r - h1;
    			const float h0lambda = 1.f - h1lambda;
    			for (int w2 = 0; w2 < outWidth; ++w2)
    			{
    				const float w1r = rwidth * w2;
    				const int w1 = static_cast<int>(w1r);
    				const int w1p = (w1 < inpWidth - 1) ? 1 : 0;
    				const float w1lambda = w1r - w1;
    				const float w0lambda = 1.f - w1lambda;
    				const float* pos1 = inpData + h1 * inpWidth + w1;
    				float* pos2 = outData + h2 * outWidth + w2;
    				for (int c = 0; c < batchSize * numChannels; ++c)
    				{
    					pos2[0] =
    						h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p]) +
    						h1lambda * (w0lambda * pos1[h1p * inpWidth] + w1lambda * pos1[h1p * inpWidth + w1p]);
    					pos1 += inpWidth * inpHeight;
    					pos2 += outWidth * outHeight;
    				}
    			}
    		}
    	}

输入参数

std::vector<cv::Mat*> &inputs, 
    //首先是个一维数组
    //然后数组类型是Mat*，Mat是矩阵，Mat*是矩阵的指针，所以这个应该是一个矩阵指针的列表
    //最后& 引用就是给输入的第一个参数去一个新的名字叫input
    
    std::vector<cv::Mat> &output, 
    //首先是个一维数组
    //然后数组类型是Mat，Mat是矩阵，所以这是一个个矩阵的列表
    //最后& 引用就是给输入的第二个参数去一个新的名字叫output

指向Mat的指针数组的测试

#include "stdafx.h"
    #include <opencv2/opencv.hpp>
    #include<iostream>
    #include<vector>
    using namespace cv;
    using namespace std;
    
    int main()
    {
    	Mat C(2, 2, CV_32FC3, Scalar()); //声明一个2*2*3的Mat，实际上大小是2*6
    	cout << "C = " << endl << " " << C << endl << endl;
    
    	int kk = 0;
    	//给Mat赋值
    	for (int i = 0; i<2; i++)
    	{
    		for (int j = 0; j<6; j++)
    		{
    			C.at<float>(i, j) = kk;  //方法1
    			C.ptr<float>(i)[j] = kk; //方法2
    			kk = kk + 1;
    		}
    	}
    
    	cout << "C = " << endl << " " << C << endl << endl;
    
    	vector<Mat*> B; //声明一个Mat的指针数组
    	Mat* pimage = &C; //pimage里面保存Mat C的地址
    					  //通过指针pimage查看Mat C
    	cout << "指针 = " << endl << " " << pimage << endl << endl;
    	cout << "*指针 = " << endl << " " << *pimage << endl << endl;
    
    	B.push_back(pimage);//将pimgage指针放入数组B中
    						//通过B查看Mat C
    	cout << B.size() << endl;
    	cout << "数组指针 = " << endl << " " << B[0] << endl << endl;
    	cout << "*数组指针 = " << endl << " " << *B[0] << endl << endl;
    
    	vector<Mat> A; //声明一个Mat的数组
    
    
    	A.push_back(C);//将Mat C放到数组中
    				   //通过B查看Mat C
    	cout << A.size() << endl;
    	cout << "BC = " << endl << " " << A[0] << endl << endl;
    
    	return 0;
    }

![20190806165902834.png][]

过程

CV_UNUSED(internals);
    cv::Mat& inp = *inputs[0]; 
    //读取数组里面第一个Mat的地址，并通过地址获取Mat的值，然后使用引用名称inp指向该Mat
    //因为inp是一个引用，所以指向的输入数据的地址还是原来的输入，如果inp发生改变，那么在系统中的输入数据会相应的发生改变
    cv::Mat& out = outputs[0];
    //读取数组里面第一个Mat，然后将引用名称out指向该Mat
    const float* inpData = (float*)inp.data;
    //(float*)inp.data表示指向Mat的第一个数据地址的指针
    // inpData是一个指向Mat第一个数据地址的指针，*inpData是Mat第一个数据的值
    float* outData = (float*)out.data;
    const int batchSize = inp.size[0]; //获取输入Mat的四个维度
    const int numChannels = inp.size[1];
    const int inpHeight = inp.size[2];
    const int inpWidth = inp.size[3];
    const float rheight = (outHeight > 1) ? static_cast<float>(inpHeight - 1) / (outHeight - 1) : 0.f;
    //因为outHeight是类中的声明参数，所以可以在类方法中直接使用
    //如果outHeight大于1，就输出(inpHeight - 1) / (outHeight - 1)
    //否则输出0
    //static_cast是一个强制类型转换符
    const float rwidth = (outWidth > 1) ? static_cast<float>(inpWidth - 1) / (outWidth - 1) : 0.f;
    for (int h2 = 0; h2 < outHeight; ++h2)
    {
    	const float h1r = rheight * h2;
    	const int h1 = static_cast<int>(h1r);
    	const int h1p = (h1 < inpHeight - 1) ? 1 : 0;
    	const float h1lambda = h1r - h1;
    	const float h0lambda = 1.f - h1lambda;
    	for (int w2 = 0; w2 < outWidth; ++w2)
    	{
    		const float w1r = rwidth * w2;
    		const int w1 = static_cast<int>(w1r);
    		const int w1p = (w1 < inpWidth - 1) ? 1 : 0;
    		const float w1lambda = w1r - w1;
    		const float w0lambda = 1.f - w1lambda;
    		const float* pos1 = inpData + h1 * inpWidth + w1;
            //inpData是一个地址，在地址上做计算，pos1指向另一个地址的数据
    		float* pos2 = outData + h2 * outWidth + w2;
    		for (int c = 0; c < batchSize * numChannels; ++c)
    		{
    			pos2[0] =
    				h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p]) +
    				h1lambda * (w0lambda * pos1[h1p * inpWidth] + w1lambda * pos1[h1p *             inpWidth + w1p]);
    			pos1 += inpWidth * inpHeight;
    			pos2 += outWidth * outHeight;
    		}
        }
    }

[https_docs.opencv.org_3.4.2_dc_db1_tutorial_dnn_custom_layers.html]: https://docs.opencv.org/3.4.2/dc/db1/tutorial_dnn_custom_layers.html
[20190806165902834.png]: /images/20211108/3d4014b8296c42b28854732bf9a6971e.png