cnn突破四（生成卷积核与固定核对比）

news2024/11/25 20:46:33

cnn突破三中生成四个卷积核，训练6万次，91分，再训练6万次，95分，不是很满意，但又找不到问题点，所以就想了个办法，使用三个固定核，加上三层bpnet神经网络，看看效果，还别说，固定核效果不错，训练6万次，逼近96分，而且不到十秒就训练完成了，而机器自动生成卷积核要40多秒！以下是代码，做个记录，为什么图像处理中常用的卷积核效果好？

14:24 2024/9/25
已经打包，已经改成100，变化不大
然后想到，用那三个卷积核，加上三层网络，
结果太开心，稳定在96三次，时而突破97，学习6万次一共四次
如果重复学习，已经有参数，不低于97
28*28gaos后降采样成14*14，使用三个卷积核并行，变成3@12*12，
降采样到3@6*6，108全连接80-10，结束
先打包一个，太激动le，95就这样突破了

这是当天的日记。代码如下：

先看forward函数：

forward第一步;使用soblex，sobely，以及lapulas三个核，14*14-》3@12*12

int w = 14;
int ww = w;
int h = 14;
int hh = h;
double[] A1 = new double[12 * 12]; double[] A2 = new double[12 * 12]; double[] A3 = new double[12 * 12];
int k = 0;
for (int j = 1; j < (h - 1); j++)
{
for (int i = 1; i < (w - 1); i++)
{
int n0 = (j * w + i);

double Grady = xI[n0 - 1 - ww] + 2 * xI[n0 - ww] + xI[n0 - ww + 1]
- xI[n0 + ww - 1] - 2 * xI[n0 + ww] - xI[n0 + ww + 1];

A1[k] = Grady;

double Gradx = xI[n0 - ww + 1] + 2 * xI[n0 + 1] + xI[n0 + ww + 1]
- xI[n0 - ww - 1] - 2 * xI[n0 - 1] - xI[n0 + ww - 1];

A2[k] = Gradx;

double lapulas = xI[n0 + 1] + xI[n0 - 1] - 2 * xI[n0] + xI[n0 + w] + xI[n0 - w] - 2 * xI[n0];//拉普拉斯=+

A3[k] = lapulas;

k++;
}
}

forward第二步：池化取最大，变成6*6@3

//第二步，降级采样
// List<double>
hebing固定 = new List<double>();//一共36*3
for (int i = 0; i < 6; i++)
for (int j = 0; j < 6; j++)//
{
int l = (i) * 6 + j;
double tempb = 0;

for (int m = 0; m < 2; m++)
for (int n = 0; n < 2; n++)
{
int kk = (i * 2 + m) * 12 + j * 2 + n;

if (A1[kk] > tempb)
{
tempb = A1[kk];

}
}
hebing固定.Add(tempb);
// hIcnn[l] = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038
}
for (int i = 0; i < 6; i++)
for (int j = 0; j < 6; j++)//
{
int l = (i) * 6 + j;
double tempb = 0;

for (int m = 0; m < 2; m++)
for (int n = 0; n < 2; n++)
{
int kk = (i * 2 + m) * 12 + j * 2 + n;

if (A2[kk] > tempb)
{
tempb = A2[kk];

for (int m = 0; m < 2; m++)
for (int n = 0; n < 2; n++)
{
int kk = (i * 2 + m) * 12 + j * 2 + n;

if (A3[kk] > tempb)
{
tempb = A3[kk];

}
}
hebing固定.Add(tempb);
// hIcnn[l] = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038
}

forward第三步：合并3@6*6=108，归一化后全连接

//先观察数据，并归一化hebing固定

double linshimax=0;
for (int i = 0; i < hebing固定.Count;i++ )
{

if (hebing固定[i] > linshimax) linshimax = hebing固定[i];
}
hebing固定归一化=new double[108];
for (int i = 0; i < hebing固定.Count; i++)
{
hebing固定归一化[i]=hebing固定[i] / linshimax;
}

hI固定 = new double[80];
//通过w1计算输入层-隐藏层输入节点
for (int i = 0; i < 36 * 3; i++)//108
for (int j = 0; j < 80; j++)//80

hI固定[j] += hebing固定归一化[i] * w1固定[i, j];

//通过激活函数对隐藏层进行计算
for (int i = 0; i < 80; i++)
hO固定[i] = sigmoid(hI固定[i] + bh固定[i]);

yi固定 = new double[10];
//通过w2计算隐藏层-输出层
for (int i = 0; i < 80; i++)
for (int j = 0; j < 10; j++)

yi固定[j] += hO固定[i] * w2固定[i, j];

//通过激活函数求yo
for (int i = 0; i < 10; i++)
yO固定[i] = sigmoid(yi固定[i] + by固定[i]);

以上就完成了forward函数，下面再看：backward函数：

void backcnn固定()
{
//对w2进行更新
double []deltax=new double[10];

for (int j = 0; j < 10; j++)//10
{
deltax[j] = (yO固定[j] - d[j]) * dsigmoid(yO固定[j]);
by固定[j] -= deltax[j] * learnRate;
for (int i = 0; i < 80; i++)//
{

w2固定[i, j] -= deltax[j] * learnRate * hO固定[i];

}
}

//对反向传播进行预处理

double[] W2 = new double[80];//

for (int j = 0; j < 80; j++)
for (int k = 0; k < 10; k++)
W2[j] += deltax[k] * w2固定[j, k];

//对w1进行更新

for (int j = 0; j < 80; j++)
{
double delta = dsigmoid(hO固定[j]) * W2[j];
bh固定[j] -= delta * learnRate;
for (int i = 0; i < 108; i++)//
{

w1固定[i, j] -= delta * learnRate * hebing固定归一化[i];

}
}

}

这就完了，看看运行效果：