cnn突破一（先搞定三层反馈神经网络bpnet，c#实现）

惦记cnn很久了，一直搞机器视觉，走不出来，现在megauging已经实现，说明书也写了不少，该突破的突破了，该改进的也改进了，一个心病治好了，有空把人工智能在机器视觉上的延伸，补一补。自己也是一直认为，人工智能是在机器视觉上发展起来的，所以做这些事情，也是顺理成章。

前头有几篇自己研究bpnet的资料，不成气候，现在可以补齐。

后面的突破，那些个前面bpnet的公式推导仍然是必不可少，我这里就省略了。

网上看到有c++手写数字识别（基于mnist数据集），顺便翻译成c#，但没有成功，直觉上估计是自己在翻译二维数组过程中有问题，因为数学的推导，我已经反复核对过了！

c++有兴趣的可以参考：利用c++编写bp神经网络实现手写数字识别详解 - AlphaInf - 博客园

后来发现，直觉不对，二维数组没错，错了两处：

1，c++和c#的random函数使用不同

2，d【10】这个数组初始化不对

然后，我觉得学习的时间太长，就改进了一下，具体如下：

28*28的图像，使用3*3的高斯核平滑，然后隔行隔列取像素，形成14*14的图像，然后全连接：

196-》128-》10，或者196-》80-》10，训练结果都很好，自己要求不很高，达到95分就行。

下面是自己的c#代码：

  double learnRate = 0.2f; //学习率 
        int n = 196; //输入层点个数 
        int p = 128; //隐藏层节点个数 
        int q = 10; //输出层节点个数 

        //与推导公式保持一致 
        //double x[n],hi[p],ho[p],yi[q],yo[q],d[q];
        double[] xI = new double[14*14];
        double[] hI = new double[128];
        double[] hO = new double[128];

        double[] yi = new double[10];
        double[] yO = new double[10];
        //所训练的网络，采用两个矩阵表示 
        double[,] w1 = new double[196, 128];
        double[,] w2 = new double[128, 10];

  void init()
        {
            Random ran = new Random();
          
            for (int i = 0; i < n; i++)
                for (int j = 0; j < p; j++)
                {
                 
                    //  w1[i, j] = 0.1;
                 

                     w1[i,j]  = ran.Next(-100, 100)/100f;
                  //  w1[i][j] = ran.Next(0, 65535) % 10 / 5f - 1;
                }
            //zhege zhengfu yi zhijian henmiao20240912
           
            for (int i = 0; i < p; i++)
                for (int j = 0; j < q; j++)
                {
                   
                    // w2[i, j] = 0.1;

                    w2[i,j] = ran.Next(-100, 100) / 100f;
                    // w2[i][j] = ran.Next(0, 65535) % 10 / 5f - 1;
                }

}

以上初始化要说明的是：权重都初始化为【-1,1】之间的随机数，图像每个像素除以255，图像每个像素归一化到【0,1】

   int[] d = new int[10];
        int[] last = new int[60000];
        //激活函数 
        public double sigmoid(double x)
        {
            return 1 / (1f + Math.Exp(-x));
        }
        //前向传播函数 
        public void forward()
        {
            //计算hi前需要对其进行清空 
            //  memset(hi, 0, sizeof(hi));
            hI = new double[128];
            //通过w1计算输入层-隐藏层输入节点 
            for (int i = 0; i < n; i++)//196
                for (int j = 0; j < p; j++)//128

                    hI[j] += xI[i] * w1[i,j];

            //通过激活函数对隐藏层进行计算 
            for (int i = 0; i < p; i++)
                //hO[i] = sigmoid(hI[i]+bh[i]);
                hO[i] = sigmoid(hI[i] );
            计算yi前需要对其进行清空 
            //memset(yi, 0, sizeof(yi));
            yi = new double[10];
            //通过w2计算隐藏层-输出层
            for (int i = 0; i < p; i++)
                for (int j = 0; j < q; j++)

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

            //通过激活函数求yo
            for (int i = 0; i < q; i++)
                //yO[i] = sigmoid(yi[i]+by[i]);
                yO[i] = sigmoid(yi[i] );
        }
        //判断输出的答案是多少 
        int getAns()
        {
            int ans = 0;
            for (int i = 1; i < q; i++)
                if (yO[i] > yO[ans]) ans = i;
            return ans;
        }

下面是训练函数：

  void train(int cas)
        {
           
      
            xI = hello[cas];

         
            int num = labels[cas];
            d = new int[10]; 
            d[num] = 1;
           

            forward();
            int ans = getAns();
            if (num == ans)
                last[cas] = 1;
            back();
        }

上面训练函数中xI = hello[cas];来自下面对mnist数据集的解析：高斯化和归一化都在里头：

   double[][] hello = new double[60000][];
        void ReadMnistImages(string filePath)
        {
            using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            using (BinaryReader reader = new BinaryReader(fileStream))
            {
                // 跳过文件头的前16个字节
                reader.ReadBytes(16);
                int h = 28;
                int w = 28;
                while (fileStream.Position < fileStream.Length)
                {
                    byte[] image = reader.ReadBytes(28 * 28); // MNIST图像大小为28x28
                    处理图像数据
                    byte[] showoutput = new byte[28 * 28];
                    //Blur(image, showoutput, 28, 28, 5);
                    ...

                    for (int j = 1; j < (h - 1); j++)
                    {
                        for (int i = 1; i < (w - 1); i++)
                        {
                            int n0 = (j * w + i);
                            int wo = (image[n0 - w - 1] + 2 * image[n0 - w] + image[n0 - w + 1] +
                                                    2 * image[n0 - 1] + 4 * image[n0] + 2 * image[n0 + 1] +
                                                    image[n0 + w - 1] + 2 * image[n0 + w] + image[n0 + w + 1]);//未作除以16
                            showoutput[n0] = (byte)(wo >> 4);//完成除以16
                        }
                    }

                 
                    byte[] showoutput14 = new byte[14 * 14];
                    int k = 0;
                    for (int j = 1; j < 28; j += 2)
                    {
                        for (int i = 1; i < 28; i += 2)
                        {
                            int nn = j * 28 + i;
                            showoutput14[k] = showoutput[nn];
                           
                            k++;

                        }
                    }
                    gaoshoutuxiang196.Add(showoutput14);
                }
             //while循环完成60000图片的读取和高斯处理

//下面for循环完成60000图片在【0,1】的归一化

                for (int xx = 0; xx < 60000; xx++)
                {
                    hello[xx] = new double[196];
                    for (int i = 0; i < 196; i++)
                    {
                        hello[xx][i] = gaoshoutuxiang196[xx][i] / 255f;
                    }
                    
                }
            }
        }

下面是反传播back（）函数：

 public double dsigmoid(double x)
        {
            return x * (1 - x);
        }
        //反向传播函数 
        void back()
        {
            //对w2进行更新 
            for (int i = 0; i < p; i++)//128
                for (int j = 0; j < q; j++)//10
                {
                  
                    double delta = (yO[j] - d[j]) * dsigmoid(yO[j]) ;//图像28*28是ling，则标签是0，d[]={1,0,0,0,0,0,0,0,0,0};图像28*28是wu，则标签是5，d[]={0,0,0,0,0,1,0,0,0,0}
                    w2[i, j] -= delta * learnRate * hO[i];
          
                }

            //对反向传播进行预处理 
           
            double[] W2 = new double[p];//p=128
            //    memset(W2,0,sizeof(W2));
            for (int j = 0; j < p; j++)
                for (int k = 0; k < q; k++)
                    W2[j] += (yO[k] - d[k]) * dsigmoid(yO[k]) * w2[j,k];//图像28*28是壹，则标签是1，d[]={0,1,0,0,0,0,0,0,0,0};图像28*28是jiu，则标签是9，d[]={0,0,0,0,0,0,0,0,0,1}

            //对w1进行更新
            for (int i = 0; i < n; i++)//196
                for (int j = 0; j < p; j++)
                {
                    double delta = dsigmoid(hO[j]) * xI[i] * W2[j];
                    w1[i,j] -= delta * learnRate;
                }
         
        }

最后就是调用执行，学习训练60000万次，以及把最后十次结果显示出来：

    private void button1trainMnist_Click(object sender, EventArgs e)
        {
            DateTime dt = DateTime.Now;
         
            for (int cas = 0; cas < 60000; cas++)
            {
                train(cas);
            }
       
            int P = 100;
       
            int he = 59000;
            for (int n = 0; n < 9; n++)
            {
                int hh = 0;
                for (int i = 0; i < P; i++)
                {
                    hh += last[he + i];

                }
                textBox42对比信息.Text += he.ToString() + "," + hh.ToString() + "\r\n";
                he += 100;
            }
           
            TimeSpan sp = DateTime.Now - dt;
            textBox44.Text = sp.ToString();
        }

c++程序和我这个程序都没有引入bias，其实正如c++作者所言，97分

后来我引入了bias【】，觉得正规一些，发现，反而不如这个程序！

原因是，bias【】更新计算对了，但写的地方不对导致学习成绩下降成绩，这是一个很隐蔽的错误，接下来，我会讲到，很久才发现bug，很崩溃，一度不想用bias【】！

今天先到这里！