图像识别技术可以用来解决人脸识别或字符识别等多种问题。
在本文中，我将对算法进行实际编码来演示识别手写字，特别是手写的数字。我将会使用Python以及Python的许多模块，比如numpy、PIL等。
1 #从PIL库中导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #从文件中载入图像
6 i = Image.open('images/dot.png')
7 #将图像转换成矩阵形式
8 iar = np.asarray(i)
9 #打印矩阵
10 print (iar)
代码中提到的图像“dot.png”基本如下：
下面给你看看图像的矩阵形式，这里只是矩阵的部分截图。
你会注意到一个由8个矩阵块组成的集合。每个矩阵块表示一个“水平行的像素”，如果仔细观察，你会发现图像有8个像素行，因此图像数组有8个矩阵块。进一步观察，图像的第一个像素行是由一个黑色像素后面跟着7个白色像素组成的。现在如果我们回到刚才生成的图像矩阵中，你会注意到像素行的第一个像素[0(R) 0(G) 0(B) 255(A)]为黑色（black），其余的[255(R) 255(G) 255(B) 255(A)]为白色（white）。
注意：A（α值）表示图像的透明度。α值越低，透明度越高，相反α值越高，透明度越低。
下图可以让上面所讲的更清晰地表示出来。
因此，这里共有8行类似这样的结果，剩下的都是白色。
以下代码的输出结果大体上是一个3D图像数组。比如，针对8*8位图像，我们将得到一个8行的3D数组，每一行包含RGB-A（红蓝绿-α）的水平像素值。有一点需要记住的是，α值越高越不透明。我们也可以从另一个角度来理解，第一个维度是整个图像，第二个维度是像素行，第三个维度是RGB-A值（红蓝绿-α）或行中的每一个像素。
现在让我们来看一些有趣的事。你也许想知道为什么有时电脑会习惯于用RGB表示颜色，有时又用RWB或其他类似的方式。好了，有一个理论叫作加色和减色理论。我们在本文中讨论的是加色法。我们以红色画笔为例，如果我们在纸上画一次，会出现红色，再画一次，红色将会变深，如果用手电筒从纸的背面照过来，红色会变得明亮一些，这就是显示器的工作原理。因此，我想说的是，
我将用matplotlib模块来呈现图像。
1 #从PIL库中导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #导入matplotlib
6 import matplotlib.pyplot as plt
7 #从文件中载入图像
8 i = Image.open('images/dotndot.png')
9 #将图像转换成矩阵形式
10 iar = np.asarray(i)
11 #输出图像
12 plt.imshow(iar)
13 plt.show()
我导入matplotlib.pyplot函数，并修改了最后两行代码。
下面是输入的图像：
输出结果是：
当计算机尝试识别数字时，会碰到一个问题，有些数字可能会看上去模糊、褪色或变形，就像验证码中或带有彩色零的图像中显示的那样。机器要处理数百万种颜色，增加了计算的复杂度。
并不是所有的图像都有机器容易识别的白色或深色的背景。对于这个问题我们通过设定阈值来解决。我们分析图像的平均颜色，将它作为阈值。高于阈值则认为更接近白色，低于阈值认为接近黑色。
通过设定阈值我们可以简化图像。
让我们来做个最简单的测试。
1 #从PIL库中导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #导入matplotlib库的pyplot
6 import matplotlib.pyplot as plt
7 #从文件中载入图像
8 i = Image.open('images/numbers/y0.4.png')
9 #将图像转换为矩阵形式
10 iar = np.asarray(i)
11 #输出图像
12 plt.imshow(iar)
13 plt.show()
下图是使用matplotlib库绘制的图像。
这是一个以黄色为背景的蓝色零，计算机很难识别这些模糊的图像。
因此，让我们用阈值函数来解决这个问题。使用阈值函数，我们将把任何图像变成黑白两色，这种方法使得计算机不必困惑于数百万种颜色（256*256*256*256），简化了图像识别的工作量。我们提出了将超过阈值的值转化为白色（很明显，一个图像的色彩越多，越接近与白色），同时低于阈值的值转化为黑色。因此现在最有挑战的部分是阈值的确定，该函数基本上是改变数组的值，使每个像素转换为白色或黑色。
下面是阈值函数：
1 #从PIL库导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #导入matplotlib库的pyplot
6 import matplotlib.pyplot as plt
7 #导入时间
8 import time
9
10 #从文件载入图像i，i2，i3和i4，并将图像转换为矩阵
11 i = Image.open('images/numbers/0.1.png')
12 iar = np.array(i)
13 i2 = Image.open('images/numbers/y0.4.png')
14 iar2 = np.array(i2)
15 i3 = Image.open('images/numbers/y0.5.png')
16 iar3 = np.array(i3)
17 i4 = Image.open('images/sentdex.png')
18 iar4 = np.array(i4)
19
20 #用matplotlib画图，在8*6大小矩形框里内，每张子图行范围（0,4），列范围（0,3），
21 #在（0,0）位置绘制ax1，（4,0）位置绘制ax2,（0,3）位置绘制ax3,（4,3）位置绘制ax4
22
23 fig = plt.figure()
24 ax1 = plt.subplot2grid((8,6),(0,0), rowspan=4, colspan=3)
25 ax2 = plt.subplot2grid((8,6),(4,0), rowspan=4, colspan=3)
26 ax3 = plt.subplot2grid((8,6),(0,3), rowspan=4, colspan=3)
27 ax4 = plt.subplot2grid((8,6),(4,3), rowspan=4, colspan=3)
28
29 #输出图像
30 ax1.imshow(iar)
31 ax2.imshow(iar2)
32 ax3.imshow(iar3)
33 ax4.imshow(iar4)
34
35 plt.show()
代码输出结果：
在上面的函数中增加阈值函数：
1 #从PIL库中导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #导入matplotlib
6 import matplotlib.pyplot as plt
7 #导入时间
8 import time
9
10 #定义阈值函数，参数为图像数组，返回新的图像数组
11 def threshold(imageArray):
12 #balanceAr是数组，用于存放所计算的每行像素的平均值
13 balanceAr = []
14 newAr = imageArray
15 for eachRow in imageArray:
16 for eachPix in eachRow:
17 avgNum = reduce(lambda x, y: x + y, eachPix[:3]) / len(eachPix[:3])
18 balanceAr.append(avgNum)
19
20 #balance是balanceAr的平均值，即所有行像素的均值
21 balance = reduce(lambda x, y: x + y, balanceAr) / len(balanceAr)
22
23 #将每行的像素值与均值比较，如果大于均值，像素转换为白色（[255,255,255,255]）
24 #否则，转换为黑色（[0,0,0,255]）
25
26 for eachRow in newAr:
27 for eachPix in eachRow:
28 if reduce(lambda x, y: x + y, eachPix[:3]) / len(eachPix[:3]) > balance:
29 eachPix[0] = 255
30 eachPix[1] = 255
31 eachPix[2] = 255
32 eachPix[3] = 255
33 else:
34 eachPix[0] = 0
35 eachPix[1] = 0
36 eachPix[2] = 0
37 eachPix[3] = 255
38 return newAr
39
40 #从文件载入图像i，i2，i3，i4，并转换成数组
41 i = Image.open('images/numbers/0.1.png')
42 iar = np.array(i)
43 i2 = Image.open('images/numbers/y0.4.png')
44 iar2 = np.array(i2)
45 i3 = Image.open('images/numbers/y0.5.png')
46 iar3 = np.array(i3)
47 i4 = Image.open('images/sentdex.png')
48 iar4 = np.array(i4)
49
50 #调用阀值函数
51 threshold(iar3)
52 threshold(iar4)
53 threshold(iar2)
54
55 #用matplotlib作图
56 fig = plt.figure()
57 ax1 = plt.subplot2grid((8,6),(0,0), rowspan=4, colspan=3)
58 ax2 = plt.subplot2grid((8,6),(4,0), rowspan=4, colspan=3)
59 ax3 = plt.subplot2grid((8,6),(0,3), rowspan=4, colspan=3)
60 ax4 = plt.subplot2grid((8,6),(4,3), rowspan=4, colspan=3)
61
62 #输出图像
63 ax1.imshow(iar)
64 ax2.imshow(iar2)
65 ax3.imshow(iar3)
66 ax4.imshow(iar4)
67 plt.show()
68
输出结果：
你会注意到所有的图像都被转化成黑白图像。阈值设定是图像识别的首要步骤之一。
在阀值函数里，我们通过运行二重循环来读取每个像素行并将该像素行中所有的RGB值取平均值，然后将其添加到balanceAr数组中。这一循环会涉及所有的像素行，计算每一行的像素平均值，然后将其添加到balanceAr数组中。接下来我们将对balanceAr数组中所有的值取平均，并将该平均值存入balance变量中。
我们再回到每个像素行，取平均值并将均值与阈值相比较。如果该均值大于阈值，我们将像素转换为白色，反之转换为黑色。
现在我们已经解决了阈值的问题，并且将所有的图像（彩色或黑白）统一转换成了黑白图像。接下来是比较有趣的部分。我们首先要训练数据，然后教会它如何识别和预测图像。
我们将通过存储本地数据（一些图像）来训练和测试它们，以帮助我们识别图像。
现在， 我的文件夹里已经有了一些图像（数字）文件。我将要做的是用我的numpy函数将这些图像都转化成数组，然后存入数据库中。这样可以节约时间，不必每次处理图像时都要先将其转化为数组。
1 #从PIL导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #导入matplotlib库的pyplot
6 import matplotlib.pyplot as plt
7 #导入time
8 import time
9
10 #定义createExamples()函数，将文件里所有图像集转换为数组形式
11 #并写入numArEx.txt文件中
12 def createExamples():
13 #numberArrayExamples是存放图像数组的文件，
14 #numbersWeHave是每个种类图像的数量
15 #versionsWeHave是图像种类的数量
16 numberArrayExamples = open('numArEx.txt','a')
17 numbersWeHave = range(0,10)
18 versionsWeHave = range(1,10)
19
20 for eachNum in numbersWeHave:
21 for eachVer in versionsWeHave:
22
23 #将数组写入文件
24 imgFilePath = 'images/numbers/'+str(eachNum)+ '.'+ str(eachVer)+
25 '.png'
26 ei = Image.open(imgFilePath)
27 eiar = np.array(ei)
28 eiar1 = str(eiar.tolist())
29
30 #对比所有的数字
31 lineToWrite = str(eachNum)+ '::'+ eiar1 + '\n'
32 numberArrayExamples.write(lineToWrite)
33
34 #定义阈值函数，参数为图像数组imageArray，返回新的图像数组
35 def threshold(imageArray):
36 balanceAr = []
37 newAr = imageArray
38 for eachRow in imageArray:
39 for eachPix in eachRow:
40 avgNum = reduce(lambda x, y: x + y, eachPix[:3]) / len(eachPix[:3])
41 balanceAr.append(avgNum)
42 balance = reduce(lambda x, y: x + y, balanceAr) / len(balanceAr)
43 for eachRow in newAr:
44 for eachPix in eachRow:
45 if reduce(lambda x, y: x + y, eachPix[:3]) / len(eachPix[:3])
46 > balance:
47 eachPix[0] = 255
48 eachPix[1] = 255
49 eachPix[2] = 255
50 eachPix[3] = 255
51 else:
52 eachPix[0] = 0
53 eachPix[1] = 0
54 eachPix[2] = 0
55 eachPix[3] = 255
56 return newAr
57
58 #从文件载入图像i，i2，i3，i4，并转换成数组
59 i = Image.open('images/numbers/0.1.png')
60 iar = np.array(i)
61 i2 = Image.open('images/numbers/y0.4.png')
62 iar2 = np.array(i2)
63 i3 = Image.open('images/numbers/y0.5.png')
64 iar3 = np.array(i3)
65 i4 = Image.open('images/sentdex.png')
66 iar4 = np.array(i4)
67
68 #调用阀值函数
69 threshold(iar3)
70 threshold(iar4)
71 threshold(iar2)
72
73 #用matplotlib作图
74 fig = plt.figure()
75 ax1 = plt.subplot2grid((8,6),(0,0), rowspan=4, colspan=3)
76 ax2 = plt.subplot2grid((8,6),(4,0), rowspan=4, colspan=3)
77 ax3 = plt.subplot2grid((8,6),(0,3), rowspan=4, colspan=3)
78 ax4 = plt.subplot2grid((8,6),(4,3), rowspan=4, colspan=3)
79
80 #输出图像
81 ax1.imshow(iar)
82 ax2.imshow(iar2)
83 ax3.imshow(iar3)
84 ax4.imshow(iar4)
85 plt.show()
我只是在代码中加入了createExamples()函数 。文本文件中基本包含了所有不同的数字以及它们的数组形式。现在我们只需要一个步骤：对比。当我们拿到一个数字并需要识别它时，我们只需尝试将该数字的图像数组和数据库中已有的数组进行对比。如果对比结果是一致的，则输出这个数字。实际操作比听起来更加容易。让我们来试一试。
让我们写一个函数用来对比指定图像和数据库中的图像数组。
1 #从PIL库导入Image
2 from PIL import Image
3 #导入numpy
4 import numpy as np
5 #导入matplotlib库的pyplot
6 import matplotlib.pyplot as plt
7 #导入时间
8 import time
9
10 #定义createExamples()函数，将文件里所有图像集转换为数组形式
11 #并写入numArEx.txt文件中
12 def createExamples():
13 numberArrayExamples = open('numArEx.txt','a')
14 numbersWeHave = range(0,10)
15 versionsWeHave = range(1,10)
16
17 for eachNum in numbersWeHave:
18 for eachVer in versionsWeHave:
19 #print str(eachNum)+ '.'+ str(eachVer)
20 imgFilePath = 'images/numbers/'+str(eachNum)+ '.'+ str(eachVer)+ '.png'
21 ei = Image.open(imgFilePath)
22 eiar = np.array(ei)
23 eiar1 = str(eiar.tolist())
24
25 # 现在我们来对比所有的数字
26
27 lineToWrite = str(eachNum)+ '::'+ eiar1 + '\n'
28 numberArrayExamples.write(lineToWrite)
29 def threshold(imageArray):
30 balanceAr = []
31 newAr = imageArray
32 for eachRow in imageArray:
33 for eachPix in eachRow:
34 avgNum = reduce(lambda x, y: x + y, eachPix[:3]) / len(eachPix[:3])
35 balanceAr.append(avgNum)
36 balance = reduce(lambda x, y: x + y, balanceAr) / len(balanceAr)
37 for eachRow in newAr:
38 for eachPix in eachRow:
39 if reduce(lambda x, y: x + y, eachPix[:3]) / len(eachPix[:3]) > balance:
40 eachPix[0] = 255
41 eachPix[1] = 255
42 eachPix[2] = 255
43 eachPix[3] = 255
44 else:
45 eachPix[0] = 0
46 eachPix[1] = 0
47 eachPix[2] = 0
48 eachPix[3] = 255
49 return newAr
50
51 #定义whatNumIsThis函数，参数为文件路径filePath，根据文件路径提取图像，将其转为数组
52 def whatNumIsThis(filePath):
53 matchedAr = []
54 loadExamps = open('numArEx.txt','r').read()
55
56 #分割函数,将所有图像的像素矩阵以\n分割
57 loadExamps = loadExamps.split('\n')
58
59 #载入图像文件列表
60 i = Image.open(filePath)
61 iar = np.array(i)
62 iarl = iar.tolist()
63 inQuestion = str(iarl)
64
65 #将图像数组跟数据库中已有的图像数组进行比对
66 for eachExample in loadExamps:
67 try:
68 splitEx = eachExample.split('::')
69 currentNum = splitEx[0]
70 currentAr = splitEx[1]
71
72 eachPixEx = currentAr.split('],')
73 eachPixInQ = inQuestion.split('],')
74
75 x = 0
76
77 while x
78 if eachPixEx[x] == eachPixInQ[x]:
79 matchedAr.append(int(currentNum))
80
81 x+=1
82 except Exception as e:
83 print(str(e))
84
85 print(matchedAr)
86 x = Counter(matchedAr)
87 print(x)
88 print(x[0])
89
90 #调用whatNumIsThis函数，
91 whatNumIsThis('images/numbers/y0.3.png')
在上面的代码中，我们只增加了whatNumIsThis(filePath)这函数，参数为文件路径（filePath）。这个函数的基本功能是根据文件路径提取图像，将其转为数组，并跟数据库中的数组进行比对。分割函数可以分割所有像素数组。计数器可以记录每一次成功的对比。
输出结果如下：
这样，像素数组最多次对比成功的数是0（328次），并输入图像中的数也是0。因此，我们成功地识别图像。
最后，我可以输出图像了。
现在，让我们试试别的。这次我们使用SciKitLearn提供的数据集，用Support Vector machine来进行分类。顺便说一句，SVM是监督学习分类器，它的工作原理是在我们给出一些标签数据之后，才开始对数据分类。
1 #导入matplotlib、sklearn
2 import matplotlib.pyplot as plt
3 from sklearn import datasets
4 from sklearn import svm
5
6 #skLearn带有数据集，现在我们导入这些数据集
7 digits = datasets.load_digits()
8
9 # SVM是我们要用的分类器
10 #digits.data是图像数组的特征集
11 #digits.target是实际的数字
12 #digits.target是我们已经赋值给digits.data的标签
13
14 #使用SVM分类器
15 clf = svm.SVC(gamma = 0.001, C = 100)
16
17 #取图像数组的特征集和标签的最后40个数据赋值给x，y
18 X,y = digits.data[:-40],digits.target[:-40]
19
20 #给数据和相应的图像数组数据贴标签
21 clf.fit(X,y)
22
23 # 训练数据集并拟合
24 #训练所有的数据集除了最后10个数用于测试
25 #输出结果并画图
26 print('Prediction:', clf.predict(digits.data[-42]))
27 plt.imshow(digits.images[-42], cmap=plt.cm.gray_r, interpolation='nearest' )
28 plt.show()
在上面的代码中，我们主要是用最后的40个数据训练SVM分类器，然后从这40个数据中任意抽取10个数据来测试它。这里我们试图找到第42个数是什么？
运行代码之后，我们得到以下结果：这是第42个数
让我们看看SVM有没有进行预测并正确标记。
瞧，我们得到了数字6，也就是第42个数的值！
原文发布时间为：2015-09-28
本文来自云栖社区合作伙伴“大数据文摘”，了解相关信息可以关注“BigDataDigest”微信公众号
