《深度学习的数学》（https://www.ituring.com.cn/book/2593）第五章实例用Excel体验卷积神经网络——python实现
所使用的的数据连接：https://www.ituring.com.cn/book/download/d16bf588-375b-4176-b319-ec3c3a2d99a1
原书网址
计算过程如下：
import pandas, numpy
global seed
def get_npdata():
file = r'D:\ChromeCoreDownloads\【Excel示例文件】深度学习的数学\附录B.xlsx'
data = pandas.read_excel(file, sheet_name='Data', engine='openpyxl')
df = pandas.DataFrame(data)
# 通过切片，去除部分没有意义的行和列
df = df.iloc[1:10, 11:587]
# 将待识别数据转换为结构为(96, 6, 6)numpy数组np_data, 将正解存储在（95x3）的矩阵value中（准确的说是DataFrame中）
for i in range(0, 571, 6):
df1 = df.iloc[:, i:i+6]
if i == 0:
value = numpy.array(df1.iloc[6:, i])
value = pandas.DataFrame(value).transpose()
else:
value.loc[len(value)] = numpy.array(df1.iloc[6:, 0])
df1 = df1.iloc[:6, :]
if i == 0:
# 将一个待识别的数字的矩阵（6x6）表示作为一个np_data的一个元素
np_data = numpy.array([numpy.array(df1)])
else:
np_data_temp = numpy.array([numpy.array(df1)])
np_data = numpy.concatenate((np_data, np_data_temp))
value = numpy.array(value)
return np_data, value
def convo_cal(np_data, fil, bf):
"""计算卷积结果（供convo_layer_out调用）
"""
i = j = 0
while i+3 <= np_data.shape[0]:
while j+3 <= np_data.shape[1]:
# 截取（3,3）矩阵
x = np_data[i:i+3, j:j+3]
# 两矩阵（3x3）相同位置相乘， 结果求和，加上偏置，就是卷积层的输入
z = numpy.sum(x * fil) + bf
# sigmoid激活函数y(x), 得到输出a
a = 1/(1 + numpy.exp(-1*z))
if j == 0:
temp = numpy.array([a])
else:
temp = numpy.append(temp, a)
j += 1
if i == 0:
convo_cal_return = numpy.array([temp])
else:
convo_cal_return = numpy.concatenate((convo_cal_return, [temp]))
i += 1
j = 0
return convo_cal_return
def convo_layer_out(np_data):
"""本函数计算卷积层输出"""
# 接下来计算卷积层， 先要随机3个（3,3）过滤器及3个偏置bf
numpy.random.seed(seed)
f1 = numpy.random.randn(3, 3)
f2 = numpy.random.randn(3, 3)
f3 = numpy.random.randn(3, 3)
bf1, bf2, bf3 = numpy.random.randn(3)
# 使用书本提供的数据验证
# f1, f2, f3, bf = set_para_standard()
# bf1, bf2, bf3 = bf
# 将卷积层的输出整理成一个矩阵（96x3x4x4）
flag = 0
for pic in np_data:
# 每张相片需经三个过滤器处理。
for f, b in zip([f1, f2, f3], [bf1, bf2, bf3]):
temp = convo_cal(pic, f, b)
if f is f1:
picfill = numpy.array([temp])
else:
picfill = numpy.concatenate((picfill, [temp]))
if flag == 0:
result = numpy.array(([picfill]))
flag += 1
else:
result = numpy.concatenate((result, [picfill]))
return result
def pooling_out(convo_out):
"""本函数计算池化层输出"""
# 将（4x4）矩阵划分为4个（2x2）矩阵
# 设置flag 用于判断是否为第一张图片
flag = 0
for pic in convo_out:
# 设置subflag用于判断是否为第一个元素
subflag = 0
for fil in pic:
filhalf = numpy.hsplit(fil, 2)
for f in filhalf:
filquater = numpy.vsplit(f, 2)
for pice in filquater:
if subflag == 0:
picpooling = numpy.array([numpy.max(pice)])
subflag = 1
else:
picpooling = numpy.append(picpooling, [numpy.max(pice)])
# 因为图片三个过滤器池化的数据合并在一起，得到一个（1x12）的矩阵，将图片三个过滤器的池化输出，整理为3x4的矩阵
picpooling = numpy.hsplit(picpooling, 3)
picpooling = numpy.array(picpooling)
# 将96张图片数据合并为一个(96x3x4)矩阵
if flag == 0:
poolingout = numpy.array([picpooling])
flag = 1
else:
poolingout = numpy.concatenate((poolingout, [picpooling]))
# print(poolingout.shape)
return poolingout
def last_layer_out(poolingout):
"""结果输出"""
# 随机（服从正态分布）的参数
numpy.random.seed(seed)
w1 = numpy.random.randn(3, 4)
w2 = numpy.random.randn(3, 4)
w3 = numpy.random.randn(3, 4)
bo = numpy.random.randn(3)
# 使用书本提供的数据验证
# w1, w2, w3, bo = set_outlayer_para()
allout = []
for pic in poolingout:
flag = 0
for w, b in zip([w1, w2, w3], bo):
subflag = 0
for d, wi in zip(pic, w):
if subflag == 0:
zpicece = numpy.dot(d, wi)
subflag = 1
else:
zpicece += numpy.dot(d, wi)
zpicece = zpicece + b
apicece = 1/(1+numpy.exp(-1*zpicece))
if flag == 0:
a = numpy.array([[apicece]])
flag = 1
else:
a = numpy.append(a, [apicece])
allout.append(a)
allout = numpy.array(allout)
return allout
def cost_function(out, value):
"""求代价函数"""
c = 0
for o, v in zip(out, value):
c += numpy.sum(1/2*(o-v)**2)
def test():
global seed
seed = 16
np_data, value = get_npdata()
# 计算卷积层输出
convo_out = convo_layer_out(np_data)
# 计算池化层输出
poolingout = pooling_out(convo_out)
# 计算输出层输出
out = last_layer_out(poolingout)
# 求代价函数
c = cost_function(out, value)
print(c)
def check():
global seed
seed = 16
np_data, value = get_npdata()
testdata = np_data[0]
testdata[0][2] = 1
testdata[0][4] = 1
testdata[5][2] = 1
testdata[5][4] = 1
testdata = numpy.array([testdata])
# 计算卷积层输出
convo_out = convo_layer_out(testdata)
# 计算池化层输出
poolingout = pooling_out(convo_out)
# 计算输出层输出
out = last_layer_out(poolingout)
return out
out = check()
print(out)
print('number is :', list(out[0]).index(numpy.max(out[0]))+1)
我们还是通过更改seed(i)的i值，从而估计出最佳的参数。可以用下面的函数实现
def guess_para():
global seed
f = []
g = []
for i in range(10000):
seed = i
# 获取数据
np_data, value = get_npdata()
# 计算卷积层输出
convo_out = convo_layer_out(np_data)
# 计算池化层输出
poolingout = pooling_out(convo_out)
# 计算输出层输出
out = last_layer_out(poolingout)
# 求代价函数
c = cost_function(out, value)
print(c, seed)
if c < 50:
f.append((seed, c))
g.append(c)
index = g.index(min(g))
print('best seed is :', f[index][0])
100以内最佳的seed值是16， 代价函数的值为34.
验证是只需将验证数据设置为（1x6x6)矩阵，并赋值给np_data
根据输出层输出的最大的值在数组中的位置加一，即为判断判定结果。
以下使用书本提供的参数验证计算过程是正确的。
# 使用书本提供的数据验证
def set_para_standard():
f1 = numpy.array([[1.161, -0.848, 1.356], [5.825, -14.571, -6.945], [4.387, 8.317, 1.214]])
f2 = numpy.array([[1.950, 14.210, 5.029], [4.344, -1.471, -12.478], [-1.346, -5.859, -2.408]])
f3 = numpy.array([[-0.785, 4.159, -0.542], [0.468, -8.465, -4.508], [0.183, -2.567, 0.231]])
bf = [-14.706, -13.572, -4.879]
return f1, f2, f3, bf
def set_outlayer_para():
w1 = numpy.array([[-0.317, -3.223, 0.151, 1.323], [-25.877, 0.402, -0.494, -1.571], [-3.661, 0.009, 1.908, -0.159]])
w2 = numpy.array([[0.010, -11.069, -0.642, 9.001], [12.096, -0.352, 0.003, 10.159], [0.430, 2.060, 1.672, -0.093]])
w3 = numpy.array([[2.775, 43.616, -0.233, 0.045], [0.755, -0.138, 0.213, -8.731], [-1.086, -0.167, -0.851, -3.019]])
bo = [14.764, -21.116, -9.164]
return w1, w2, w3, bo