自己的初心，在bpnet基础上自研cnn

网上有cnn的源码（lenet），也有原理！（cpu版本的，很原始的那种，但还是比我的自研cnn好！）

所以改he凯明初始化，softmax，批处理，vgg，残差都实验成功了！

以及cudnn下也实现了bn和残差，自然也实现了并发！

但是自己的初心还是放不下，mnist下，应该有一个自己安心的版本！毕竟是自己原创的！

基于bpnet，怎样达成cnn呢？

其实就一句话：不放弃，磕到底，最终你会意识到权重和卷积核是一回事，这件事想通了，就基本成功了！

这次修改，其实我已经透彻了cnn的数学原理，也就是读过人家的paper了！

前头极简cnn几篇博客已经分析透彻了cnn的数学原理，也做了达成！

这次是审视和修改自己的初心，肯定还是比极简cnn复杂的多！

毕竟是训练mnist数据集！

虽然batch=10，但还是cpu版本的！c#达成！使用了he初始化和softmax，以及leaky relu！

卷积时的bias不好处理，也删除了，只保留了全连接中的bias！

训练一轮6万次，上了90分，训练时间降到1分07秒，没有batch要1分37秒！learnrate=0.015

第二轮，第三轮，讲的学习率到0.01，上96没问题，继续降低学习率，成绩还能上！

lr=0.005，超过97分！其实成绩我并不关注了，手写了十个数字，正常，基本全能正确识别！

只是在正确的cnn理论下约束自己的初心，使其数学化，达成安心版本！

其实我的版本里，有一些东西不在cnn理论中，而且训练成绩不降反升！这也是我为什么做记录的原因，人工智能困扰的地方，也可能时处女地！

好，先说在cnn理论下，自己初心达成的安心版本！

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.IO;

using System.Drawing.Imaging;

namespace 自己的20核

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

Random ran = new Random();

public double randomNormalDistribution()

{

double u = 0.0, v = 0.0, w = 0.0, c = 0.0;

{

//获得两个（-1,1）的独立随机变量

u = ran.NextDouble() * 2 - 1.0;

v = ran.NextDouble() * 2 - 1.0;

w = u * u + v * v;

} while (w == 0.0 || w >= 1.0);

//这里就是 Box-Muller转换

c = Math.Sqrt((-2 * Math.Log(w)) / w);

return u * c;

}

double $,$ w576cnn = new double $25, 4$ ;

double $,$ w1cnn = new double $25, 4$ ;

double $,$ w1cnn2 = new double $25, 4$ ;

double $,$ w1cnn3 = new double $25, 4$ ;

double $,$ w1cnn4 = new double $25, 4$ ;

double $,$ delw1cnn = new double $25, 4$ ;

double $,$ delw1cnn2 = new double $25, 4$ ;

double $,$ delw1cnn3 = new double $25, 4$ ;

double $,$ delw1cnn4 = new double $25, 4$ ;

double $,$ w12cnn = new double $16 \* 16, 80$ ;

double $,$ w2cnn = new double $80, 10$ ;

//double\[\] bIOcnn = new double $256$ ;//不用B和deltaB，降低难度

//double\[\] bI2Ocnn = new double $80$ ;

//double\[\] bycnn = new double $10$ ;

void init()

{

//lenet-1

for (int i = 0; i < 25; i++)

for (int j = 0; j < 4; j++)

{

w576cnn $i, j$ = randomNormalDistribution() / Math.Sqrt(25*batch_size / 2f);

}

for (int i = 0; i < 25; i++)

for (int j = 0; j < 4; j++)

{

w1cnn $i, j$ = randomNormalDistribution() / Math.Sqrt(25 * batch_size / 2f);

w1cnn2 $i, j$ = randomNormalDistribution() / Math.Sqrt(25 * batch_size / 2f);

w1cnn4 $i, j$ = randomNormalDistribution() / Math.Sqrt(25 * batch_size / 2f);

w1cnn3 $i, j$ = randomNormalDistribution() / Math.Sqrt(25 * batch_size / 2f);

}

for (int i = 0; i < 16 * 16; i++)

for (int j = 0; j < 80; j++)

{

w12cnn $i, j$ = randomNormalDistribution() / Math.Sqrt(256 * batch_size / 2f);

}

for (int i = 0; i < 80; i++)

for (int j = 0; j < 10; j++)

{

w2cnn $i, j$ = randomNormalDistribution() / Math.Sqrt(80 * batch_size / 2f);

}

//for (int i = 0; i < 256; i++)

//{ bIOcnn $i$ = randomNormalDistribution() / Math.Sqrt(256 / 2f); }

//for (int i = 0; i < 80; i++)

//{ bI2Ocnn $i$ = randomNormalDistribution() / Math.Sqrt(80 / 2f); }

//for (int i = 0; i < 10; i++)

//{ bycnn $i$ = randomNormalDistribution() / Math.Sqrt(10 / 2f); }

}

List<byte\[\]> alltraindataorg = new List<byte\[\]>();

double\[\]\[\] hello28 = new double $60000$ \[\];

List<int> labels = new List<int>();

void ReadMnistImages(string filePath)

{

alltraindataorg.Clear();

using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))

using (BinaryReader reader = new BinaryReader(fileStream))

{

// 跳过文件头的前16个字节

reader.ReadBytes(16);

while (fileStream.Position < fileStream.Length)

{

byte\[\] image = reader.ReadBytes(28 * 28); // MNIST图像大小为28x28

alltraindataorg.Add(image);

}

void ReadMnistLabels(string filePath)

{

labels.Clear();

using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))

using (BinaryReader reader = new BinaryReader(fileStream))

{

// 跳过文件头的前8个字节

reader.ReadBytes(8);

while (fileStream.Position < fileStream.Length)

{

byte label = reader.ReadByte(); // 读取标签

// 处理标签数据

// ...

labels.Add(label);

}

double learnRate = 0.2f; //学习率

private void button29_Click(object sender, EventArgs e)

{

init();

////////////duqu mnist shujuji ,DuQu Mnist ShuJuJi//2024090111004

string imagesFilePath = "c:\\train-images.idx3-ubyte";

string labelsFilePath = "c:\\train-labels.idx1-ubyte";

ReadMnistImages(imagesFilePath);

ReadMnistLabels(labelsFilePath);

for (int xx = 0; xx < 60000; xx++)

{

hello28 $xx$ = new double $28 \* 28$ ;

for (int i = 0; i < 28 * 28; i++)

{

hello28 $xx$ $i$ = alltraindataorg $xx$ $i$ / 255f;

}

}//上头的初始化应该独立出去

//learnRate = 0.015f;//不错，上96了202502272143

learnRate = 0.015f;

showbuffer2pictmod4(new Byte $28 \* 28$ , 28, 28, pictureBox20);

}

void showbuffer2pictmod4(byte\[\] buffer, int ww, int hh, PictureBox destImg)

{

int mod = ww % 4;//解决四位对齐问题20150716

int temproiw = ww + (4 - mod) % 4;//其实这都是和显示相关，处理图像其实不必考虑，

//顯示

byte\[\] cutvalues = new byte $temproiw \* hh \* 3$ ;

int bytes = temproiw * hh * 3;

Bitmap cutPic24 = new Bitmap(temproiw, hh, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

BitmapData _cutPic = cutPic24.LockBits(new Rectangle(0, 0, temproiw, hh), ImageLockMode.ReadWrite,

cutPic24.PixelFormat);

IntPtr ptr = _cutPic.Scan0;//得到首地址

for (int i = 0; i < hh; i++)

{

for (int j = 0; j < ww; j++)

{

int n = i * ww + j;

//int m = 3 * n;

int m = 3 * (i * temproiw + j);

cutvalues $m$ = buffer $n$ ;

cutvalues $m + 1$ = buffer $n$ ;

cutvalues $m + 2$ = buffer $n$ ;

}

System.Runtime.InteropServices.Marshal.Copy(cutvalues, 0, ptr, bytes);

cutPic24.UnlockBits(_cutPic);

destImg.Image = cutPic24;

}

int\[\] last = new int $60000$ ;

int batch_size = 10;

public void updatesumresult()

{

//最后更新d

for (int j = 0; j < 10; j++)//10

for (int i = 0; i < 80; i++)//15

{

w2cnn $i, j$ -= learnRate * 临时dzw2 $i, j$ / batch_size;

}

for (int j = 0; j < 80; j++)//15

for (int i = 0; i < 16 * 16; i++)//256

{

w12cnn $i, j$ -= learnRate * 临时dzw12 $i, j$ / batch_size;

}

//for (int i = 0; i < 10; i++)

//{

// bycnn $i$ -= learnRate * 临时记录dby $i$ ;

//}

//for (int i = 0; i < 80; i++)

//{

// bI2Ocnn $i$ -= learnRate * 临时记录dbhI2O $i$ ;

//}

//for (int i = 0; i < 256; i++)

//{

// bIOcnn $i$ -= learnRate * 临时记录dbhIO $i$ ;

//}

//卷积核 $k \* 5 + z, (tidai) % 4$ -= delta * learnRate;

for (int i = 0; i < 25; i++)

for(int j=0;j<4;j++)

{

w1cnn $i, j$ -= delw1cnn $i, j$ * learnRate/batch_size;

w1cnn2 $i, j$ -= delw1cnn2 $i, j$ * learnRate / batch_size;

w1cnn3 $i, j$ -= delw1cnn3 $i, j$ * learnRate / batch_size;

w1cnn4 $i, j$ -= delw1cnn4 $i, j$ * learnRate / batch_size;

}

//图像变了10次了，怎么会对？

for (int i = 0; i < 25; i++)

{

w576cnn $i, 0$ -= (delta576w03 $i$ + delta576w02 $i$ + delta576w01 $i$ + delta576w00 $i$ ) * learnRate / batch_size;

}

for (int i = 0; i < 25; i++)

{

w576cnn $i, 1$ -= (delta576w13 $i$ + delta576w12 $i$ + delta576w11 $i$ + delta576w10 $i$ ) * learnRate / batch_size;

}

for (int i = 0; i < 25; i++)

{

w576cnn $i, 2$ -= (delta576w23 $i$ + delta576w22 $i$ + delta576w21 $i$ + delta576w20 $i$ ) * learnRate / batch_size;

}

for (int i = 0; i < 25; i++)

{

w576cnn $i, 3$ -= (delta576w33 $i$ + delta576w32 $i$ + delta576w31 $i$ + delta576w30 $i$ ) * learnRate / batch_size;

}

public void reset_update_all()

{

for (int j = 0; j < 10; j++)//10

{

for (int i = 0; i < 80; i++)//15

{

临时dzw2 $i, j$ = 0;

}

for (int j = 0; j < 80; j++)//

{

for (int i = 0; i < 16 * 16; i++)//256

{

临时dzw12 $i, j$ = 0;

}

//for (int i = 0; i < 16; i++)

//{

// deltacnn $i$ = 0;

// deltacnn1 $i$ = 0;

// deltacnn2 $i$ = 0;

// deltacnn3 $i$ = 0;

// deltacnn5 $i$ = 0;

// deltacnn6 $i$ = 0;

// deltacnn7 $i$ = 0;

// deltacnn8 $i$ = 0;

// deltacnn9 $i$ = 0;

// deltacnn10 $i$ = 0;

// deltacnn11 $i$ = 0;

// deltacnn12 $i$ = 0;

// deltacnn13 $i$ = 0;

// deltacnn14 $i$ = 0;

// deltacnn15 $i$ = 0;

// deltacnn16 $i$ = 0;

//}

for (int i = 0; i < 25; i++)

{

delw1cnn $i, 0$ = 0; delw1cnn $i, 1$ = 0; delw1cnn $i, 2$ = 0; delw1cnn $i, 3$ = 0;

delw1cnn2 $i, 0$ = 0; delw1cnn2 $i, 1$ = 0; delw1cnn2 $i, 2$ = 0; delw1cnn2 $i, 3$ = 0;

delw1cnn3 $i, 0$ = 0; delw1cnn3 $i, 1$ = 0; delw1cnn3 $i, 2$ = 0; delw1cnn3 $i, 3$ = 0;

delw1cnn4 $i, 0$ = 0; delw1cnn4 $i, 1$ = 0; delw1cnn4 $i, 2$ = 0; delw1cnn4 $i, 3$ = 0;

delta576w00 $i$ = 0;

delta576w01 $i$ = 0;

delta576w02 $i$ = 0;

delta576w03 $i$ = 0;

delta576w10 $i$ = 0;

delta576w11 $i$ = 0;

delta576w12 $i$ = 0;

delta576w13 $i$ = 0;

delta576w20 $i$ = 0;

delta576w21 $i$ = 0;

delta576w22 $i$ = 0;

delta576w23 $i$ = 0;

delta576w30 $i$ = 0;

delta576w31 $i$ = 0;

delta576w32 $i$ = 0;

delta576w33 $i$ = 0;

}

private void button30cnn_Click(object sender, EventArgs e)

{

last=new int $60000$ ;

DateTime dt = DateTime.Now;

for (int cas = 0; cas < 6000; cas++)

{

reset_update_all();

for (int j = 0;j < 10; j++)

{

int n = cas * batch_size + j;

traincnn(n);//改minibatch，要把更新单独出来，10次一更新，要累加，就要改变初始化值202507130503

}

updatesumresult();//10次一更新

}

int P = 100;

int he = 59100;

float junzhi = 0;

for (int n = 0; n < 9; n++)

{

int hh = 0;

for (int i = 0; i < P; i++)

{

hh += last $he + i$ ;

}

textBox47.Text += he.ToString() + "," + hh.ToString() + "\r\n";

he += 100;

junzhi += hh;

}

junzhi = junzhi / 9f;

TimeSpan sp = DateTime.Now - dt;

textBox47.Text += "均值：" + junzhi.ToString() + "\r\n";

textBox48.Text = sp.ToString();

}

double\[\] hIcnntemp1 = new double $576$ ; double\[\] hIcnntemp = new double $576$ ;

double\[\] hIcnntemp2 = new double $576$ ; double\[\] hIcnntemp3 = new double $576$ ;

List<Point> jilumn1na = new List<Point>(); List<Point> jilumnna = new List<Point>();

List<Point> jilumn2na = new List<Point>(); List<Point> jilumn3na = new List<Point>();

double\[\] hIcnn1na = new double $144$ ; double\[\] hIcnnna = new double $144$ ;

double\[\] hIcnn2na = new double $144$ ; double\[\] hIcnn3na = new double $144$ ;

double\[\] hI遗忘1 = new double $144$ ; double\[\] hI遗忘 = new double $144$ ;

double\[\] hI遗忘2 = new double $144$ ; double\[\] hI遗忘3 = new double $144$ ;

public double NDrelu(double x)

{

return x > 0 ? x : 0.01f * x;//=max(0.1x,x)

}

public double dNDrelu(double x)

{

// return x * (1 - x);

return x > 0 ? 1f : 0.01f;

}

List<double\[\]> hebingbackImg = new List<double\[\]>();

List<List<Point>> hebingpos = new List<List<Point>>();

double\[\] hocnnhebing = new double $16 \* 16$ ;

void maxpooling(int p后h, int p后w,int 前图h,int 前图w,double\[\] 前图,double\[\] p后图,ref List<Point> maxP相对位置)//24*24->12*12,2*2取最大

{

for (int i = 0; i < p后h; i++)

for (int j = 0; j < p后w; j++)//

{

int l = (i) * p后w + j;

double tempb = 0;

Point tempPt = new Point();

for (int m = 0; m < 2; m++)

for (int n = 0; n < 2; n++)//需要记住m，n和序号L，202409181018

{

int k = (i * 2 + m) * 前图w+ j * 2 + n;

if (前图 $k$ > tempb)

{

tempb = 前图 $k$ ;//如果是最大值，核就变得没有意义，back怎么办？202409170727

tempPt = new Point(n, m);//m是h，n是w，这个要小心用错

}

maxP相对位置.Add(tempPt);//25个数据，就有25组m，n，序号一一对应

p后图 $l$ = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038

}

public void cnnforward()//202409180943使用4层网络，抄过来(这里还是三层网络），14*14->5*5->15->10

{

hIcnntemp = new double $576$ ;

hIcnntemp1 = new double $576$ ; hIcnntemp2 = new double $576$ ; hIcnntemp3 = new double $576$ ;

hIcnn1na = new double $144$ ; hIcnn2na = new double $144$ ; hIcnn3na = new double $144$ ;

hIcnnna = new double $144$ ;//每一幅图片都要重置

hI遗忘 = new double $144$ ; hI遗忘2 = new double $144$ ; hI遗忘3 = new double $144$ ;

hI遗忘1 = new double $144$ ;//每一幅图片都要重置

jilumnna.Clear();//forwardcnn执行一次，就是换一张图片

jilumn1na.Clear();

jilumn2na.Clear(); jilumn3na.Clear();

for (int i = 0; i < 24; i++)

for (int j = 0; j < 24; j++)//

{

int l = (i) * 24 + j;

for (int m = 0; m < 5; m++)

for (int n = 0; n < 5; n++)

{

int k = (i + m) * 28 + j + n;

hIcnntemp $l$ += xI $k$ * w576cnn $m \* 5 + n, 0$ ;//始终用零组，其他三个组不用

//为了方便，如此设计202409181006

hIcnntemp1 $l$ += xI $k$ * w576cnn $m \* 5 + n, 1$ ;

hIcnntemp2 $l$ += xI $k$ * w576cnn $m \* 5 + n, 2$ ;

hIcnntemp3 $l$ += xI $k$ * w576cnn $m \* 5 + n, 3$ ;

}

////第二步，24*24》12*12

maxpooling(12, 12, 24, 24, hIcnntemp, hIcnnna, ref jilumnna);

maxpooling(12, 12, 24, 24, hIcnntemp1, hIcnn1na, ref jilumn1na);

maxpooling(12, 12, 24, 24, hIcnntemp2, hIcnn2na, ref jilumn2na);

maxpooling(12, 12, 24, 24, hIcnntemp3, hIcnn3na, ref jilumn3na);

//4*12*12 //第一次maxpooling返回位置

for (int i = 0; i < 144; i++)//12*12时才做sigmod，挺有意思202507120618

{

hI遗忘 $i$ = NDrelu(hIcnnna $i$ );

hI遗忘1 $i$ = NDrelu(hIcnn1na $i$ );

hI遗忘2 $i$ = NDrelu(hIcnn2na $i$ );

hI遗忘3 $i$ = NDrelu(hIcnn3na $i$ );

}

/////////

// 上面已经达成12*12的四张特征图202409211852，下面每张特征图再卷积成8*8，下采样，生成4张4*4

hebingbackImg = new List<double\[\]>(); //16*4*4

hebingpos = new List<List<Point>>();//第二次maxpooling返回位置

List<double\[\]> tempbackImg = new List<double\[\]>();

List<List<Point>>

temp = chongfu(hI遗忘, w1cnn, ref tempbackImg);//重复一次，生成4张4*4特征图和16个位置记录要返回，4次就是，16张图，64个位置记录

for (int i = 0; i < 4; i++)

{

hebingpos.Add(temp $i$ );

hebingbackImg.Add(tempbackImg $i$ );

}

tempbackImg.Clear();

temp.Clear();

temp = chongfu(hI遗忘1, w1cnn2, ref tempbackImg);//重复一次，生成4张4*4特征图和16个位置记录要返回，4次就是，16张图，64个位置记录

for (int i = 0; i < 4; i++)

{

hebingpos.Add(temp $i$ );

hebingbackImg.Add(tempbackImg $i$ );

}

tempbackImg.Clear();

temp.Clear();

temp = chongfu(hI遗忘2, w1cnn3, ref tempbackImg);//重复一次，生成4张4*4特征图和16个位置记录要返回，4次就是，16张图，64个位置记录

for (int i = 0; i < 4; i++)

{

hebingpos.Add(temp $i$ );

hebingbackImg.Add(tempbackImg $i$ );

}

tempbackImg.Clear();

temp.Clear();

temp = chongfu(hI遗忘3, w1cnn4, ref tempbackImg);//重复一次，生成4张4*4特征图和16个位置记录要返回，4次就是，16张图，64个位置记录

for (int i = 0; i < 4; i++)

{

hebingpos.Add(temp $i$ );

hebingbackImg.Add(tempbackImg $i$ );

}

hocnnhebing = new double $16 \* 16$ ;

for (int i = 0; i < 16; i++)

for (int j = 0; j < 16; j++)//4*4

{

int n = i * 16 + j;

// hocnnhebing $n$ = NDrelu(hebingbackImg $i$ $j$ + bIOcnn $n$ );//4*4时才做sigmod，挺有意思202507120618

hocnnhebing $n$ = NDrelu(hebingbackImg $i$ $j$ );

}

//下面开始全连接202409181044

hI2cnn = new double $80$ ;//15gai 25

for (int i = 0; i < 16 * 16; i++)//128

for (int j = 0; j < 80; j++)//60

hI2cnn $j$ += (hocnnhebing $i$ ) * w12cnn $i, j$ ;//75,25

//通过激活函数对隐藏层进行计算

for (int i = 0; i < 80; i++)

// hO2cnn $i$ = NDrelu(hI2cnn $i$ + bI2Ocnn $i$ );

hO2cnn $i$ = NDrelu(hI2cnn $i$ );

yicnn = new double $10$ ;

//通过w2计算隐藏层-输出层

for (int i = 0; i < 80; i++)

for (int j = 0; j < 10; j++)

yicnn $j$ += hO2cnn $i$ * w2cnn $i, j$ ;

//通过激活函数求yo

for (int i = 0; i < 10; i++)

// yOcnn $i$ = NDrelu(yicnn $i$ + bycnn $i$ );

yOcnn $i$ = NDrelu(yicnn $i$ );

////////////////////////////

//下面是softmax，//yo相当与zi

double maxtemp = yOcnn $0$ ;

for (int i = 1; i < 10; i++)

{

if (yOcnn $i$ > maxtemp)

maxtemp = yOcnn $i$ ;

}

double sum = 0;

// 首先找出yo中最大，然后softmax

for (int i = 0; i < 10; i++)

{

sum += Math.Exp(yOcnn $i$ - maxtemp);

}

for (int i = 0; i < 10; i++)

{

softm $i$ = Math.Exp(yOcnn $i$ - maxtemp) / sum;//概率计算完毕

}

double\[\] hI2cnn = new double $80$ ;

double\[\] hO2cnn = new double $80$ ;

double\[\] yicnn = new double $10$ ;

double\[\] yOcnn = new double $10$ ;

double\[\] ThIcnntemp = new double $64$ ;

double\[\] ThIcnntemp1 = new double $64$ ; double\[\] ThIcnntemp2 = new double $64$ ; double\[\] ThIcnntemp3 = new double $64$ ;

double\[\] ThIcnn1na = new double $16$ ; double\[\] ThIcnn2na = new double $16$ ; double\[\] ThIcnn3na = new double $16$ ;

double\[\] ThIcnnna = new double $16$ ;//每一幅图片都要重置

List<Point> Tjilumn1na = new List<Point>(); List<Point> Tjilumnna = new List<Point>();

List<Point> Tjilumn2na = new List<Point>(); List<Point> Tjilumn3na = new List<Point>();

public List<List<Point>> chongfu(double\[\] 输入图像, double $,$ 卷积核,ref List<double\[\]> fanhuituxiang)

{

List<List<Point>> templlp = new List<List<Point>>();

// 上面已经达成12*12的四张特征图202409211852，下面每张特征图再卷积成8*8，下采样，生成4张4*4

ThIcnntemp = new double $64$ ;

ThIcnntemp1 = new double $64$ ; ThIcnntemp2 = new double $64$ ; ThIcnntemp3 = new double $64$ ;

ThIcnn1na = new double $16$ ; ThIcnn2na = new double $16$ ; ThIcnn3na = new double $16$ ;

ThIcnnna = new double $16$ ;//每一幅图片都要重置

Tjilumnna.Clear();//forwardcnn执行一次，就是换一张图片

Tjilumn1na.Clear();

Tjilumn2na.Clear(); Tjilumn3na.Clear();

for (int i = 0; i < 8; i++)

for (int j = 0; j < 8; j++)//

{

int l = (i) * 8 + j;

for (int m = 0; m < 5; m++)

for (int n = 0; n < 5; n++)

{

int k = (i + m) * 12 + j + n;

ThIcnntemp $l$ += 输入图像 $k$ * 卷积核 $m \* 5 + n, 0$ ;//始终用零组，其他三个组不用

//为了方便，如此设计202409181006

ThIcnntemp1 $l$ += 输入图像 $k$ * 卷积核 $m \* 5 + n, 1$ ;

ThIcnntemp2 $l$ += 输入图像 $k$ * 卷积核 $m \* 5 + n, 2$ ;

ThIcnntemp3 $l$ += 输入图像 $k$ * 卷积核 $m \* 5 + n, 3$ ;//一个图像用四个卷积核生成4个特征图*8*8

}

//第二步，8*8-》4*4

maxpooling(4, 4, 8, 8, ThIcnntemp, ThIcnnna, ref Tjilumnna);

templlp.Add(Tjilumnna); fanhuituxiang.Add(ThIcnnna);

maxpooling(4, 4, 8, 8, ThIcnntemp1, ThIcnn1na, ref Tjilumn1na);

templlp.Add(Tjilumn1na); fanhuituxiang.Add(ThIcnn1na);

maxpooling(4, 4, 8, 8, ThIcnntemp2, ThIcnn2na, ref Tjilumn2na);

templlp.Add(Tjilumn2na); fanhuituxiang.Add(ThIcnn2na);

maxpooling(4, 4, 8, 8, ThIcnntemp3, ThIcnn3na, ref Tjilumn3na); //程序中的0初始化值，已经核实过，是ok的20250712

templlp.Add(Tjilumn3na); fanhuituxiang.Add(ThIcnn3na);

return templlp;

}

double\[\] softm = new double $10$ ;

double\[\] xI = new double $28 \* 28$ ;

int\[\] d = new int $10$ ;

void traincnn(int cas)

{

//是否需要重置deltaB？deltaW？在minibatch中？要

xI = hello28 $cas$ ;//28*28

int num = labels $cas$ ;

d = new int $10$ ;

d $num$ = 1;

cnnforward();

int ans = getAnsSoftmaxcnn();

if (num == ans)

last $cas$ = 1;

softm $num$ = softm $num$ - 1;

backcnn();

}

public double\[\] 更新卷积核(double\[\] 中间值, int 卷积核序号, double\[\] 图像, double $,$ 卷积核)//=4,=5,卷积核序号从1开始

{

//第四个卷积核202409191112

double\[\] deltacnn3 = new double $16$ ;//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核

int kk = 0;

int tidai = 卷积核序号 - 1;

int temp = (tidai) * 16;

for (int i = temp; i < temp + 16; i++)

{

for (int j = 0; j < 80; j++)//15

{

// deltacnn3 $kk$ = 中间值 $j$ * w12cnn $i, j$ * dsigmoid(hocnnhebing $i$ );

// 临时记录dbhIO $i$ =?这个怎么办？202502271112

deltacnn3 $kk$ += 中间值 $j$ * w12cnn $i, j$ * dNDrelu(hocnnhebing $i$ );

}

// deltacnn3 $kk$ /= 80;

kk++;

}

//for (int i = 0; i < 16; i++)

//{

// Point temppt = 求二维(i, hebingpos $tidai$ $i$ .Y, hebingpos $tidai$ $i$ .X);//3代表第si波16个

// for (int k = 0; k < 5; k++)

// for (int z = 0; z < 5; z++)

// {

// int newIndex = (temppt.Y + k) * 12 + (temppt.X + z);

// double delta = 图像 $newIndex$ * deltacnn3 $i$ ;//一共25个

// // w1cnn1 $k \* 5 + z, 卷积核序号 - 1$ -= delta * learnRate;

// 卷积核 $k \* 5 + z, (tidai) % 4$ -= delta * learnRate;

// }

return deltacnn3;

}

public void last更新卷积核minibatch(double\[\] 更新卷积核ret, int 卷积核序号, double\[\] 图像, double $,$ 卷积核)//=4,=5,卷积核序号从1开始

{

int tidai = 卷积核序号 - 1;

for (int i = 0; i < 16; i++)

{

Point temppt = 求二维(i, hebingpos $tidai$ $i$ .Y, hebingpos $tidai$ $i$ .X);//3代表第si波16个

for (int k = 0; k < 5; k++)

for (int z = 0; z < 5; z++)

{

int newIndex = (temppt.Y + k) * 12 + (temppt.X + z);

// 更新卷积核ret $i$ += 图像 $newIndex$ * 更新卷积核ret $i$ ;//一共25个

卷积核 $k \* 5 + z, (tidai) % 4$ += 图像 $newIndex$ * 更新卷积核ret $i$ ;

//// w1cnn1 $k \* 5 + z, 卷积核序号 - 1$ -= delta * learnRate;

//卷积核 $k \* 5 + z, (tidai) % 4$ -= delta * learnRate;

}

//// 更新卷积核ret $i$ = 更新卷积核ret $i$ / 25f;

// for (int k = 0; k < 25; k++)

// { 卷积核 $k, (tidai) % 4$ /= 16; }

}

public void last更新卷积核(double\[\] 更新卷积核ret, int 卷积核序号, double\[\] 图像, double $,$ 卷积核)//=4,=5,卷积核序号从1开始

{

int tidai = 卷积核序号 - 1;

for (int i = 0; i < 16; i++)

{

Point temppt = 求二维(i, hebingpos $tidai$ $i$ .Y, hebingpos $tidai$ $i$ .X);//3代表第si波16个

for (int k = 0; k < 5; k++)

for (int z = 0; z < 5; z++)

{

int newIndex = (temppt.Y + k) * 12 + (temppt.X + z);

double delta = 图像 $newIndex$ * 更新卷积核ret $i$ ;//一共25个

// w1cnn1 $k \* 5 + z, 卷积核序号 - 1$ -= delta * learnRate;

卷积核 $k \* 5 + z, (tidai) % 4$ -= delta * learnRate;

}

public Point 求二维(int index, int mm, int nn)

{

Point rePt = new Point();

for (int i = 0; i < 5; i++)

for (int j = 0; j < 5; j++)

{

int n = i * 5 + j;

if (index == n)

{

int h = i * 2 + mm;

int w = j * 2 + nn;

rePt.X = w;

rePt.Y = h;

i = 5;

j = 5;//end 2 for loop;

}

return rePt;

}

void 求deltaW576( double\[\] deltacnnx, double $,$ w1cnnx,int 指定核, List<Point> 记录mn,double\[\] deltaW576, double\[\] hI遗忘图,int pool1W=12,int pool1前原图W=28)

{

double\[\] deltacnnXx = new double $16$ ;

for (int i = 0; i < 16; i++)//16

{

for (int j = 0; j < 25; j++)//25

{

deltacnnXx $i$ += deltacnnx $i$ * w1cnnx $j, 指定核$ ;

}

// deltacnnXx $i$ /= 25;//图像中有25个位置导致

}

// double\[\] delta576w0 = new double $25$ ;

for (int i = 0; i < 16; i++)

{

Point temppt = 求二维(i, 记录mn $i$ .Y, 记录mn $i$ .X);

for (int k = 0; k < 5; k++)

for (int z = 0; z < 5; z++)

{

int newIndex = (temppt.Y + k) * pool1前原图W + (temppt.X + z);

int biasIndex = (temppt.Y / 2 + k) * pool1W + temppt.X / 2 + z;

//double delta = deltacnnX $i$ * dNDrelu(hI遗忘 $biasIndex$ ) * learnRate;//一共25个，12*12=hI遗忘

//w576cnn $k \* 5 + z, 0$ -= xI $newIndex$ * delta;//28*28，更新四个卷积核，先不更新，想用minibatch，10次运算，更新一次

double delta = deltacnnXx $i$ * dNDrelu(hI遗忘图 $biasIndex$ );//一共25个，12*12=hI遗忘

deltaW576 $k \* 5 + z$ += xI $newIndex$ * delta;//28*28，更新四个卷积核，先不更新，想用minibatch，10次运算，更新一次

//deltaW576 $k \* 5 + z$ = xI $newIndex$ * delta;//28*28，更新四个卷积核，先不更新，想用minibatch，10次运算，更新一次

}

//for (int k = 0; k < 25; k++)

//{

// deltaW576 $k$ /= 16f;

//}

}

//反向传播函数

double $,$ 临时dzw2 = new double $80, 10$ ;

double $,$ 临时dzw12 = new double $16 \* 4 \* 4, 80$ ;

double\[\] delta576w00 = new double $25$ ;

double\[\] delta576w01 = new double $25$ ;

double\[\] delta576w02 = new double $25$ ;

double\[\] delta576w03 = new double $25$ ;

double\[\] delta576w10 = new double $25$ ;

double\[\] delta576w11 = new double $25$ ;

double\[\] delta576w12 = new double $25$ ;

double\[\] delta576w13 = new double $25$ ;

double\[\] delta576w20 = new double $25$ ;

double\[\] delta576w21 = new double $25$ ;

double\[\] delta576w22 = new double $25$ ;

double\[\] delta576w23 = new double $25$ ;

double\[\] delta576w30 = new double $25$ ;

double\[\] delta576w31 = new double $25$ ;

double\[\] delta576w32 = new double $25$ ;

double\[\] delta576w33 = new double $25$ ;

void backcnn()//应该引入结局b的更新，这样可以加快收敛速度202409140818

{

double\[\] 替代 = new double $10$ ;

//double $,$ 临时dzw2 = new double $80, 10$ ;

//double $,$ 临时dzw12 = new double $16\*4\*4, 80$ ;

////更新delta w1cnn【25，4】《--来自临时dzw12【0-63，80】，第一4*4*4

////更新delta w2cnn【25，4】《--来自临时dzw12【64-127，80】，第二4*4*4

////更新delta w3cnn【25，4】《--来自临时dzw12【128-191，80】，第三4*4*4

////更新delta w4cnn【25，4】《--来自临时dzw12【191-255，80】，第四4*4*4

//double\[\] 临时记录dby = new double $10$ ;

//double\[\] 临时记录dbhI2O = new double $80$ ;

//double\[\] 临时记录dbhIO = new double $256$ ;

//////double\[\] 临时记录db = new double $144$ ;

//////double\[\] 临时记录db1 = new double $144$ ;

//////double\[\] 临时记录db2 = new double $144$ ;

//////double\[\] 临时记录db3 = new double $144$ ;

double\[\] deltacnn = new double $16$ ;

double\[\] deltacnn1 = new double $16$ ;

double\[\] deltacnn2 = new double $16$ ;

double\[\] deltacnn3 = new double $16$ ;

double\[\] deltacnn5 = new double $16$ ;

double\[\] deltacnn6 = new double $16$ ;

double\[\] deltacnn7 = new double $16$ ;

double\[\] deltacnn8 = new double $16$ ;

double\[\] deltacnn9 = new double $16$ ;

double\[\] deltacnn10 = new double $16$ ;

double\[\] deltacnn11 = new double $16$ ;

double\[\] deltacnn12 = new double $16$ ;

double\[\] deltacnn13 = new double $16$ ;//卷积核w1cnn4 $25,0$ ，5*5的卷积核

double\[\] deltacnn14 = new double $16$ ;//卷积核w1cnn4 $25,1$

double\[\] deltacnn15 = new double $16$ ;//卷积核w1cnn4 $25,2$

double\[\] deltacnn16 = new double $16$ ;//卷积核w1cnn4 $25,3$

for (int j = 0; j < 10; j++)//10

{

// 临时记录dby $j$ =

替代 $j$ = softm $j$ * dNDrelu(yOcnn $j$ );

for (int i = 0; i < 80; i++)//15

{

临时dzw2 $i, j$ += 替代 $j$ * hO2cnn $i$ ;//这里出现+的原因是batch导致的20260401

}

double\[\] W3 = new double $80$ ;//

for (int j = 0; j < 80; j++)//

for (int k = 0; k < 10; k++)//10

W3 $j$ += 替代 $k$ * w2cnn $j, k$ ;

double\[\] 替代2 = new double $80$ ;

for (int j = 0; j < 80; j++)//

{

// 临时记录dbhI2O $j$ =

替代2 $j$ = dNDrelu(hO2cnn $j$ ) * W3 $j$ ;

for (int i = 0; i < 16 * 16; i++)//256

{

临时dzw12 $i, j$ += 替代2 $j$ * (hocnnhebing $i$ ); //这里出现+的原因是batch导致的20260401

}

//上头是全连接

//下头是卷积核，处理变得不一样，头4个与与w1cnn有关，

//即第一4*4*4=64，更新deltaw1cnn【25，0】，更新deltaw1cnn【25，1】，

//更新deltaw1cnn【25，2】，更新deltaw1cnn【25，3】

//卷积核中一个元素，在图像中可以找到很多位置，这个问题怎么办？202507121726

//取均值，有80，求和后，除80，如果有25，求和后，除以25，试试看，公式中没给出表达，办法比问题多。

for (int i = 0; i < 16; i++)//25

{

for (int j = 0; j < 80; j++)//

{

// 临时记录dbhIO $i$ =

deltacnn $i$ += 替代2 $j$ * w12cnn $i, j$ * dNDrelu(hocnnhebing $i$ );//与w1cnn有关

}//全连接还是好处理202409200708

// deltacnn $i$ /= 80;//80次，取个均值

}

//另一个卷积核202409191112

//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核

for (int i = 16; i < 32; i++)//25

{

for (int j = 0; j < 80; j++)//

{

// 临时记录dbhIO $i$ =

deltacnn1 $i - 16$ += 替代2 $j$ * w12cnn $i, j$ * dNDrelu(hocnnhebing $i$ );//与w1cnn有关

}

// deltacnn1 $i - 16$ /= 80;//80次，取个均值

}

//第三个卷积核202409191112

//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核

for (int i = 32; i < 48; i++)//25

{

for (int j = 0; j < 80; j++)//

{

// 临时记录dbhIO $i$ =

deltacnn2 $i - 32$ += 替代2 $j$ * w12cnn $i, j$ * dNDrelu(hocnnhebing $i$ );//与w1cnn有关

}

// deltacnn2 $i - 32$ /= 80;//80次，取个均值

}

//第四个卷积核202409191112

//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核

for (int i = 48; i < 64; i++)//25

{

for (int j = 0; j < 80; j++)//15

{

// 临时记录dbhIO $i$ =

deltacnn3 $i - 48$ += 替代2 $j$ * w12cnn $i, j$ * dNDrelu(hocnnhebing $i$ );//与w1cnn有关

}

// deltacnn3 $i - 48$ /= 80;//80次，取个均值

}

//4个卷积核已经更新完，下面第5个到16

deltacnn5 = 更新卷积核(替代2, 5, hIcnn1na, w1cnn2);//5->0,w1cnn2 $25,(5 - 1) % 4$ ->w1cnn2 $25,(6 - 1) % 4$ ->w1cnn2 $25,(7 - 1) % 4$ ->w1cnn2 $25,(8 - 1) % 4$

deltacnn6 = 更新卷积核(替代2, 6, hIcnn1na, w1cnn2);

deltacnn7 = 更新卷积核(替代2, 7, hIcnn1na, w1cnn2);

deltacnn8 = 更新卷积核(替代2, 8, hIcnn1na, w1cnn2);

deltacnn9 = 更新卷积核(替代2, 9, hIcnn2na, w1cnn3);//9->0,w1cnn3 $25,(9- 1) % 4$ ->w1cnn3 $25,(10 - 1) % 4$ ->w1cnn3 $25,(11- 1) % 4$ ->w1cnn3 $25,(12 - 1) % 4$

deltacnn10 = 更新卷积核(替代2, 10, hIcnn2na, w1cnn3);

deltacnn11 = 更新卷积核(替代2, 11, hIcnn2na, w1cnn3);

deltacnn12 = 更新卷积核(替代2, 12, hIcnn2na, w1cnn3);

deltacnn13 = 更新卷积核(替代2, 13, hIcnn3na, w1cnn4);//卷积核w1cnn4 $25,0$ ，5*5的卷积核

deltacnn14 = 更新卷积核(替代2, 14, hIcnn3na, w1cnn4);//卷积核w1cnn4 $25,1$

deltacnn15 = 更新卷积核(替代2, 15, hIcnn3na, w1cnn4);//卷积核w1cnn4 $25,2$

deltacnn16 = 更新卷积核(替代2, 16, hIcnn3na, w1cnn4);//卷积核w1cnn4 $25,3$ //hIcnn3na是12*12的图像《-8**《-4*4，backup

//for (int i = 0; i < 16; i++)//四个没有更新，发现一个delta|B错误202507130520，为改正，屏蔽

//{

// 临时记录dbhIO $64 + i$ = deltacnn5 $i$ ;

// 临时记录dbhIO $64 + 16 + i$ = deltacnn6 $i$ ;

// 临时记录dbhIO $64 + 16 \* 2 + i$ = deltacnn7 $i$ ;

// 临时记录dbhIO $64 + 16 \* 3 + i$ = deltacnn8 $i$ ;

// 临时记录dbhIO $64 + 16 \* 4 + i$ = deltacnn9 $i$ ;

// 临时记录dbhIO $64 + 16 \* 5 + i$ = deltacnn10 $i$ ;

// 临时记录dbhIO $64 + 16 \* 6 + i$ = deltacnn11 $i$ ;

// 临时记录dbhIO $64 + 16 \* 7 + i$ = deltacnn12 $i$ ;

// 临时记录dbhIO $64 + 16 \* 8 + i$ = deltacnn13 $i$ ;

// 临时记录dbhIO $64 + 16 \* 9 + i$ = deltacnn14 $i$ ;

// 临时记录dbhIO $64 + 16 \* 10 + i$ = deltacnn15 $i$ ;

// 临时记录dbhIO $64 + 16 \* 11 + i$ = deltacnn16 $i$ ;

//}

////继续向上，四个卷积核刚好对应一副原始图像，即四个卷积核向上对应一个卷积核28*28-》24*24-》12*12

////卷积核w1cnn $25,4$ 对应xI $k$ * w576cnn $m \* 5 + n, 0$

////卷积核w1cnn1 $25,4$ 对应xI $k$ * w576cnn $m \* 5 + n, 1$

// double\[\] deltacnnX = new double $16$ ;//每一个deltacnnx，都对应25个28*28中的数据元素，以及一个5*5的卷积核

求deltaW576( deltacnn, w1cnn, 0, jilumnna, delta576w00, hI遗忘);

求deltaW576( deltacnn1, w1cnn, 1, jilumnna, delta576w01, hI遗忘);

求deltaW576( deltacnn2, w1cnn, 2, jilumnna, delta576w02, hI遗忘);

求deltaW576( deltacnn3, w1cnn, 3, jilumnna, delta576w03, hI遗忘);

//第二轮开

求deltaW576( deltacnn5, w1cnn2, 0, jilumn1na, delta576w10, hI遗忘1);

求deltaW576( deltacnn6, w1cnn2, 1, jilumn1na, delta576w11, hI遗忘1);

求deltaW576( deltacnn7, w1cnn2, 2, jilumn1na, delta576w12, hI遗忘1);

求deltaW576( deltacnn8, w1cnn2, 3, jilumn1na, delta576w13, hI遗忘1);

//第san轮开始

求deltaW576( deltacnn9, w1cnn3, 0, jilumn2na, delta576w20, hI遗忘2);

求deltaW576( deltacnn10, w1cnn3, 1, jilumn2na, delta576w21, hI遗忘2);

求deltaW576( deltacnn11, w1cnn3, 2, jilumn2na, delta576w22, hI遗忘2);

求deltaW576( deltacnn12, w1cnn3, 3, jilumn2na, delta576w23, hI遗忘2);

////最后yilun

求deltaW576( deltacnn13, w1cnn4, 0, jilumn3na, delta576w30, hI遗忘3);

求deltaW576( deltacnn14, w1cnn4, 1, jilumn3na, delta576w31, hI遗忘3);

求deltaW576( deltacnn15, w1cnn4, 2, jilumn3na, delta576w32, hI遗忘3);

求deltaW576( deltacnn16, w1cnn4, 3, jilumn3na, delta576w33, hI遗忘3);

////最后更新d

//for (int j = 0; j < 10; j++)//10

// for (int i = 0; i < 80; i++)//15

// {

// w2cnn $i, j$ -= learnRate * 临时dzw2 $i, j$ ;

// }

//for (int j = 0; j < 80; j++)//15

// for (int i = 0; i < 16 * 16; i++)//256

// {

// w12cnn $i, j$ -= learnRate * 临时dzw12 $i, j$ ;

// }

////for (int i = 0; i < 10; i++)

////{

//// bycnn $i$ -= learnRate * 临时记录dby $i$ ;

////}

////for (int i = 0; i < 80; i++)

////{

//// bI2Ocnn $i$ -= learnRate * 临时记录dbhI2O $i$ ;

////}

////for (int i = 0; i < 256; i++)

////{

//// bIOcnn $i$ -= learnRate * 临时记录dbhIO $i$ ;

////}

//last更新卷积核(deltacnn, 1, hIcnnna, w1cnn);

//last更新卷积核(deltacnn1, 2, hIcnnna, w1cnn);

//last更新卷积核(deltacnn2, 3, hIcnnna, w1cnn);

//last更新卷积核(deltacnn3, 4, hIcnnna, w1cnn);

//last更新卷积核(deltacnn5, 5, hIcnn1na, w1cnn2);

//last更新卷积核(deltacnn6, 6, hIcnn1na, w1cnn2);

//last更新卷积核(deltacnn7, 7, hIcnn1na, w1cnn2);

//last更新卷积核(deltacnn8, 8, hIcnn1na, w1cnn2);

//last更新卷积核(deltacnn9, 9, hIcnn2na, w1cnn3);

//last更新卷积核(deltacnn10, 10, hIcnn2na, w1cnn3);

//last更新卷积核(deltacnn11, 11, hIcnn2na, w1cnn3);

//last更新卷积核(deltacnn12, 12, hIcnn2na, w1cnn3);

//last更新卷积核(deltacnn13, 13, hIcnn3na, w1cnn4);

//last更新卷积核(deltacnn14, 14, hIcnn3na, w1cnn4);

//last更新卷积核(deltacnn15, 15, hIcnn3na, w1cnn4);

//last更新卷积核(deltacnn16, 16, hIcnn3na, w1cnn4);

//for (int i = 0; i < 25; i++)

//{

// w576cnn $i, 0$ -= (delta576w03 $i$ + delta576w02 $i$ + delta576w01 $i$ + delta576w00 $i$ ) / 4 * learnRate;

//}

//for (int i = 0; i < 25; i++)

//{

// w576cnn $i, 1$ -= (delta576w13 $i$ + delta576w12 $i$ + delta576w11 $i$ + delta576w10 $i$ ) / 4 * learnRate;

//}

//for (int i = 0; i < 25; i++)

//{

// w576cnn $i, 2$ -= (delta576w23 $i$ + delta576w22 $i$ + delta576w21 $i$ + delta576w20 $i$ ) / 4 * learnRate;

//}

//for (int i = 0; i < 25; i++)

//{

// w576cnn $i, 3$ -= (delta576w33 $i$ + delta576w32 $i$ + delta576w31 $i$ + delta576w30 $i$ ) / 4 * learnRate;

//}

last更新卷积核minibatch(deltacnn, 1, hIcnnna, delw1cnn);

last更新卷积核minibatch(deltacnn1, 2, hIcnnna, delw1cnn);

last更新卷积核minibatch(deltacnn2, 3, hIcnnna, delw1cnn);

last更新卷积核minibatch(deltacnn3, 4, hIcnnna, delw1cnn);

last更新卷积核minibatch(deltacnn5, 5, hIcnn1na, delw1cnn2);

last更新卷积核minibatch(deltacnn6, 6, hIcnn1na, delw1cnn2);

last更新卷积核minibatch(deltacnn7, 7, hIcnn1na, delw1cnn2);

last更新卷积核minibatch(deltacnn8, 8, hIcnn1na, delw1cnn2);

last更新卷积核minibatch(deltacnn9, 9, hIcnn2na, delw1cnn3);

last更新卷积核minibatch(deltacnn10, 10, hIcnn2na, delw1cnn3);

last更新卷积核minibatch(deltacnn11, 11, hIcnn2na, delw1cnn3);

last更新卷积核minibatch(deltacnn12, 12, hIcnn2na, delw1cnn3);

last更新卷积核minibatch(deltacnn13, 13, hIcnn3na, delw1cnn4);

last更新卷积核minibatch(deltacnn14, 14, hIcnn3na, delw1cnn4);

last更新卷积核minibatch(deltacnn15, 15, hIcnn3na, delw1cnn4);

last更新卷积核minibatch(deltacnn16, 16, hIcnn3na, delw1cnn4);

}

int getAnsSoftmaxcnn()

{

int ans = 0;

for (int i = 1; i <10; i++)

if (softm $i$ > softm $ans$ ) ans = i;

return ans;

}

private void button31_Click(object sender, EventArgs e)

{

Bitmap curBitmap = (Bitmap)pictureBox20.Image;

Rectangle rc = new Rectangle(0, 0, curBitmap.Width, curBitmap.Height);

System.Drawing.Imaging.BitmapData bmpdata = curBitmap.LockBits(rc,

System.Drawing.Imaging.ImageLockMode.ReadWrite,

curBitmap.PixelFormat);

IntPtr imageptr = bmpdata.Scan0;

int ww = curBitmap.Width;

int hh = curBitmap.Height;

int bytes = 0;

if (curBitmap.PixelFormat == PixelFormat.Format24bppRgb)

{

bytes = ww * hh * 3;//此处针对的是24位位图

}

byte\[\] rgbValues = new byte $bytes$ ;

System.Runtime.InteropServices.Marshal.Copy(imageptr, rgbValues, 0, bytes);

curBitmap.UnlockBits(bmpdata);

// showbuffer2pictmod4(showoutput14, 14, 14, pictureBox10);

byte\[\] buffer8 = new byte $28 \* 28$ ;

double\[\] buffer8d = new double $28 \* 28$ ;

if (curBitmap.PixelFormat == PixelFormat.Format24bppRgb)

{

for (int ii = 0; ii < 28; ii++)

{

for (int j = 0; j < 28; j++)

{

int n = ii * 28 + j;

int k = (ii) * 28 + j;

// int m = 3 * k;

buffer8 $k$ = rgbValues $n \* 3$ ;//这里都是灰度图像20221209

// buffer8 $k$ = (byte)(0.3 * rgbValues $n \* 3 + 2$ + 0.59 * rgbValues $n \* 3 + 1$ + 0.11 * rgbValues $n \* 3$ );//这里是1024*768图像

buffer8d $k$ = rgbValues $n \* 3$ / 255f;//这里都是灰度图像20221209

}

showbuffer2pictmod4(buffer8, 28, 28, pictureBox20);

textBox51.Text = "";

xI = buffer8d;

cnnforward();

// int ans = getAnscnn();

int ans = getAnsSoftmaxcnn();

for (int i = 0; i < 10; i++)

textBox51.Text += ((float)softm $i$ ).ToString() + "\r\n";

textBox49.Text = ans.ToString() + ";" + ((float)yOcnn $ans$ ).ToString();

}

private void button30_Click(object sender, EventArgs e)

{

showbuffer2pictmod4(new byte $28 \* 28$ , 28, 28, pictureBox20);

}

Bitmap weitu28;

float bilix28 = 0; float biliy28 = 0;

private void pictureBox20_MouseMove(object sender, MouseEventArgs e)

{

if (huax28)

{

Graphics g = pictureBox20.CreateGraphics();

g.DrawLine(new Pen(Color.White, 12f), qidianx28, new Point(e.X, e.Y));//huabi gao kuai yidian

// Bitmap curBitmap = (Bitmap)pictureBox9.Image;

//curBitmap.SetPixel(e.X, e.Y, Color.White);

//weitu28.SetPixel((int)(e.X * bilix28), (int)(e.Y * biliy28), Color.White); ;

try

{

weitu28.SetPixel((int)(qidianx28.X * bilix28), (int)(qidianx28.Y * biliy28 - 1), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(qidianx28.X * bilix28), (int)(qidianx28.Y * biliy28 + 1), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(qidianx28.X * bilix28), (int)(qidianx28.Y * biliy28), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(qidianx28.X * bilix28 - 1), (int)(qidianx28.Y * biliy28), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(qidianx28.X * bilix28 + 1), (int)(qidianx28.Y * biliy28), Color.FromArgb(255, 255, 255));

qidianx28 = new Point(e.X, e.Y);

weitu28.SetPixel((int)(e.X * bilix28 - 1), (int)(e.Y * biliy28 - 1), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(e.X * bilix28 + 1), (int)(e.Y * biliy28 + 1), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(e.X * bilix28), (int)(e.Y * biliy28), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(e.X * bilix28 - 1), (int)(e.Y * biliy28 + 1), Color.FromArgb(255, 255, 255));

weitu28.SetPixel((int)(e.X * bilix28 + 1), (int)(e.Y * biliy28 - 1), Color.FromArgb(255, 255, 255));

}

catch (Exception ee)

{ }

}

private void pictureBox20_MouseDown(object sender, MouseEventArgs e)

{

weitu28 = (Bitmap)pictureBox20.Image;

bilix28 = weitu28.Width * 1f / pictureBox20.Width;

biliy28 = weitu28.Height * 1f / pictureBox20.Height;

if (MouseButtons.Left == e.Button)

{

qidianx28.X = e.X;

qidianx28.Y = e.Y;

// e.Button

huax28 = true;

}

Point qidianx28 = new Point();

bool huax28 = false;

private void pictureBox20_MouseUp(object sender, MouseEventArgs e)

{

huax28 = false;

}

private void textBox1_TextChanged(object sender, EventArgs e)

{

this.learnRate = Convert.ToDouble(textBox1.Text);

}