cnn突破三

cnn，是卷积核神经网络，前面讲的没有卷积核，所以这里，我们在前面三层bpnet网络的基础上，增加卷积核试一试！

所有的启发来自，28*28变14*14的那个常用的高斯卷积核，我们前面的网络实际是：28*28->3*3卷积后，隔行隔列抠图（相当于池化）->14*14->128->10

下面，我们就是仿照上面，我们不再使用高斯核，而是让他自己产生四个卷积核(看看是什么鬼！）：

即14*14->4*10*10->4*5*5->80->10，结论是：

改成14*14*4-10*10*4-5*5*4-80-10，学习6万次，均分大于90，小于95，我们先看结果：

我们训练学习了12万次，达到95分，用鼠标画了个2，识别出来了，得分99，不错，说明四个卷积核有了，我们把mnist原图的2，用学到的卷积核处理后的四个图像也有了，太神奇！

下面是c#实现源码，请对比前面三层bpnet网络看：

先初始化了四个卷积核：

   double[,] w1cnn = new double[25, 4]; double[,] w12cnn = new double[100, 80];

  double[,] w2cnn = new double[80, 10];

 //for cnn202409181004
              for (int i = 0; i <25; i++)
                  for (int j = 0; j < 4; j++)
                  {
                      w1cnn[i, j] = ran.Next(-100, 100) / 100f;
                 
                  }
         
              for (int i = 0; i <100; i++)
               
                  for (int j = 0; j < 80; j++)
                  {               
                      w12cnn[i, j] = ran.Next(-100, 100) / 100f;                    
                  }
            
              for (int i = 0; i < 80; i++)
                  for (int j = 0; j < 10; j++)
                  {
                      w2cnn[i, j] = ran.Next(-100, 100) / 100f;
                  }

然后，你对比前头的三层网络：forward（）函数中增加如下：

forward第一步：14*14的图像用5*5的四个卷积核操作，变成4*10*10

  for (int i = 0; i < 10; i++)
                for (int j = 0; j < 10; j++)//
                {
                    int l = (i) * 10 + j;
                  
                    for (int m = 0; m < 5; m++)
                        for (int n = 0; n < 5; n++)
                        {
                            int k = (i + m) * 14 + j + n;
                            hIcnntemp[l] += xI[k] * w1cnn[m * 5 + n, 0];
                         
                            hIcnntemp1[l] += xI[k] * w1cnn[m * 5 + n, 1];

                            hIcnntemp2[l] += xI[k] * w1cnn[m * 5 + n, 2];
                            hIcnntemp3[l] += xI[k] * w1cnn[m * 5 + n, 3];
                        }
                }

  //forward第二步，10*10-》5*5
            jilumn.Clear();//forward执行一次，就是换一张图片
            jilumn1na.Clear();
            jilumn2na.Clear(); jilumn3na.Clear();
            for (int i = 0; i < 5; i++)
                for (int j = 0; j < 5; j++)//
                {
                    int l = (i) * 5 + 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) * 10 + j * 2 + n;
                            //取最大值
                            if (hIcnntemp[k] > tempb)
                            {
                                tempb = hIcnntemp[k];
                                tempPt = new Point(n, m);//m是h，n是w，这个要小心用错

                            }
                        }
                
                    jilumn.Add(tempPt);//25个数据，就有25组m，n，序号一一对应
                    hIcnn[l] = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038
                }

上面这段代码要重复三次，一共处理四副图像，即4@10*10-》4@5*5

  for (int i = 0; i < 5; i++)
                for (int j = 0; j < 5; j++)//
                {
                    int l = (i) * 5 + 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) * 10 + j * 2 + n;
                            //  tempb += B1[k] * Wb2c[m * 2 + n, l];//取均值？还是取最大值？
                            if (hIcnntemp1[k] > tempb)
                            {
                                tempb = hIcnntemp1[k];//如果是最大值，核就变得没有意义，back怎么办？202409170727
                                tempPt = new Point(n, m);//m是h，n是w，这个要小心用错

                            }
                        }
                    //   C1[l] = (byte)(tempb/4f);
                    jilumn1na.Add(tempPt);//25个数据，就有25组m，n，序号一一对应
                    hIcnn1na[l] = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038
                }
            for (int i = 0; i < 5; i++)
                for (int j = 0; j < 5; j++)//
                {
                    int l = (i) * 5 + 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) * 10 + j * 2 + n;
                            //  tempb += B1[k] * Wb2c[m * 2 + n, l];//取均值？还是取最大值？
                            if (hIcnntemp2[k] > tempb)
                            {
                                tempb = hIcnntemp2[k];//如果是最大值，核就变得没有意义，back怎么办？202409170727
                                tempPt = new Point(n, m);//m是h，n是w，这个要小心用错

                            }
                        }
                    //   C1[l] = (byte)(tempb/4f);
                    jilumn2na.Add(tempPt);//25个数据，就有25组m，n，序号一一对应
                    hIcnn2na[l] = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038
                }
            for (int i = 0; i < 5; i++)
                for (int j = 0; j < 5; j++)//
                {
                    int l = (i) * 5 + 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) * 10 + j * 2 + n;
                            //  tempb += B1[k] * Wb2c[m * 2 + n, l];//取均值？还是取最大值？
                            if (hIcnntemp3[k] > tempb)
                            {
                                tempb = hIcnntemp3[k];//如果是最大值，核就变得没有意义，back怎么办？202409170727
                                tempPt = new Point(n, m);//m是h，n是w，这个要小心用错

                            }
                        }
                    //   C1[l] = (byte)(tempb/4f);
                    jilumn3na.Add(tempPt);//25个数据，就有25组m，n，序号一一对应
                    hIcnn3na[l] = tempb;//25个数据，通过这个关系，就能找到14*14matrix中去。202409181038
                }

第三步关于forward，把处理后的图像合并起来，4@5*5=100

     hocnnhebing = new double[100];
            for (int i = 0; i < 25; i++)
            {
           
               hocnnhebing[i] =  hocnn[i] = sigmoid(hIcnn[i]);
                  hocnnhebing[i+25] =  hocnn1na[i] = sigmoid(hIcnn1na[i]);
                  hocnnhebing[i + 50] = sigmoid(hIcnn2na[i]);
                  hocnnhebing[i + 75] = sigmoid(hIcnn3na[i]);
            }

forward第四步，全连接：

  //下面开始全连接202409181044
            hI2 = new double[80];//
        
            for (int i = 0; i < 100; i++)//              
                for (int j = 0; j < 80; j++)//
                    hI2[j] += (hocnnhebing[i]) * w12cnn[i, j];//
              

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

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

               yicnn[j] += hO2[i] * w2cnn[i, j];

            //通过激活函数求yo
            for (int i = 0; i <10; i++)           
                yOcnn[i] = sigmoid(yicnn[i]);

上面就完成了forward（）函数。下面再看backward（）函数：

   for (int i = 0; i < 80; i++)//
                for (int j = 0; j < 10; j++)//10
                {
                    double delta = (yOcnn[j] - d[j]) * dsigmoid(yOcnn[j]) * hO2[i];
                    w2cnn[i, j] -= delta * learnRate;
                }      
            double[] W3 = new double[80];//
       
            for (int j = 0; j < 80; j++)//
                for (int k = 0; k < 10; k++)//10
                    W3[j] += (yOcnn[k] - d[k]) * dsigmoid(yOcnn[k]) * w2cnn[j, k];
                   
            for (int i = 0; i <100; i++)//        
                for (int j = 0; j < 80; j++)//
                {                                
                    double delta = dsigmoid(hO2[j]) * (hocnnhebing[i]) * W3[j];//这里要的是系数
                    w12cnn[i, j] -= delta * learnRate;
                }

//对比三层bpnet，上面比较好理解，下面是对四个卷积核的backward：

//backward中第一个卷积核5*5的处理：

    double[] deltacnn = new double[25];//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核
             for (int i = 0; i < 25; i++)//25             
                 for (int j = 0; j < 80; j++)//           
                 {              
                     deltacnn[i] = dsigmoid(hO2[j]) * W3[j] * w12cnn[i, j] * dsigmoid(hocnnhebing[i]);
                 }//全连接还是好处理202409200708
             for (int i= 0; i< 25; i++)
             {
               Point temppt= 求二维(i, jilumn[i].Y, jilumn[i].X);
               for (int k = 0; k < 5; k++)
                   for (int z = 0; z < 5; z++)
                   {                                       
                      int newIndex = (temppt.Y + k) * 14 + (temppt.X + z);
                      double delta = xI[newIndex] * deltacnn[i];//一共25个
                      w1cnn[k * 5 + z, 0] -= delta * learnRate;//只用一个卷积核，核forward就对应上了202409181430
                   }
             }

  //第二个卷积核202409191112

             double[] deltacnn1 = new double[25];//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核
             for (int i = 25; i < 50; i++)//25
             
                 for (int j = 0; j < 80; j++)//
                 {
                  
                     deltacnn1[i - 25] = dsigmoid(hO2[j]) * W3[j] * w12cnn[i, j] * dsigmoid(hocnnhebing[i]);
                 }
             for (int i = 0; i < 25; i++)
             {
                 Point temppt = 求二维(i, jilumn1na[i].Y, jilumn1na[i].X);
                 for (int k = 0; k < 5; k++)
                     for (int z = 0; z < 5; z++)
                     {
                    

                         int newIndex = (temppt.Y + k) * 14 + (temppt.X + z);
                         double delta = xI[newIndex] * deltacnn1[i];//一共25个
                         w1cnn[k * 5 + z, 1] -= delta * learnRate;//只用一个卷积核，核forward就对应上了202409181430
                     }
             }
             //第三个卷积核202409191112

             double[] deltacnn2 = new double[25];//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核
             for (int i = 50; i < 75; i++)//25
             
                 for (int j = 0; j < 80; j++)//
                 {
                
                     deltacnn2[i - 50] = dsigmoid(hO2[j]) * W3[j] * w12cnn[i, j] * dsigmoid(hocnnhebing[i]);
                 }
             for (int i = 0; i < 25; i++)
             {
                 Point temppt = 求二维(i, jilumn2na[i].Y, jilumn2na[i].X);
                 for (int k = 0; k < 5; k++)
                     for (int z = 0; z < 5; z++)
                     {
                    

                         int newIndex = (temppt.Y + k) * 14 + (temppt.X + z);
                         double delta = xI[newIndex] * deltacnn2[i];//一共25个
                         w1cnn[k * 5 + z, 2] -= delta * learnRate;//只用一个卷积核，核forward就对应上了202409181430
                     }
             }
            //第四个卷积核202409191112
             double[] deltacnn3 = new double[25];//每一个deltacnn，都对应25个14*14中的数据元素，以及一个5*5的卷积核
             for (int i = 75; i < 100; i++)//25
            
                 for (int j = 0; j <80; j++)//
                 {
                  
                     deltacnn3[i - 75] = dsigmoid(hO2[j]) * W3[j] * w12cnn[i, j] * dsigmoid(hocnnhebing[i]);
                 }
             for (int i = 0; i < 25; i++)
             {
                 Point temppt = 求二维(i, jilumn3na[i].Y, jilumn3na[i].X);
                 for (int k = 0; k < 5; k++)
                     for (int z = 0; z < 5; z++)
                     {
                      

                         int newIndex = (temppt.Y + k) * 14 + (temppt.X + z);
                         double delta = xI[newIndex] * deltacnn3[i];//一共25个
                         w1cnn[k * 5 + z, 3] -= delta * learnRate;//只用一个卷积核，核forward就对应上了202409181430
                     }
             }

以上就处理完了。哦，还有一个函数：

 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;
        }

或许，我这个cnn与你想的高大上的不同，但刨根问底，就是一回事！

也就是，你自学懂了，想怎么实现就怎么实现！

这几个核，在训练达到95分后，竟然自己生成了，太神奇！

想一想我们在图像处理里，用了那么多的卷积核，重来没有说是让计算机自己生成的，震惊到了吧！虽然这几个核，不那么好看，但的的确确，是计算机自己学习到的！

这是什么，这就是人工智能，这就是有学习能力的机器，太厉害了！所以人能做到的高斯核，机器在不断改进和进化中，一定会生成，更震惊的，他可能生成的卷积核，你都没见过，但他确实效果好，所以，他得到的结果，还有可能超过你！

本程序中，我们只生成了4个卷积核，那么使用8个卷积核，是不是效果更好？留作思考。

本节到此结束。