纯C++超分辨率重建LapSRN --改编--（一）数据和框架
程序员文章站
2022-03-09 13:06:31
...
由于网络上找不到多通道多核的转置卷积，那么只能从matconvnet入手了,先用LapSRN 8倍的，它的层数小一点（放大一个2倍差不多8层 3x8=24,实际上是25层，只要8，9层就可以出现一个2倍放大图，其它2倍的20多层，4倍的40多层 ）
先说一下流程
1。从matlab中导出LapSRN数据（网络权重（卷积核）和偏置，按用到的顺序导出，所以在我们的程序中不需要排列核位置）
2。从文本文件中导入结构中
3。外框架和 LapSRN 函数（几乎和matlab中一样）
4。然后就是三个函数vl_nnconv(正向卷积)，vl_nnconvt（反向）,vl_nnrelu（激励）
vl_nnrelu比较简单，其它的围绕vl_nnconv 和vl_nnconvt 展开（也就是对matconvnet中的代码涂涂改改）。
现在开始：
1。导出LapSRN 8倍网络数据到 LapSRN_x8.txt 文件中
%% 参数
scale = 8; % SR 采样比例 可以是 2、4 或 8 倍
%% 加载预训练模型
model_filename = fullfile('pretrained_models', sprintf('LapSRN_x%d.mat', scale));
fprintf('载入 %s\n', model_filename);
net = load(model_filename);
net=net.net;
l=length(net.layers);
%
%
j=0;
%
upsample_num=0;% 图像放大计数
residual_num=0;% 残差图计数
%保存模型数据
%偏移
%---------------------------------------
FID=fopen('LapSRN_x8.txt','w');
%所有层
for i=1:l %42 是上采样层
issave=0;
disp(['第 ',num2str(i),' 层']);
if strTong(net.layers(i).type,'dagnn.Conv')
j=j+1
disp('卷积层');
%得到权重（也就是卷积核）和偏移
disp('参数是：');
disp(net.layers(i).params);
fft=net.layers(i).params{1};
for k=1:length(net.params)
if strTong(net.params(k).name,fft)
weight=net.params(k).value;
break;
end
end
if net.layers(i).block.hasBias==false
bias=[]; % 无偏移
else
fft=net.layers(i).params{2};
for k=1:length(net.params)
if strTong(net.params(k).name,fft)
bias=net.params(k).value;
break;
end
end
end
wname=['卷积层' num2str(j) '\n'];
fprintf(FID,wname );
issave=1;
end
if strTong(net.layers(i).type,'dagnn.ConvTranspose')
disp('上采样层');%反向卷积，转置卷积
disp('输入是：');
disp(net.layers(i).inputs);
%得到权重（也就是卷积核）和偏移
disp('参数是：');
disp(net.layers(i).params);
fft=net.layers(i).params{1};
for k=1:length(net.params)
if strTong(net.params(k).name,fft)
weight=net.params(k).value;
break;
end
end
if net.layers(i).block.hasBias==false
bias=[]; % 无偏移
else
fft=net.layers(i).params{2};
for k=1:length(net.params)
if strTong(net.params(k).name,fft)
bias=net.params(k).value;
break;
end
end
end
disp('输出是：');
disp(net.layers(i).outputs);
upsample=net.layers(i).block.upsample;
crop=net.layers(i).block.crop;
numGroups=net.layers(i).block.numGroups;
opts=net.layers(i).block.opts{:}
% 字符串是否包含
if strBao(net.layers(i).outputs{:}, 'img_up') %残差
wname=['图像放大层\n'];
fprintf(FID,wname );
else
wname=['残差放大层\n'];
fprintf(FID,wname );
end
issave=1;
end
if issave==1;
[h,w,c,p]=size(weight);
l0=h*w*c*p;
fprintf(FID,'长度 %d\n',l0 );%有多少个
for i0=1:c
for j0=1:p
for t=1:h
for s=1:w
fprintf(FID, '%f ',weight(s,t,i0,j0));
end
fprintf(FID, '\n');
end
end
end
if ~isempty(bias)
bname=['有偏移\n'];
fprintf(FID,bname );
l0=length(bias);
fprintf(FID,'长度 %d\n',l0 );%有多少个
for i0=1:l0
fprintf(FID, '%f ',bias(i0));
end
fprintf(FID, '\n');
else
bname=['无偏移\n'];
fprintf(FID,bname );
end
end
end
fclose(FID);
%---------------------------------------
模型数据结构：
#define 总层数 25
struct 层数据
{
char 类型[255];
int 权重长度;
float * 权重_数据;
int 偏移长度;
float * 偏移_数据;
};
struct LapSRN_x8模型
{
int 层数; //25
层数据 * 所有层;
//构造函数
LapSRN_x8模型();
};
LapSRN_x8模型::LapSRN_x8模型()
{
层数=总层数; //
int size;
size = sizeof(层数据)*层数;//
所有层=(层数据 *)malloc(size);
}
载入模型数据：
bool loadModel(LapSRN_x8模型 *sr)
{
char name[]="LapSRN_x8.txt";
std::ifstream fin(name);
//检查文件是否存在
if (!fin)
{
return false;
}
cout<<"正在载入‘LapSRN_x8.txt’的数据"<<endl;
//从档案载入
char str[40];
int len;
层数据 * 层=sr->所有层;
for (int k = 0;k<总层数;k++)
{
//cout<<k<<"层"<<endl<<endl;
fin >> 层->类型;
//cout<<层->类型<<endl;
fin >> str;
//cout<<str<<endl;
fin >> len;//需要载入的个数
//cout<<len<<endl;
层->权重长度=len;
层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);
float * w=层->权重_数据;
//float tmp;
for(int i=0;i<len;i++)
{
fin >> *w++;
}
fin >> str; //有无偏移
//cout<<str<<endl;
if(strcmp(str, "有偏移")==0)
{
fin >> str;//长度
//cout<<str<<endl;
fin >> len;//需要载入的个数
//cout<<len<<endl;
层->偏移长度=len;
层->偏移_数据=(float*)malloc(sizeof(float) * 层->偏移长度);
float * b=层->偏移_数据;
for(int i=0;i<len;i++)
{
fin >> *b++;
}
}else
{
层->偏移长度=0;
层->偏移_数据=NULL;
}
层++;//到下一层
}//end
fin.close ();
return true;
}
卷积层：
class 卷积层
{
public:
int width; //宽
int height; //高
int depth; //通道 深度
float * data;
//构造函数
卷积层(int iwidth,int iheight);
卷积层(int iwidth,int iheight,int idepth);
卷积层(int iwidth,int iheight,int c,float * data);
~卷积层();
};
卷积层::卷积层(int iwidth,int iheight): width(iwidth),
height(iheight)
{
depth=1;
data=NULL;
}
卷积层::卷积层(int iwidth,int iheight,int idepth): width(iwidth),
height(iheight),depth(idepth)
{
data=NULL;
}
卷积层::卷积层(int iwidth,int iheight,int idepth,float * fdata): width(iwidth),
height(iheight),depth(idepth), data(fdata)
{
}
卷积层::~卷积层()
{
}
内存分配在外部
主函数main ,这里不用图形界面：
int main(int argc, char *argv[])
{
char jpgname[256];
if( argc == 2 )
strcpy(jpgname, argv[1]);
else
strcpy(jpgname, "测试1.jpg");//lena.jpg //6c7a
//载入图片
loadjpg(jpgname);
// 放大倍率 2，4 或 8 倍
int up_scale = 8;
clock_t start_t, end_t;//计算时间
double total_t;
start_t = clock();
// LapSRN 高分辨率重建
LapSRN(up_scale);
end_t = clock();
total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC;
cout<<"已经完成"<<endl;
cout<<"用时："<<total_t<<" 秒"<<endl;
system("pause");
return 0;
}
核心流程函数LapSRN：
void LapSRN(int up_scale)
{
LapSRN_x8模型 sr;
// 加载 CNN 模型参数
loadModel(&sr);
//cout<<"loadModel成功"<<endl;
int wid=jpg.getwidth();
int hei=jpg.getheight();
cout<<"输入图像宽度："<<wid<<endl;
cout<<" 高度："<<hei<<endl;
卷积层 im_b(wid,hei);//即Y通道
im_b.data=new float[wid * hei * sizeof(float)];
卷积层 U(wid,hei),V(wid,hei);
U.data=new float[wid * hei * sizeof(float)];
V.data=new float[wid * hei * sizeof(float)];
//RGB转换为YUV
RGB2YUV(&jpg,&im_b,&U,&V);
//U,V暂时无用，先删除占用内存
delete []U.data; U.data=NULL;
delete []V.data; V.data=NULL;
//loadImlow(&im_b);//载入matlab导出的数据用于比较
//save_mat ("im_bis.txt",im_b.data,im_b.width,im_b.height,im_b.depth); //保存
//总层数
int l=总层数;//
cout<<"共有："<<l<<"层"<<endl;
//中间过程
卷积层 convfea1(wid,hei,64);
convfea1.data=new float[wid * hei * 64 * sizeof(float)];
卷积层 convfea2(wid,hei,64);
convfea2.data=new float[wid * hei * 64 * sizeof(float)];
卷积层 *源=&im_b, *目标=&convfea1;
// 残差图--------------------------------------------------------
// 2倍残差图
卷积层 residual1(wid*2,hei*2);
residual1.data=new float[wid * hei * 4 * sizeof(float)];
卷积层 hR1(wid*2,hei*2);
hR1.data=new float[wid * hei * 4 * sizeof(float)];
// 4倍残差图
卷积层 residual2(wid*4,hei*4);
residual2.data=new float[wid * hei * 16 * sizeof(float)];
卷积层 hR2(wid*4,hei*4);
hR2.data=new float[wid * hei * 16 * sizeof(float)];
// 8倍残差图
卷积层 residual3(wid*8,hei*8);
residual3.data=new float[wid * hei * 64 * sizeof(float)];
卷积层 hR3(wid*8,hei*8);
hR3.data=new float[wid * hei * 64 * sizeof(float)];
if(residual3.data==NULL)
{
printf("图片太大！只能运行4倍放大\n");
up_scale=4;
}
if(residual2.data==NULL)
{
printf("图片太大！只能运行2倍放大\n");
up_scale=2;
}
int upsample_num=0;// 图像放大计数
int residual_num=0;// 残差图计数
float *weight, *bias;
//save_矩阵 ("im_b.txt",im_b.data,im_b.width,im_b.height,im_b.depth); //保存
层数据 * 层=sr.所有层;
//循环各层直至结束
for (int i=0;i<l;i++ )//8 25层
{
cout<<"第 "<<i<<" 层"<<endl;
if (strstr(层->类型, "卷积层"))//strTong(net.layers(i).type,'dagnn.Conv')
{
//返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。
//j=j+1
cout<<"卷积..."<<endl;
//得到权重（也就是卷积核）和偏移
weight=层->权重_数据;
bias=层->偏移_数据;
if (i==0) //strTong(net.layers(i).inputs{1},'LR') //第一层
{
//convfea = vl_nnconv(im_b,weight,bias,'Pad',1);//一图得出64特征图
vl_nnconv(&im_b,目标,层,1 ,1 , 1 ,1 ,1 ,1 );
vl_nnrelu(目标, 0.2);//'leak',
//save_卷积层2jpg(目标,"con0");
源=目标;
目标=&convfea2;
}
else //一以后
{
if (层->权重长度==576) //strBao(net.layers(i).outputs{:}, 'residual')
{
cout<<"合成残差..."<<endl;
//residual_num=residual_num+1;
卷积层 *tmp=目标;//暂存
if (residual_num==1)
//residual1= vl_nnconv(convfea,weight,bias,'Pad',1);// 2倍残差图
目标= & residual1;
//end
if (residual_num==2)
//residual2= vl_nnconv(convfea,weight,bias,'Pad',1);// 4倍残差图
目标= &residual2;
if (residual_num==3)
//residual3= vl_nnconv(convfea,weight,bias,'Pad',1);// 8倍残差图
目标= &residual3;
vl_nnconv(源,目标,层,1 ,1 ,1 ,1 ,1 ,1 );
vl_nnrelu(目标, 0.2);//'leak',
//char txt[255];
//sprintf(txt, "第%d残差", residual_num);
//save_卷积层2jpg(目标,txt);
//sprintf(txt, "第%d残差前", residual_num);
//save_卷积层2jpg(源,txt);
目标=tmp;//还原
}
else
{
//中间层 64特征图合成1图 再重新生成深一层64特征图
//convfea = vl_nnconv(convfea,weight,bias,'Pad',1);
vl_nnconv(源,目标,层,1 ,1 , 1 ,1 ,1 ,1 );
vl_nnrelu(目标, 0.2);//'leak',
//char txt[255];
//sprintf(txt, "con%d", i);
//save_卷积层2jpg(目标,txt);
std::swap(源,目标);
}
//end
}//end
}//end
if (strstr(层->类型, "残差放大层"))//strTong(net.layers(i).type,'dagnn.Conv')
{
cout<<"残差放大..."<<endl;
residual_num++;
weight=层->权重_数据;
bias=层->偏移_数据;
// 残差放大参数是 'upsample', 2 ,'crop', [0 1 0 1],'numGroups', 1
//convfea = vl_nnconvt(convfea, weight, bias,'upsample', upsample ,'crop', crop,'numGroups', 1) ;//
//扩大第一卷积层内存
delete []目标->data; 目标->data=NULL;
if (residual_num==1)
{
目标->width=wid*2;目标->height=hei * 2;目标->depth=64;
目标->data=new float[wid * hei * 4 * 64 * sizeof(float)];
}
if (residual_num==2)
{
目标->width=wid*4;目标->height=hei * 4;目标->depth=64;
目标->data=new float[wid * hei * 16 * 64 * sizeof(float)];
}
if (residual_num==3)
{
目标->width=wid*8;目标->height=hei * 8;目标->depth=64;
目标->data=new float[wid * hei * 64 * 64 * sizeof(float)];
}
vl_nnconvt(源,目标,层,2,2, 0 ,1,0,1) ;//残差放大
vl_nnrelu(目标, 0.2);//'leak',
//char txt[255];
//sprintf(txt, "残差放大%d", i);
//save_卷积层2jpg(目标,txt);
std::swap(源,目标);
//扩大第二卷积层内存
delete []目标->data; 目标->data=NULL;
if (residual_num==1)
{
目标->width=wid*2;目标->height=hei * 2;目标->depth=64;
目标->data=new float[wid * hei * 4 * 64 * sizeof(float)];
}
if (residual_num==2)
{
目标->width=wid*4;目标->height=hei * 4;目标->depth=64;
目标->data=new float[wid * hei * 16 * 64 * sizeof(float)];
}
if (residual_num==3)
{
目标->width=wid*8;目标->height=hei * 8;目标->depth=64;
目标->data=new float[wid * hei * 64 * 64 * sizeof(float)];
}
}
if (strstr(层->类型, "图像放大层"))//strTong(net.layers(i).type,'dagnn.Conv')
{
cout<<"图像放大..."<<endl;
//到这里可以删除
delete []目标->data; 目标->data=NULL;
delete []源 ->data; 源 ->data=NULL;
weight=层->权重_数据;
bias=层->偏移_数据;//无偏移
upsample_num=upsample_num+1;
// 图像放大参数是 'upsample', 2 ,'crop', [1 1 1 1],'numGroups', 1
if (upsample_num==1) // 2倍放大图
{
//img_up1 = vl_nnconvt(imlow, weight, bias,'upsample', upsample ,'crop', crop,'numGroups', 1) ;
vl_nnconvt(&im_b,&hR1,层,2,2, 1 ,1,1,1) ;//残差放大
//save_卷积层2jpg(&im_b,"2倍放大前");
//save_卷积层2jpg(&hR1,"2倍放大");
卷积层相加(&residual1,&hR1);
//hR1=img_up1+residual1; // 合成2倍重建图
//save_卷积层2jpg(&hR1,"2倍重建图");
delete []im_b.data; im_b.data=NULL;
delete []residual1.data; residual1.data=NULL;
//色彩放大（2倍）
ResizeGrayscaleImage(&jpg,2) ;
//卷积层 U(wid,hei),V(wid,hei);
U.height=V.height=hei*2;
U.width =V.width =wid*2;
U.data=new float[wid * hei *2*2* sizeof(float)];
V.data=new float[wid * hei *2*2* sizeof(float)];
//RGB转换为YUV
RGB2YUV(&jpg,&U,&V);
//合成色彩重建图
IMAGE im_h(U.width,U.height);
YUV2RGB(&hR1,&U,&V, &im_h);
//保存图像
saveimage(L"LapSRN 2倍 重建.jpg", &im_h);
//U,V暂时无用，先删除占用内存
delete []U.data; U.data=NULL;
}
else
if (upsample_num==2) // 4倍放大图
{
//img_up2 = vl_nnconvt(hR1, weight, bias,'upsample', upsample ,'crop', crop,'numGroups', 1) ;//
vl_nnconvt(&hR1,&hR2,层,2,2, 1 ,1,1,1) ;//残差放大
//save_卷积层2jpg(&hR2,"4倍放大");
卷积层相加(&residual2,&hR2);
//hR2=img_up2+residual2; // 4倍
//save_卷积层2jpg(&hR2,"4倍重建图");
delete []hR1.data; hR1.data=NULL;
delete []residual2.data; residual2.data=NULL;
//色彩放大（2倍）
ResizeGrayscaleImage(&jpg,2) ;//再2倍就是4倍
//卷积层 U(wid,hei),V(wid,hei);
U.height=V.height=hei*4;
U.width =V.width =wid*4;
U.data=new float[wid * hei *16* sizeof(float)];
V.data=new float[wid * hei *16* sizeof(float)];
//RGB转换为YUV
RGB2YUV(&jpg,&U,&V);
//合成色彩重建图
IMAGE im_h(U.width,U.height);
YUV2RGB(&hR2,&U,&V, &im_h);
//保存图像
saveimage(L"LapSRN 4倍 重建.jpg", &im_h);
//U,V暂时无用，先删除占用内存
delete []U.data; U.data=NULL;
}
else
if (upsample_num==3 )// 8倍放大图
{
//img_up3 = vl_nnconvt(hR2, weight, bias,'upsample', upsample ,'crop', crop,'numGroups', 1) ;//
vl_nnconvt(&hR2,&hR3,层,2,2, 1 ,1,1,1) ;//残差放大
//save_卷积层2jpg(&hR3,"8倍放大");
卷积层相加(&residual3,&hR3);
//hR3=img_up3+residual3; // 8倍
//save_卷积层2jpg(&hR3,"8倍重建图");
delete []hR2.data; hR2.data=NULL;
delete []residual3.data; residual3.data=NULL;
//色彩放大（2倍）
ResizeGrayscaleImage(&jpg,2) ;//再2倍就是8倍
//卷积层 U(wid,hei),V(wid,hei);
U.height=V.height=hei*8;
U.width =V.width =wid*8;
U.data=new float[wid * hei *64* sizeof(float)];
V.data=new float[wid * hei *64* sizeof(float)];
//RGB转换为YUV
RGB2YUV(&jpg,&U,&V);
//合成色彩重建图
IMAGE im_h(U.width,U.height);
YUV2RGB(&hR3,&U,&V, &im_h);
//保存图像
saveimage(L"LapSRN 8倍 重建.jpg", &im_h);
//U,V暂时无用，先删除占用内存
delete []U.data; U.data=NULL;
}//end
//end
}
// disp('激励层');
// convfea = vl_nnrelu(convfea, 0.2);//'leak',
层++;
}//end
}
这个可以参看前面的matlab的代码。
外框架完成。