怎样使用Python进行深度学习呢

夏小攀

Python深度学习的源代码有吗哦？

爱俯卧撑的123

1. import xlrd
   
2. import math
   
3. import matplotlib.pyplot as plt
   
4. from mpl_toolkits.mplot3d.axes3d import Axes3D
   
5. import numpy as np
   
6. import time
   
7. 
   
8. def loadData(filename):#将数据集加载到data数组
   
9.     workbook = xlrd.open_workbook(filename)
   
10.     boyinfo = workbook.sheet_by_index(0)
    
11.     col_num = boyinfo.ncols
    
12.     row_num = boyinfo.nrows
    
13.     col0 = boyinfo.col_values(0)[1:]
    
14.     data = np.array(col0)
    
15.     if col_num == 1:
    
16.         return data
    
17.     else:
    
18.         for i in range(col_num-1):
    
19.             coltemp = boyinfo.col_values(i+1)[1:]
    
20.             data = np.c_[data, coltemp]
    
21.     return data
    
22. 
    
23. def plotData(X,y):
    
24.     pos = np.where(y == 1)
    
25.     neg = np.where(y == 0)
    
26.     p1 = plt.plot(X[pos, 0], X[pos, 1], marker='s', markersize=5, color='red')[0]
    
27.     p2 = plt.plot(X[neg, 0], X[neg, 1], marker='o', markersize=5, color='green')[0]
    
28. 
    
29.     return p1, p2
    
30. 
    
31. def nomalization(X):
    
32.     Xmin = np.min(X , axis = 0)
    
33.     Xmax = np.max(X , axis = 0)
    
34.     Xmu = np.mean(X , axis = 0)
    
35.     X_norm = (X - Xmu) / (Xmax - Xmin)
    
36.     return X_norm
    
37. 
    
38. # sigmoid: 定义一个 激活（激励）函数 sigmoid 函数 （activation function），输入参数是 wx， 返回的是 sigmoid 函数值
    
39. def sigmoid(wx):
    
40.     sigmoidV =  1.0/(1.0+np.exp(-wx))#请补全                             # 请补全  计算激活函数 sigmoid 函数 的函数值，计算公式为：1.0/(1.0+np.exp(-wx))
    
41.     return sigmoidV
    
42. 
    
43. # BGD 批量梯度下降法求最优参数
    
44. # 定义一个BGD 函数，即：批量梯度下降法（Batch Gradient Descent，BGD），输入参数是 数据集 X 和 y,
    
45. # 迭代次数 iter_num, 学习率 alpha，又写作 lr (learning rate), 它表示每次向着J最陡峭的方向迈步的大小， 返回的是 权重 w
    
46. # 通过批量梯度下降法（Batch Gradient Descent，BGD），不断更新权重 W
    
47. def BGD(X, y, iter_num, alpha):
    
48.     trainMat = np.mat(X)                            # 通过使用 np.mat 函数，将数据集 X 转换成矩阵类型，并赋值给 trainMat
    
49.     trainY = np.mat(y).T                            # 通过使用 np.mat 函数，将数据集 y 转换成矩阵类型，并且转置，然后赋值给 trainY
    
50.     m, n = np.shape(X)                              # 通过使用 np.shape 函数，得到数据集 X 的形状大小，其中，m 为数据集 X 的行数，n 为数据集 X 的列数
    
51.     w = np.ones((n,1))                              # 通过使用 np.ones 函数，创建元素全为 1 的矩阵，矩阵的大小为 n 行 1 列，并赋值给 w, 即：进行权重 w 的初始化，令其全为 1
    
52.     for i in range(iter_num):                       # 通过 for 循环结构，开始进行迭代，其中，i 可取的数依次为：0，1 ，2，....，iter_num-1， 迭代次数总共有 iter_num 次
    
53.         error =  sigmoid(trainMat*w)-trainY#请补全  # 计算迭代的误差 error：将预测得到的激活函数的数值 sigmoid(trainMat*w) 减去 实际的 trainY 数值
    
54.         w = w - (1.0/m) * alpha * trainMat.T * error#请补全  # 更新权重 w , BGD 批量梯度下降法 的核心， w = w - (1.0/m)*alpha*trainMat.T*error
    
55.     return w                                        # 返回 w
    
56. 
    
57. # plot decision boundary：定义一个 plotDecisionBoundaryn 函数，输入参数是 训练集 trainX, 训练集 trainY, 直线斜率截距相关参数 w, 迭代次数 iter_num ，目的是为了画出决策的判断边界
    
58. def plotDecisionBoundary(trainX, trainY, w, mylr, iter_num = 0):
    
59.     # prepare data
    
60.     xcord1 = [];ycord1 = [];xcord2 = [];ycord2 = [] # 准备数据，定义四个空的列表，并分别赋值给 xcord1、ycord1、xcord2、ycord2，进行初始化
    
61.     m, n = np.shape(trainX)                         # 通过使用 np.shape 函数，得到训练集 trainX 的形状大小，其中，m 为训练集 trainX 的行数，n 为训练集 trainX 的列数
    
62.     for i in range(m):                              # 通过使用 for 循环语句，遍历训练集 trainX 所有的行，其中，i 可以取得值分别是 0，1，2，...，m-1，总共是 m 行
    
63.         if trainY[i] == 1:                          # 通过使用 if 条件判断语句，如果训练集 trainY（标志）中的元素为 1，那么将训练集 trainX中的 trainX[i,1] 和 trainX[i,2] 分别添加到 xcord1 和 ycord1 列表中
    
64.             xcord1.append(trainX[i,1])              # 通过 append 的方法，将训练集 trainX中 的 trainX[i,1] 添加到 xcord1 列表中，保存的是 pos 的横坐标, 代表 positive 的数据
    
65.             ycord1.append(trainX[i,2])              # 通过 append 的方法，将训练集 trainX中 的 trainX[i,2] 添加到 ycord1 列表中，保存的是 pos 的纵坐标, 代表 positive 的数据
    
66.         else:                                       # 否则，如果训练集 trainY（标志）中的元素不为 1，那么将训练集 trainX中的 trainX[i,1] 和 trainX[i,2] 分别添加到 xcord2 和 ycord2 列表中
    
67.             xcord2.append(trainX[i,1])              # 通过 append 的方法，将训练集 trainX中 的 trainX[i,1] 添加到 xcord2 列表中，保存的是 neg 的横坐标, 代表 negative 的数据
    
68.             ycord2.append(trainX[i,2])              # 通过 append 的方法，将训练集 trainX中 的 trainX[i,2] 添加到 ycord2 列表中，保存的是 neg 的纵坐标, 代表 negative 的数据
    
69.     x_min = min(trainX[:,1])                        # 通过使用 min 函数，计算出 trainX[:,1] ，即 trainX 第2列的最小值，并赋值给 x_min
    
70.     y_min = min(trainX[:,2])                        # 通过使用 min 函数，计算出 trainX[:,2] ，即 trainX 第3列的最小值，并赋值给 y_min
    
71.     x_max = max(trainX[:,1])                        # 通过使用 max 函数，计算出 trainX[:,1] ，即 trainX 第2列的最大值，并赋值给 x_max
    
72.     y_max = max(trainX[:,2])                        # 通过使用 max 函数，计算出 trainX[:,2] ，即 trainX 第3列的最大值，并赋值给 y_max
    
73. 
    
74.     # plot scatter  & legend
    
75.     fig = plt.figure(1)                              # 通过使用 plt.figure 函数，开始创建一个图形窗口，并赋值给 fig
    
76.     # 通过使用 plt.scatter 函数，绘制散点图，横坐标为 xcord1, 纵坐标为 ycord1，标记大小为30，颜色为红色，形状样式为 s (正方形)，代表 square, 图例标签为 'I like you'
    
77.     plt.scatter(xcord1, ycord1, s=30, c='red', marker='s', label='I like you')
    
78.     # 请补全 通过使用 plt.scatter 函数，绘制散点图，横坐标为 xcord2, 纵坐标为 ycord2，标记大小为30，颜色为绿色，形状样式为 o (圆形)，代表 circle, 图例标签为 'I don't like you'
    
79.     plt.scatter(xcord2, ycord2, s=30, c='green', marker='o', label='I don\'t like you')#请补全
    
80. 
    
81.     plt.legend(loc='upper right')                   # 设置图例的位置为右上角
    
82. 
    
83.     # set axis and ticks
    
84.     delta_x = x_max-x_min                           # 计算横坐标的极差为横坐标最大值与最小值的差，并赋值给 delta_x
    
85.     delta_y = y_max-y_min                           # 计算纵坐标的极差为纵坐标最大值与最小值的差，并赋值给 delta_y
    
86.     # 设置横坐标的刻度：从 x_min - delta_x / 10 到 x_max + delta_x / 10，使用 np.arange 函数创建数组，步长为 1，并赋值给 my_x_ticks
    
87.     my_x_ticks = np.arange(x_min - delta_x / 10, x_max + delta_x / 10, 1)
    
88.     # 设置纵坐标的刻度：从 y_min - delta_y / 10 到 y_max + delta_y / 10，使用 np.arange 函数创建数组，步长为 1，并赋值给 my_y_ticks
    
89.     my_y_ticks = np.arange(y_min - delta_y / 10, y_max + delta_y / 10, 1)
    
90. 
    
91.     plt.xticks(my_x_ticks)                          # 通过使用 plt.xticks 函数，设置作图的横坐标的刻度为 my_x_ticks
    
92.     plt.yticks(my_y_ticks)                          # 通过使用 plt.yticks 函数，设置作图的纵坐标的刻度为 my_y_ticks
    
93.     # 通过使用 plt.axis 函数，设置作图的横坐标和纵坐标的显示范围，分别是[x_min-delta_x/10, x_max+delta_x/10] 和 [y_min-delta_y/10, y_max+delta_y/10]
    
94.     plt.axis([x_min-delta_x/10, x_max+delta_x/10, y_min-delta_y/10, y_max+delta_y/10])
    
95. 
    
96.     # drwa a line：绘制一条直线，用于决策判断
    
97.     x = np.arange(x_min-delta_x/10, x_max+delta_x/10, 0.01) # 通过使用 np.arange 函数创建数组， 从 x_min - delta_x / 10 到 x_max + delta_x / 10，步长为 0.01，并赋值给 x
    
98.     y = y = (-w[0]-w[1]*x)/w[2] #请补全                                             # 通过公式计算得到直线的纵坐标： y = (-w[0]-w[1]*x)/w[2]
    
99.     plt.plot(x, y.T)                                # 通过使用 plt.plot 函数绘制图象，其中，横坐标是 x , 纵坐标是 y.T， “.T” 表示的是矩阵的转置，因为绘图时需要横纵坐标的维度一致
    
100. 
     
101.     # figure name：设置图像的文件名和标题名
     
102.     # 设置图像的文件名为 'Training ' + str(iter_num) + ' times.png'，其中，str(iter_num) 表示将迭代次数 iter_num 转变成字符串，图片格式为 “png”
     
103.     fig_name = 'Training ' + str(iter_num) + 'times' + str(mylr)+'.png'
     
104.     # 设置图像的标题名为'Training ' + str(iter_num) + ' times.png'，其中，str(iter_num) 表示将迭代次数 iter_num 转变成字符串，图片格式为 “png”
     
105.     plt.title(fig_name)
     
106.     fig.savefig(fig_name)                           # 通过使用 fig.savefig 函数，保存图片，分辨率等参数采取默认值
     
107.     # plt.show()                                    # 通过使用 plt.show 函数，显示绘制好的图片，注意的是必须关闭图像窗口，才可以进入执行后续的程序
     
108.     plt.clf()#清除框线
     
109. 
     
110. def loss(X, Y, w):                                  # 定义一个 损失函数 loss 函数 （loss function），输入参数是 X, Y, w， 返回的是 损失函数的值
     
111.     m, n = np.shape(X)                              # 通过使用 np.shape 函数，得到数据集 X 的形状大小，其中，m 为数据集 X 的行数，n 为数据集 X 的列数
     
112.     trainMat = np.mat(X)                            # 通过使用 np.mat 函数，将数据集 X 转变成矩阵类型，并赋值给 trainMat
     
113.     Y_ = []                                         # 准备数据，定义一个空的列表，并赋值给 Y_，进行初始化, 后续会通过 append 的方法向空列表内不断添加新的元素
     
114.     for i in np.arange(m):                          # 通过 for 循环结构，遍历数据集 X 所有的行，其中，i 可取的数依次为：0，1 ，2，....，m-1， 数据集 X总共有 m 行
     
115.         # 通过 append 的方法向空列表 Y_ 内不断添加新的元素，新元素是通过 训练的矩阵数据集  trainMat[i] 乘以权重 w 之后，再计算激活函数 sigmoid 的函数值
     
116.         Y_.append(sigmoid(trainMat[i]*w))
     
117.     m = np.shape(Y_)[0]                             # 通过使用 np.shape 函数，得到数据集 X 的形状大小，其中，np.shape(Y_)[0] 为数据集 X 的行数，并赋值给 m
     
118.     sum_err = 0.0                                   # 初始化误差的总和为 0.0, 赋值给 sum_err， 后续会不断更新 误差的总和 sum_err 的数值
     
119.     for i in range(m):                              # 通过 for 循环结构，遍历数据集 Y_ 所有的行，其中，i 可取的数依次为：0，1 ，2，....，m-1， 数据集 Y_ 总共有 m 行
     
120.         # 请补全 更新误差的总和 sum_err 的数值， 每次 误差的总和 sum_err 递减 Y[i]*np.log(Y_[i])+(1-Y[i])*np.log(1-Y_[i])，这是 交叉熵损失函数（ Cross Entropy Loss ）的计算公式
     
121.         sum_err = Y_[i]*np.log(Y_[i])+(1-Y[i])*np.log(1-Y_[i])#请补全
     
122.     return sum_err/m                                # 返回 sum_err
     
123. 
     
124. # classify：定义一个 classify 函数，输入参数是 wx， 返回的是标志 1 或者 0
     
125. def classify(wx):
     
126.     prob = sigmoid(wx)                              # 计算概率：将激活函数 sigmoid(wx) 的数值作为预测的概率，并赋值给 prob
     
127.     if prob > 0.5:                                  # 如果 概率 prob 大于 0.5， 那么返回数值 1
     
128.         return 1
     
129.     else:                                           # 否则，如果 概率 prob 不大于 0.5， 那么返回数值 0
     
130.         return 0
     
131. 
     
132. 
     
133. # predict：定义一个 predict 函数，输入参数是 测试集 testX 和权重 w， 返回的是预测的结果 result
     
134. def predict(testX, w):
     
135.     m, n = np.shape(testX)                          # 通过使用 np.shape 函数，得到测试集 testX 的形状大小，其中，m 为测试集 testX 的行数，n 为测试集 testX 的列数
     
136.     testMat = np.mat(testX)                         # 通过使用 np.mat 函数，将测试集 testX 转换成矩阵类型，并赋值给 testMat
     
137.     result = []                                     # 准备数据，定义一个空的列表，并赋值给结果 result，进行初始化, 后续会通过 append 的方法向空列表内不断添加新的元素
     
138.     for i in np.arange(m):                          # 通过 for 循环结构，遍历测试集 testX 所有的行，其中，i 可取的数依次为：0，1 ，2，....，m-1， 测试集 testX 总共有 m 行
     
139.         # 通过 append 的方法向空列表 result 内不断添加新的元素，新元素是通过调用 classify 函数进行预测得到，将返回的浮点型的 1 或者 0 添加到 空列表 result 内
     
140.         result.append(classify(float(testMat[i]*w)))
     
141.     return result                                   # 返回预测结果result
     
142. 
     
143. 
     
144. # Precision：定义一个 Precision 函数，输入参数是数据集 X, Y 和权重 w， 返回的是 测试集的正确率
     
145. def Precision(X, Y, w):
     
146.     result = predict(X, w)                          # 通过调用 predict 函数，输入测试集 X 和权重 w， 计算得到预测结果，并把返回的结果赋值给 result
     
147.     right_sum = 0                                   # 进行初始化预测正确的数目，赋值 0 给 right_sum，后续如果预测正确，会不断增加 1
     
148.     # 通过 for 循环结构，开始进行遍历，其中，i 可取的数依次为：0，1 ，2，....，len(result)-1， 预测结果 result 内元素的个数总和为 len(result)
     
149.     for i in range(len(result)):
     
150.         if result[i]-int(Y[i]) == 0:                # 通过条件判断语句 if, 如果结果 result 的元素与 int(Y[i])相等，即：预测正确！ 那么更新预测正确的数目 right_sum
     
151.             right_sum += 1                          # 如果预测正确！ 那么更新预测正确的数目 right_sum，每次递增加 1
     
152.     # 最后返回测试集预测的正确率，计算公式为：1.0*right_sum/len(Y)，注意：乘以 1.0 的原因是把正确率变成浮点型，当然也可以直接用 float 强制转换
     
153.     return 1.0*right_sum/len(Y)
     
154. 
     
155. 
     
156. def main(times,mylr):
     
157.     begin = time.time()
     
158.     data = loadData('data.xls')
     
159.     X = data[:,:2]#身高与收入
     
160.     y = data[:,2]#1与0
     
161.    
     
162.     '''
     
163.     plt_data = plt.figure(1)
     
164.     p1,p2 = plotData(X,y)
     
165.     plt.xlabel('tall')
     
166.     plt.ylabel('salary')
     
167.     plt.legend((p1, p2), ('I like you', "I do not like you"), numpoints=1, handlelength=0)
     
168.     plt_data.savefig('visualization_org.png')  # 通过调用 plt.savefig 函数，保存图像，并且图像的文件名为：'visualization_org.jpg'，其中，图片的格式为 'jpg'
     
169.     #plt.show()    # 通过调用 plt.show 函数，显示图像
     
170.     #plt.close(plt_data)
     
171.     '''
     
172.    
     
173.     '''将数据X归一化'''
     
174.     X_norm = nomalization(X)
     
175.     '''
     
176.     plt_norm = plt.figure(1)#新建一个归一化的函数框
     
177.    
     
178.     p1_norm, p2_norm = plotData(X_norm, y)
     
179.     #print(p1_norm)
     
180.     #print(p2_norm)
     
181.     plt.xlabel('tall')
     
182.     plt.ylabel('salary')
     
183.     plt.legend((p1_norm, p2_norm), ('I like you', 'I do not like you'), numpoints = 1, handlelength=0)
     
184.     #plt_norm.savefig("visualization_norm.png")#保存图片
     
185.     #plt.show()  # 通过调用 plt.show 函数，显示归一化后的图像
     
186.     '''
     
187.    
     
188.     '''optimizing by BSD'''
     
189.    
     
190.     iter_num = times#训练次数
     
191.     lr = mylr#alpha值
     
192.     m, n = np.shape(data)#data为50行，三列的array
     
193.     offset = np.ones((m, 1))#返回50行，1列的由[1.]填充的array
     
194.     trainMat = np.c_[offset, X_norm]#合并offset, X_norm，返回50行3列的，第一列为1.的array
     
195.     theta = BGD(trainMat, y, iter_num, lr)
     
196.    
     
197.    
     
198.     # 通过调用 plotDecisionBoundary 函数，绘制分类决策的直线，其中，输入参数分别是：训练集 trainMat, 标签 y, 最优化后的权重 theta 和 迭代次数 iter_num
     
199.     #plotDecisionBoundary(trainMat, y, theta, mylr, iter_num)
     
200.     cost = loss(trainMat, y, theta)  # 通过调用 loss 函数，计算出本模型算法的损失函数，其中, 输入参数分别是： 训练集 trainMat, 标签 y 和 最优化后的权重 theta， 并赋值给 cost
     
201.     print('Cost theta: {0}'.format(cost))  # 在屏幕上输出 损失函数的数值，其中，.format(cost) 的格式是更加规范的输出格式，当然也可以用转义字符 %s
     
202.     print('%.10f'%cost)
     
203. 
     
204.     # Compute accuracy on our training set
     
205.     p = Precision(trainMat, y, theta)  # 通过调用 Precision 函数，计算出预测 测试集结果的正确率，其中，输入参数分别是： 训练集 trainMat, 标签 y 和 最优化后的权重 theta， 并赋值给 p
     
206.     print('Train Accuracy: {0}'.format(p))  # 在屏幕上输出 测试集正确率的数值，其中，.format(p) 的格式是更加规范的输出格式，当然也可以用转义字符 %s
     
207.     print('finished!')  # 在屏幕上输出完成的信息，'finished!'
     
208.     end = time.time()
     
209.     print(f'time:{end-begin:.1f} s')
     
210.    
     
211.     '''保存数据到txt
     
212.     with open('result-lrdif.txt' , 'a') as result_txt:
     
213.         result_txt.write(f' 200组数据-训练[{times}]次结果:\n lr(alpha):[{lr}]\n Cost theta(损失率):{cost}\n Train Accuracy(正确率):{p}\n Time(用时):{end-begin:.1f}\n =======================================\n\n')
     
214.     '''
     
215. 
     
216.     return p,cost
     
217. def create3Dview(times,lr,p,base,fuck):
     
218.     #显示中文,避免warning
     
219.     plt.rcParams['font.sans-serif']=['SimHei']
     
220.     plt.rcParams['axes.unicode_minus']=False
     
221. 
     
222.     # 创建画布
     
223.     fig = plt.figure()
     
224.     # 创建3D坐标系
     
225.     axes3d = Axes3D(fig,auto_add_to_figure=False)
     
226.     fig.add_axes(axes3d)
     
227. 
     
228.     times = np.array(times)
     
229.     lr = np.array(lr)
     
230.     colors = ['green','pink','blue','yellow','gray','red','purple','brown','orange']
     
231.     #规定柱子的长宽
     
232.     if len(lr)>1:
     
233.         dy =  (lr[1]-lr[0])/2
     
234.     else:
     
235.         dy = lr[0]//2
     
236.     if len(times)>1:
     
237.         dx = (times[1]-times[0])/2
     
238.     else:
     
239.         dx = times[0]//2
     
240.     for i in range(len(lr)):
     
241.         axes3d.bar3d(times,[lr[i]]*base,[0]*base,#[0]*base是规定底部
     
242.                      dx,dy,p[i]*fuck,
     
243.                      color = np.random.choice(colors,1))
     
244.     #plt.xticks(times)
     
245.     plt.yticks(lr, lr)
     
246.     plt.xlabel('times')
     
247.     plt.ylabel('lr')
     
248.     # 将三维的灰色背诵面换成白色
     
249.     axes3d.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
     
250.     axes3d.w_yaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
     
251.     axes3d.w_zaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
     
252.     axes3d.view_init(elev=30,azim=-60)
     
253.     plt.show()
     
254.    
     
255. if __name__ == '__main__':
     
256.     '''开始试验设置不同的alpha和times对于模型正确率以及损失函数之间的关系'''
     
257.     diflr = []#添加不同的alpha到列表,注意必须是等差的
     
258.     for i in range(1,5):
     
259.         diflr.append(i/10)
     
260.         
     
261.     diftimes = []#添加不同的times(学习次数)到列表,注意必须是等差的
     
262.     for i in range(1,5):
     
263.         diftimes.append(i*10)
     
264.         
     
265.     p_result = []#正确率(结果)
     
266.     cost_result = []#损失率(结果)
     
267.     for each_lr in diflr:
     
268.         for time_ in diftimes:
     
269.             p,cost = main(time_,each_lr)
     
270.             p_result.append(p)
     
271.             cost_result.append(np.matrix.tolist(cost)[0][0])#将矩阵转换为浮点数后添加
     
272.             
     
273.     base = int(math.sqrt(len(p_result)))#base是作三维柱状图的参数,x轴的系数个数
     
274.     '''将结果转换为base*base的二维array'''
     
275.     p_result = np.array(p_result).reshape((base,base))
     
276.     cost_result = np.array(cost_result).reshape((base,base))
     
277.     '''调用画图函数'''
     
278.     create3Dview(diftimes,diflr,p_result,base,1)
     
279.     create3Dview(diftimes,diflr,cost_result,base,-1)
     
280.    
     

复制代码