devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OCR图片相似度对比和分类算法_ocr比对原理

作者：知新_RL | 2024-08-09 02:15:42

赞

踩

ocr比对原理

目录

算法清单

前提知识

一、像素点对比

二、重心对比

三、投影比对

四、分块对比

Logistic回归的直观认识

带入数据进行训练

使用训练好的模型

训练模型的代码

参考文献：

Ocr文字识别其中的一大关键就是两张图片相似与否的判断，所以我们希望寻找一种或多种算法来计算图片的相似度。本文将对于项目中使用的比对算法进行介绍，并将其联合运用进行初步文字识别。

算法清单

 

  1. 像素点对比
  2. 重心对比
  3. 投影对比
  4. 分块对比

前提知识

        计算机处理图片并不像人这样可以直观的理解处理，在计算机中的图像可以看成一个矩阵，矩阵中的元素是一个颜色值，这个值由RGB三个参数构成，这三个参数的取值范围为0~255。当然图片的表示不只有RGB这一种，其他类型不再详述。由于0~255的范围太大了，我们应该进行图片的降维——二值化。二值化将图片变成只由黑色和白色，可以使用OTSU算法。我们再将黑色用1表示，白色用0表示，这样就得到一个矩阵，矩阵中只有数字0和1组成。

              

（图1：二值化后的图片）                   （图二：转换为01矩阵后的图片）

 

一、像素点对比

       我们将标准图与匹配图的每个像素点进行比对，如果相等，则相似点加一。这样扫描两张完图片，我们可以得到二者之间相似点的多少，再用相似点除以总点数，就可以得到一个0~1之间的数值，这就是相似度。

     

（标准图）                                                      （匹配图）

        如上图所示，共100个点，只有红色点[5,1]是不一样的，所以相似度等于99/100。

        这种比对算法是最简单的，但是实际应用效果不尽人意。试想，如果将匹配图的左上角多了一个点，如下图。那么将会直接导致匹配率下降很多87/100。实际中的情况远远比这复杂，所以效果欠佳。

（坏点图）

 

二、重心对比

       有些字符除了位置不一样，二者是很相似的。如[.]与[·]，所以我们需要对其进行位置的比对。可以计算其重心，判断黑色点主要是集中在什么区域。

 

        我们循环扫描每个黑色的点，将它们的横坐标与纵坐标累加起来，得到横坐标的和与纵坐标的和。再除以点的个数，得到平均横坐标与平均纵坐标。再分别将其除以横、纵坐标的总长，得到两个个在0~1区间的数，这就代表它的重心。最后计算二者重心的距离（距离的计算将会在后文介绍），得出相似度。这种算法的缺陷也是很明显的，因为除了特殊的符号外，其他字符的重心总是相差不大的，所以精确度很低。

 

三、投影比对

       投影比对是对行与列的黑色点个数进行统计，得到一个关于图片的特征向量，再计算二者特征向量的距离（距离的计算将在后文介绍），得出相似度。

                       

（标准图的投影）                                                             （匹配图的投影）

       如上图所示，我们可以得到两组向量：

        X:{10,102,2,10,10,2,2,10,10}Y:{8,8,6,6,6,6,6,6,8,8}

        X:{10,102,2,9,10,2,2,10,10}  Y:{7,8,6,6,6,6,6,6,8,8}

        计算两组向量的距离，得出相似度。

        这种算法将图片的特征缩小化了，比如二者第一列的统计结果都为9，我们无法知道缺的那个1的具体位置。但是将二维的匹配简化到向量距离的计算，这样更加利于计算机处理。

 

四、分块对比

       上文中说到投影对比，它的缺陷是让图片的特征丢失过多。为了减少特征的丢失，我们可以将图片切割成几块，在分别对每一块进行匹配计算相似度，得到相似度向量，再计算向量距离，得到相似度。

        分块对比不是一个具体算法，而是一种优化思路，让一张大图片的匹配变成许多小图片的匹配，这样可以使结果更为精确。

 

向量距离的计算

       上文一直在提向量间距离的计算，可见向量间的距离是至关重要的。目前常用的算法是欧几里德距离算法。

 

        我们可以建立标准字库（为每个字生成一张图片），将欲识别图片用以上算法到字库中进行分别匹配，得到多个相似度。我们让每个相似度乘以一个权重再先加，得出总相似度，总相似度最高的就是识别结果。这里涉及到一个问题，就是权重的确定，每个算法的平均准确度是不一样的，我们让准确度高的权重大一些。但是又怎么来确定权重的具体数值呢？请阅读下篇：Logistic回归的应用，通过该模型，我们会得到一个不错的结果。

 

 在上文中提到图片相似度比对算法，得出了图片的相似度数据。接下来最重要的是通过相似度数据来得出图片是否相似，也就是对于多个数据进行计算得到相似与不相似两个结果。这就要使用分类回归——logistic回归了。由于本人对于机器学习造诣不足，本文不过多的涉及回归模型的原理讲解，只对模型的java实现与模型在本项目中的应用进行阐述。

Logistic回归的直观认识

         线性回归模型想必大家都知道，它是对于数据的拟合，通过学习多组数据，得出一条可以很好拟合所有数据的方程（模型）。再将新数据带入这个方程（模型），就可以计算得出一个数值，即预测结果。当然这个方程是多元的，因为影响结果的因素不止一个，也不一定是一次的，因为变量之间的关系可能不是一维的。选择不同的方程，得出的预测准确度是不尽一样的。

（线性回归：一元一次方程得出的是一条直线）

         Logistic分类回归可以理解为就是对线性回归得出结果的进一步计算，将结果限定在0和1之间，从而表示相似与不相似。

（logistic函数：将结果限定在0与1之间）

         当然整个重点就是在于怎么拟合训练数据，常用的算法就是梯度下降。通过梯度下降可以让我们的方程逐步的向最小误差靠近，这里逐步的步长是可以改变的，也就是学习率。学习率的选择是比较重要的，会影响整个模型的学习速度与正确率。

（梯度下降：算法逐步靠近局部最优值）

         总的来说，通过logistic模型，可以对我们输入的相似度数据计算出一个0到1的相似值，通过该值就可以确定图片是否相似，从而识别文字。

带入数据进行训练

         训练的数据是两张图片的对比相似度，如果图片是同一个字，我们将结果标记为1，否则标记为0。下面是一些数据，x为多个相似度算法得出的结果，y为结果标记，为了方便观察，对数据进行了一些处理。

         可以看到x0一直为1，这是因为在方程中第一项是常数项，即x的0次方为1，也可以理解为偏置。还有6个对比算法得出相似度数据，可以看到正样本中的相似度比负样本中的高，说明我们的对比算法是有一定说服力的。但是每种算法的准确率不尽一样比如x3的正负样本都得出了比较高的相似度，说明准确率不高。因为x3是基于重心的对比，方块字的重心都差不多，所以没什么说服力。将这些数据带进模型进行训练，可以得出如下结果。

说明: C:\Users\Administrator.PC-20160823BFLX\Desktop\re1.png

         可以看到经过5222次的迭代，结果和我们预测的差不多，x3和x6与结果呈负相关。整个代价0.074，即准确率92.6%，已经不错了，毕竟学习数据很少。

使用训练好的模型

         上文我们已经将模型训练好了，现在只需要将相似度比对数据带入模型即可得出预测结果。结果是一个0~1之间的数据，我们将待预测图片与字库图片进行一一比对后带入模型，取结果最大的为识别结果即可。

完整代码请访问我的gihub（https://github.com/printlin/tmOcr）

  1.  
  2. 模型的java实现
  3.  
  4. package util;
  5.  
  6.  
  7.  
  8.  
  9. import java.util.List;
  10.  
  11.  
  12. import java.util.Map;
  13.  
  14.  
  15.  
  16.  
  17. /**
  18.  
  19.  
  20.  * @author Administrator
  21.  
  22.  
  23.  * @Description 分类回归模型，传入训练集，学习得到sts，即可使用sts对输入的x计算y
  24.  
  25.  
  26.  * @date 2018年7月16日 下午2:33:31
  27.  
  28.  
  29.  */
  30.  
  31.  
  32. public class LogisticModel {
  33.  
  34.  
  35.          private double[] sts=null;//参数Θ，通过学习得到
  36.  
  37.  
  38.          private double a=0.1;//学习速率
  39.  
  40.  
  41.          private List<Map<String,Object>> list=null;
  43.  
  44.          /**
  45.  
  46.  
  47.           * @param list 训练集 Map中x为 double[]代表变量数组；y为double代表结果
  48.  
  49.  
  50.           */
  51.  
  52.  
  53.          public LogisticModel(List<Map<String,Object>> list){
  55.  
  56.                    this.list=list;
  57.  
  58.  
  59.                    Map<String,Object> map=list.get(0);//空指针异常，未判断
  60.  
  61.  
  62.                    double[] x=(double[])map.get("x");//空指针异常，未判断
  63.  
  64.  
  65.                    sts=new double[x.length];
  66.  
  67.  
  68.          }
  69.  
  70.  
  71.          public LogisticModel(){
  72.  
  73.  
  74.          }
  75.  
  76.  
  77.          /**
  78.  
  79.  
  80.           * @author Administrator
  81.  
  82.  
  83.           * @Description 函数模型 X1*Θ1+...+Xn*Θn=y。输入x计算y
  84.  
  85.  
  86.           * @param xs x变量
  87.  
  88.  
  89.           * @return 计算结果
  90.  
  91.  
  92.           * @date 2018年7月16日 下午2:25:10
  93.  
  94.  
  95.           */
  96.  
  97.  
  98.          public double function(double[] xs){
  99.  
  100.  
  101.                    double re=0f;
  102.  
  103.  
  104.                    for(int i=0;i<xs.length;i++){//X1*Θ1+...+Xn*Θn=y 全是一维，对于本次学习足以
  105.  
  106.  
  107.                             re+=xs[i]*sts[i];
  108.  
  109.  
  110.                    }
  111.  
  112.  
  113.                    return 1/(Math.pow(Math.E, -re)+1);//logistic函数，将结果限定在0~1
  114.  
  115.  
  116.          }
  117.  
  118.  
  119.          /**
  120.  
  121.  
  122.           * @author Administrator
  123.  
  124.  
  125.           * @Description 使用梯度下降算法进行函数参数更新（学习）
  126.  
  127.  
  128.           * @date 2018年7月16日 下午2:28:09
  129.  
  130.  
  131.           */
  132.  
  133.  
  134.          private void update(){
  135.  
  136.  
  137.                    double[] stss=new double[sts.length];//新的模型参数，此处单独用数组来装而不是直接对该参数赋值，是为了不影响下一个参数的学习，保证每个参数对应的都是同一个函数
  138.  
  139.  
  140.                    int len=list.size();
  141.  
  142.  
  143.                    for(int i=0;i<stss.length;i++){//遍历每一个参数
  144.  
  145.  
  146.                             double sum=0f;
  147.  
  148.  
  149.                             for(Map<String,Object> map:list){
  150.  
  151.  
  152.                                      double[] xs=(double[])map.get("x");
  153.  
  154.  
  155.                                      double y=(double)map.get("y");
  156.  
  157.  
  158.                                      sum+=(function(xs)-y)*xs[i];
  159.  
  160.  
  161.                             }
  162.  
  163.  
  164.                             //System.out.println("js---:"+a*(1.0f/len)*sum);
  165.  
  166.  
  167.                             stss[i]=sts[i]-a*(1.0f/len)*sum;//更新该参数
  168.  
  169.  
  170.                    }
  171.  
  172.  
  173.                    sts=stss;//统一更新参数
  174.  
  175.  
  176.          }
  177.  
  178.  
  179.          /**
  180.  
  181.  
  182.           * @author Administrator
  183.  
  184.  
  185.           * @Description 代价函数，在训练集上计算误差
  186.  
  187.  
  188.           * @return 误差损失
  189.  
  190.  
  191.           * @date 2018年7月16日 下午2:29:36
  192.  
  193.  
  194.           */
  195.  
  196.  
  197.          private double dj(){
  198.  
  199.  
  200.                    double sum=0f;
  201.  
  202.  
  203.                    for(Map<String,Object> map:list){
  204.  
  205.  
  206.                             double[] xs=(double[])map.get("x");
  207.  
  208.  
  209.                             double y=(double)map.get("y");
  210.  
  211.  
  212.                             sum+=y*Math.log(function(xs))+(1-y)*Math.log(1-function(xs));
  213.  
  214.  
  215.                    }
  216.  
  217.  
  218.                    return -(1.0f/list.size())*sum;
  219.  
  220.  
  221.          }
  222.  
  223.  
  224.          /**
  225.  
  226.  
  227.           * @author Administrator
  228.  
  229.  
  230.           * @Description 开始学习
  231.  
  232.  
  233.           * @date 2018年7月16日 下午2:30:51
  234.  
  235.  
  236.           */
  237.  
  238.  
  239.          public void go(){
  240.  
  241.  
  242.                    int sum=0;//参数迭代次数
  243.  
  244.  
  245.                    int count=0;
  246.  
  247.  
  248.                    while(true){
  249.  
  250.  
  251.                             double oldDj=dj();//迭代前损失
  252.  
  253.  
  254.                             sum++;
  255.  
  256.  
  257.                             if(sum>=10000){//迭代次数不超过10000
  258.  
  259.  
  260.                                      break;
  261.  
  262.  
  263.                             }
  264.  
  265.  
  266.                             update();//迭代
  267.  
  268.  
  269.                             double newDj=dj();//迭代后损失
  270.  
  271.  
  272.                             if(Math.abs(newDj-oldDj)<0.00001){//两次损失差
  273.  
  274.  
  275.                                      count++;
  276.  
  277.  
  278.                                      if(count>10){//如果损失差小于0.00001连续10次,则认为已经拟合
  279.  
  280.  
  281.                                                break;
  282.  
  283.  
  284.                                      }
  285.  
  286.  
  287.                             }else{count=0;}
  288.  
  289.  
  290.                    }
  291.  
  292.  
  293.                    for(int j=0;j<sts.length;j++){
  294.  
  295.  
  296.                             System.out.print("st"+j+":"+sts[j]+"  ");//输出学习到的所有参数
  297.  
  298.  
  299.                    }
  300.  
  301.  
  302.                    System.out.println("\ndj:"+dj()+"   sum:"+sum);//输出误差已经总学习次数
  303.  
  304.  
  305.          }
  306.  
  307.  
  308.          public double[] getSts() {
  309.  
  310.  
  311.                    return sts;
  312.  
  313.  
  314.          }
  315.  
  316.  
  317.          public void setSts(double[] sts) {
  318.  
  319.  
  320.                    this.sts = sts;
  321.  
  322.  
  323.          }
  324.  
  325.  
  326.          public List<Map<String, Object>> getList() {
  328.  
  329.                    return list;
  330.  
  331.  
  332.          }
  333.  
  334.  
  335.          public void setList(List<Map<String, Object>> list) {
  337.  
  338.                    this.list = list;
  339.  
  340.  
  341.          }
  342.  
  343.  
  344. }

 

 

训练模型的代码

  1.  
  2. package test;
  3.  
  4.  
  5.  
  6.  
  7. import java.io.File;
  8.  
  9.  
  10. import java.io.IOException;
  11.  
  12.  
  13. import java.util.ArrayList;
  14.  
  15.  
  16. import java.util.HashMap;
  17.  
  18.  
  19. import java.util.List;
  20.  
  21.  
  22. import java.util.Map;
  23.  
  24.  
  25.  
  26.  
  27. import imgdo.ImgData;
  28.  
  29.  
  30. import util.ImgUtil;
  31.  
  32.  
  33. import util.LogisticModel;
  34.  
  35.  
  36.  
  37.  
  38. /**
  39.  
  40.  
  41.  * @author Administrator
  42.  
  43.  
  44.  * @Description
  45.  
  46.  
  47.  * @date 2018年8月3日 上午11:41:54
  48.  
  49.  
  50.  */
  51.  
  52.  
  53. public class LogisticTest {
  54.  
  55.  
  56.          private String trueFolder="F:\\textImg\\trueFolder";
  57.  
  58.  
  59.          private String falseFolder="F:\\textImg\\falseFolder";
  60.  
  61.  
  62.          public static void main(String[] args) throws IOException {
  63.  
  64.  
  65.                    new LogisticTest().learn();
  66.  
  67.  
  68.          }
  69.  
  70.  
  71.          /*
  72.  
  73.  
  74.           * 下面这个方法只对一个字进行了学习。将同样的字作为正样本，其他字为负样本，进行分类学习
  75.  
  76.  
  77.           * 如果衍生到所有字：
  78.  
  79.  
  80.           * 将所有字放在一起，文件名为该字。学习时判断文件名是否一致，一致则结果设置为1.其他为0
  81.  
  82.  
  83.           * 当然集合中一致的字是相对少的，这样会导致负样本过多，可以随机取固定比例的负样本进行学习。
  84.  
  85.  
  86.           * */
  87.  
  88.  
  89.          public void learn() throws IOException{
  90.  
  91.  
  92.                    ImgUtil iu=new ImgUtil();
  93.  
  94.  
  95.                    File trueFile=new File(trueFolder);
  96.  
  97.  
  98.                    File[] trueFiles=trueFile.listFiles();
  99.  
  100.  
  101.                    File falseFile=new File(falseFolder);
  102.  
  103.  
  104.                    File[] falseFiles=falseFile.listFiles();
  105.  
  106.  
  107.                    List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
  109.  
  110.                    for(int i=0,len=trueFiles.length;i<len;i++){//将正样本进行两两比较
  111.  
  112.  
  113.                             for(int j=i+1;j<len;j++){
  114.  
  115.  
  116.                                      ImgData data=iu.formatLibImg(trueFiles[i]),img=iu.formatLibImg(trueFiles[j]);//格式化图片
  117.  
  118.  
  119.                                      double[] re=iu.allMatch(data, img);//比对图片，得出各个比对算法的计算结果
  120.  
  121.  
  122.                                      Map<String,Object> map=new HashMap<String,Object>();
  123.  
  124.  
  125.                                      System.out.println("x=["+re[0]+"\t"+re[1]+"\t"+re[2]+"\t"+re[3]+"\t"+re[4]+"\t"+re[5]+"\t"+re[6]+"]\ty=1");
  126.  
  127.  
  128.                                      map.put("x", re);
  129.  
  130.  
  131.                                      map.put("y",1.0);//结果为相似
  132.  
  133.  
  134.                                      list.add(map);
  135.  
  136.  
  137.                             }
  138.  
  139.  
  140.                    }
  141.  
  142.  
  143.                    for(int i=0,len=trueFiles.length;i<len;i++){//将正样本与每一个负样本进行比较
  144.  
  145.  
  146.                             for(int j=0,jLen=falseFiles.length;j<jLen;j++){
  147.  
  148.  
  149.                                      ImgData data=iu.formatLibImg(trueFiles[i]),img=iu.formatLibImg(falseFiles[j]);//格式化图片
  150.  
  151.  
  152.                                      double[] re=iu.allMatch(data, img);//比对图片，得出各个比对算法的计算结果
  153.  
  154.  
  155.                                      Map<String,Object> map=new HashMap<String,Object>();
  156.  
  157.  
  158.                                      System.out.println("x=["+re[0]+"\t"+re[1]+"\t"+re[2]+"\t"+re[3]+"\t"+re[4]+"\t"+re[5]+"\t"+re[6]+"]\ty=0");
  159.  
  160.  
  161.                                      map.put("x", re);
  162.  
  163.  
  164.                                      map.put("y",0.0);//结果为不相似
  165.  
  166.  
  167.                                      list.add(map);
  168.  
  169.  
  170.                             }
  171.  
  172.  
  173.                    }
  174.  
  175.  
  176.                    LogisticModel lm=new LogisticModel(list);//带入模型
  177.  
  178.  
  179.                    lm.go();//开始学习
  180.  
  181.  
  182.          }
  183.  
  184.  
  185. }

 ​​​​​​​

文件夹中的内容

以上就是我的拙见，非常感谢您能看到这里，有什么问题可以评论指正哦。

参考文献：

https://blog.csdn.net/Print_lin/article/details/81052497

https://github.com/printlin/tmOcr

https://blog.csdn.net/Print_lin/article/details/81389392

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/950948
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号