32位C++改编 对抗(SRGAN)之生成(generator)超分辨重建 ---（一）内存数据

前面准备工作已做得差不多了，现在开始

原始框图：

 

实现框图：

上图中的双三次放大是没有的，图像就不重发了（或者等有空再重发吧）。

定义基本单位：

struct 基本单位//残差块半层数据 
{
		层数据 *卷积层; 
		bool 有无BatchNorm_beta;
		int 归一化长度;
		//gamma 缩放 为固定值 1.0
		float *	BatchNorm_beta;//BatchNorm_beta  位移
		//均值 和方差
		float *	u; //tensorflow 中的 移动平均值(moving_mean)
		float *	std;// 移动方差(moving_variance)
		bool 有无Prelu;
		float *	Prelu_alpha; //Prelu_alpha
};

定义残差块：

struct 残差块//
{
	int num;//数量 2
	基本单位 *数据;
};

模型数据池：

struct generator_tf模型
{
	

	基本单位 * 输入层;

	int 残差块数量;//16块
	残差块 * 块;
	基本单位 残差输出层; //总共16层半
	
	基本单位 * 后3层;

	//构造函数
	generator_tf模型();

};

构造模型：

generator_tf模型::generator_tf模型()
{

	int size;
	size = sizeof(基本单位);//
	输入层=(基本单位 *)malloc(size);

	size = sizeof(层数据);//
	输入层->卷积层=(层数据 *)malloc(size);

	层数据 * 层=输入层->卷积层;
	strcpy(层->类型, "卷积层");
	层->权重长度=64*3*9*9;
	层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);
	层->输入维度=3;
	层->输出维度=64;
	层->核宽=9;
	层->偏移长度=64;
	层->偏移_数据=(float*)malloc(sizeof(float) * 层->偏移长度);

	输入层->有无BatchNorm_beta=false;
	输入层->有无Prelu=true;
	输入层->归一化长度=64;
	输入层->Prelu_alpha=(float*)malloc(sizeof(float) * 层->偏移长度);

	//块 
	残差块数量=16;
	size = sizeof(残差块)*残差块数量;
	块=(残差块*)malloc(size);
	残差块 * 残差块0=块;
	for (int k = 0;k<残差块数量;k++)
	{

		残差块0->num=2;
			
		size = sizeof(基本单位)*2;

		残差块0->数据=(基本单位*)malloc(size);

		for(int p=0;p<2;p++){
			size = sizeof(层数据);//
			残差块0->数据[p].卷积层=(层数据 *)malloc(size);
			层=残差块0->数据[p].卷积层;
				strcpy(层->类型, "卷积层");
				层->权重长度=64*64*3*3;
				层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);
				层->输入维度=64;
				层->输出维度=64;
				层->核宽=3;
				层->偏移长度=0;//64;
				层->偏移_数据=NULL;//(float*)malloc(sizeof(float) * 层->偏移长度);

				残差块0->数据[p].归一化长度=64;
				残差块0->数据[p].有无BatchNorm_beta=true;
				残差块0->数据[p].BatchNorm_beta=(float*)malloc(sizeof(float) * 64);
				残差块0->数据[p].u=(float*)malloc(sizeof(float) * 64);
				残差块0->数据[p].std=(float*)malloc(sizeof(float) * 64);
				if(p==0)
				{
					残差块0->数据[p].有无Prelu=true;
					残差块0->数据[p].Prelu_alpha=(float*)malloc(sizeof(float) * 64);
				}
				else
				{
					残差块0->数据[p].有无Prelu=false;
				}
		}

		残差块0++;
	}

			size = sizeof(层数据);//
			残差输出层.卷积层=(层数据 *)malloc(size);
			层=残差输出层.卷积层;
				strcpy(层->类型, "卷积层");
				层->权重长度=64*64*3*3;
				层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);
				层->输入维度=64;
				层->输出维度=64;
				层->核宽=3;
				层->偏移长度=0;//64;
				层->偏移_数据=NULL;//(float*)malloc(sizeof(float) * 层->偏移长度);

			残差输出层.归一化长度=64;
			残差输出层.有无BatchNorm_beta=true;
			残差输出层.BatchNorm_beta=(float*)malloc(sizeof(float) * 64);
			残差输出层.u=(float*)malloc(sizeof(float) * 64);
			残差输出层.std=(float*)malloc(sizeof(float) * 64);
			残差输出层.有无Prelu=false;
		//}

	size = sizeof(基本单位);//
	后3层=(基本单位 *)malloc(size*3);
			size = sizeof(层数据);//
	基本单位 * 后单位=后3层;
	for (int k = 0;k<3;k++)
	{
		size = sizeof(层数据);//
		后单位->卷积层=(层数据 *)malloc(size);
		层=后单位->卷积层;
		strcpy(层->类型, "卷积层");
		后单位->BatchNorm_beta=false;

		switch(k)
		{
			case 0:
			case 1:
				层->权重长度=256*64*3*3;
				层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);
	层->输入维度=64;
	层->输出维度=256;
	层->核宽=3;
				层->偏移长度=256;
				层->偏移_数据=(float*)malloc(sizeof(float) * 层->偏移长度);

				后单位->有无Prelu=true;
				后单位->归一化长度=64;
				后单位->Prelu_alpha=(float*)malloc(sizeof(float) * 后单位->归一化长度);
				break;
			case 2:
				层->权重长度=3*64*9*9;
				层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);
	层->输入维度=64;
	层->输出维度=3;
	层->核宽=9;
				层->偏移长度=3;
				层->偏移_数据=(float*)malloc(sizeof(float) * 层->偏移长度);

				后单位->Prelu_alpha=false;
				break;

		}
		后单位++;
	}

}

然后就可以载入模型数据了，由于数据已经转化为caffe格式，除了跳过gamma数据，于前面相同，就不介绍了

该部分结束