import h5py
import matplotlib.pyplot as plt
import numpy as np
def load_dataset():
#拿到这个文件字典
train_dataset = h5py.File('./train_catvnoncat.h5','r')
test_dataset = h5py.File('./test_catvnoncat.h5','r')
#拿到字典中所有的键值
# for key in train_dataset.keys():
#打印Key-Value
# print (train_dataset[key])
#list_classes表示是种类，train_set_x表示训练的数据集,train_set_y"表示训练的数据集的标签
#有209个图片集，每个图片集是 64*64*3
#<HDF5 dataset "list_classes": shape (2,), type "|S7">
#<HDF5 dataset "train_set_x": shape (209, 64, 64, 3), type "|u1">
#<HDF5 dataset "train_set_y": shape (209,), type "<i8">
#拿到209个图片集，使用np做成数组
train_set_x = np.array(train_dataset["train_set_x"][:])
train_set_y = np.array(train_dataset["train_set_y"][:])
test_set_x = np.array(test_dataset["test_set_x"][:])
test_set_y = np.array(test_dataset["test_set_y"][:])
#打印维度
# print(train_set_x.shape)
#(209, 64, 64, 3)
#设置窗体大小
# plt.figure(figsize = (2,2))
#设置第0张
# plt.imshow(train_set_x[11])
# plt.show()
#显示标签是否为猫
# print(train_set_y[11])
#第1 个元素，也就是图片数，第二个参数 -1 是 其余数相乘),T代表转置,形成（12288，209）
train_set_x = train_set_x.reshape(train_set_x.shape[0],-1).T
# print(train_set_x.shape)
test_set_x = test_set_x.reshape(train_set_x.shape[0],-1).T
#转化y的坐标
train_set_y = train_set_y.reshape(train_set_y.shape[0],-1).T
test_set_y = train_set_y.reshape(train_set_y.shape[0],-1).T#(1,209)
return train_set_x,train_set_y,test_set_x,test_set_y
def init_parameters(fc_net):
#定义一个字典，存放参数矩阵W1，b1,W2,b2,W3,b3,W4,b4
#a1 = W1*a0+b1
parameters = {}
#拿到层数
layers_num = len(fc_net)
# print(layers_num)
for L in range(1,layers_num):
#使用高斯分布，每一个字典，形成一个fc_net[L]行fc_net[L-1]列的随机数组
parameters["W"+str(L)] = np.random.randn(fc_net[L],fc_net[L-1])
#fc_net[L]行1列
parameters["b"+str(L)] = np.zeros((fc_net[L],1))
# for L in range(1,layers_num):
#打印W1到W4
# print("W"+str(L) +"=",parameters["W"+str(L)])
# print("b"+str(L) +"=",parameters["b"+str(L)])
return parameters
#定义sigmoid函数
def sigmoid(Z):
return 1/(1+np.exp(-Z))
def forward_pass(A0,parameters):
#缓存函数
cache = {}
A = A0
#缓存A0
cache["A0"] = A0
#python //代表整除，向下取整
Layer_num = len(parameters) // 2
#遍历 rang(1,5)是遍历1,2,3,4
for L in range(1, Layer_num+1):
#dot是矩阵乘法
#其中对于b来说的话，b是1列的，但是 python中有广播机制,可以扩展为209列
Z = np.dot(parameters["W"+str(L)],A) +parameters["b"+str(L)]
#A1 = (4,12288)*(12288,209) +(4,1) = (4,209) +(4,1) = (4,209)
#A2 = (3,4)*(4,209) +(3,1) = (3,209)+(3,1) = (3,209)
#A3 = (2,3)*(3,209) +(2,1) = (2,209)
#A4 = (1,209)
A = sigmoid(Z)
#给所有 中间值Z1-Z4 和 A1 -A1缓存
cache["Z"+str(L)] = Z
cache["A"+str(L)] = A
return A,cache
def compute_cost(AL,Y):
#代价函数
m = Y.shape[1] #Y =（1,209）
cost = (1/m)*np.sum((1/2)*(AL-Y)*(AL-Y)) #代价函数
return cost
def backward_pass(AL,parameters,cache,Y):
#样本总数 209
m = Y.shape[1]
#定义字典，存储所有层的梯度
gredient = {}
#拿到层数
Layer_num = len(parameters) //2
#末层误差 dJ/dz dZL.shape = (1,209)
dZL= (AL -Y)*(AL*(1-AL) )
#第4层的梯度 W4 = 1/m *(dZL, A )
gredient["dW"+str(Layer_num)] = (1/m)*np.dot(dZL,cache["A"+ str(Layer_num -1)].T)
gredient["db" +str(Layer_num)] = (1/m)*np.sum(dZL,axis=1,keepdims =True)#axis=1代表横向叠加,keepdims让其横向为矩阵，有维度
#遍历[3,2,1]
for L in reversed (range(1,Layer_num)):
dZL = np.dot(parameters["W"+str(L+1)].T,dZL)*(AL*(1-AL))
gredient["dW"+str(L)] = (1/m)*np.dot(dZL,cache["A"+ str(L -1)].T)
gredient["db" +str(L)] = (1/m)*np.sum(dZL,axis=1,keepdims =True)
return gredient
#梯度检验
#解析法：求得梯度解析表达式，通过这个表达式得到梯度(确切解)
#数值逼近：（近似解）
#字典转列向量，先把所有b W串联成一个 (49182,1)矩阵，然后计算 数值梯度和 解析梯度的欧式距离
#
def grad_dict_to_vector(gradient):
Layer_num = len(gradient) // 2 #gradients=4
count = 0
for L in range(1,Layer_num+1): #遍历[1,2,...,Layer_num]
dW_vector = np.reshape(gradient["dW"+str(L)], (-1,1)) #将该层dW矩阵展平为一个列矩阵 （4,12288）->（49152,1）
db_vector = np.reshape(gradient["db"+str(L)], (-1,1)) #将该层db矩阵展平为一个列矩阵 （4,1）->（4,1）
vec_L = np.concatenate((dW_vector, db_vector), axis=0) #先将该层W个b串联叠加
if count == 0:
vec_output = vec_L #叠加到输出列矩阵
else:
vec_output = np.concatenate((vec_output, vec_L), axis=0) #逐层串联叠加
count = count + 1
return vec_output #返回列矩阵
#把parameters转成 列向量
def param_dict_to_vector(parameters):#参数字典转列矩阵
#将我们所有的参数字典转换为满足我们特定所需形状的单个向量。
Layer_num = len(parameters) // 2 #Layer_num=4
count = 0
for L in range(1,Layer_num+1): #遍历[1,2,...,Layer_num]
W_vector = np.reshape(parameters["W"+str(L)], (-1,1)) #将该层W参数矩阵展平为一个列矩阵
b_vector = np.reshape(parameters["b"+str(L)], (-1,1)) #将该层b参数矩阵展平为一个列矩阵
vec_L = np.concatenate((W_vector, b_vector), axis=0) #串联叠加
if count == 0:
vec_output = vec_L
else:
vec_output = np.concatenate((vec_output, vec_L), axis=0) #串联叠加
count = count + 1
return vec_output
# 列向量转字典
def vector_to_param_dict(vec,param_src): #列矩阵转参数字典,第一个输入为列矩阵，第二个输入为保存W和b的参数字典
Layer_num = len(param_src) // 2 #Layer_num=4
param_epsilon = param_src
idx_start = 0
idx_end = 0
for L in range(1,Layer_num+1): #遍历[1,2,...,Layer_num]
row = param_src["W"+str(L)].shape[0]
col = param_src["W"+str(L)].shape[1]
idx_end = idx_start + row*col #该W参数矩阵元素个数
#print("idx_start=",idx_start,";idx_end=",idx_end)
param_epsilon["W"+str(L)] = vec[idx_start:idx_end].reshape((row,col))
idx_start = idx_end
row = param_src["b"+str(L)].shape[0]
col = param_src["b"+str(L)].shape[1]
idx_end = idx_start+row*col #该b参数矩阵元素个数
#print("b.shape=",param_src["b"+str(L)].shape)
#print("idx_start=",idx_start,";idx_end=",idx_end)
param_epsilon["b"+str(L)] = vec[idx_start:idx_end].reshape((row,col))
idx_start = idx_end
return param_epsilon #返回添加了epsilon的参数字典
compute_cost
#梯度检测
def gradient_check(A0,Y,gradient,parameters,epsilon=1e-4):
print("opooooooo")
grad_vec = grad_dict_to_vector(gradient)#梯度字典转列向量
param_vec = param_dict_to_vector(parameters)#参数字典转列向量(49182,1)
param_num = param_vec.shape[0] #49182,参数个数
#定义列矩阵保存数值梯度
grad_vec_approach = np.zeros(grad_vec.shape)
#得到数值梯度列矩阵
for i in range(0,param_num):
#第一个参数的数值梯度
if i%1000==0:
print("grad checking i=",i)
#对第一个参数做前向计算过程,求得当前代价值
param_vec_plus = np.copy(param_vec)
#对第一个参数加epslion，一般为1e-7
param_vec_plus[i][0] = param_vec_plus[i][0] + epsilon
#把这样的参数列矩阵，重新变换成字典，然后前向传播，计算出代价值
#返回的cache不需要，就是不需要返回中间的W和b
AL,_ = forward_pass(A0,vector_to_param_dict(param_vec_plus,parameters))
# 计算代价值
J_plus_epsilon = compute_cost(AL,Y)
#计算减去epslion的代价值
param_vec_minus = np.copy(param_vec)
param_vec_minus[i][0] = param_vec_minus[i][0] - epsilon
AL,_ = forward_pass(A0,vector_to_param_dict(param_vec_minus,parameters))
J_minus_epsilon = compute_cost(AL,Y)
#减去e和 加上e的相加后除以得到第一个参数的数值梯度
grad_vec_approach[i][0]= (J_plus_epsilon-J_minus_epsilon)/(2*epsilon)
#在机器学习中，表征两个向量之间差异性的方法：L2范数（欧氏距离）、余弦距离
#L2范数：主要用于表征两个向量之间数值的差异（适合我们现在的情况）
#余弦距离：主要用于表征两个向量之间方向的差异
# np.sqrt(np.sum((grad_vec-grad_vec_approach)**2))可以直接求得，但是解析梯度和数值非常小，会引入数值误差，采用相对误差的方法
diff = np.sqrt(np.sum((grad_vec-grad_vec_approach)**2))/(np.sqrt(np.sum((grad_vec)**2))+np.sqrt(np.sum((grad_vec_approach)**2)))
if diff > 1e-4:
print("Maybe a mistake in your bakeward pass!!! diff=",diff)
else:
print("No problem in your bakeward pass!!! diff=",diff)
# 反向传播算法
def update_parameters(gredient,parameters,LearnRate):
# w: = w -learningRate *dw
# w: = b -learningRate *db
Layer_num = len(parameters)//2
for L in range(1,Layer_num+1):
#遍历[1,2,3,4]
parameters["W" +str(L)] = parameters["W" +str(L)] - LearnRate*gredient["dW"+str(L)]
parameters["b" +str(L)] = parameters["b" +str(L)] - LearnRate*gredient["db"+str(L)]
return parameters
def Train_Net(fc_net,train_set_x,train_set_y,iterations=2000,LearnRate=0.01):
#4.初始化全连接层
parameters = init_parameters(fc_net)
#z = wx+b ;a =f(z)
#AL = (1,209)
#cost保存每10次迭代计算得到的代价值
costs = []
for iteration in range (0,iterations):
AL,cache = forward_pass(train_set_x,parameters)
#6.代价函数,多样本损失值
loss = compute_loss(AL, train_set_y)
if iteration%500 == 0:
#每100个打印一次
costs.append(loss)
print("loss == ",loss)
#7 .AL为输入数据，parameters中有w和b，cache中有Z和A，train_set_y为标签值
gradient = backward_pass(AL,parameters,cache,train_set_y)
#梯度检测
if iteration ==1999:
diff = gradient_check(train_set_x,train_set_y,gradient,parameters)
#8. 梯度下降 gredient,根据梯度更新一次参数
parameters = update_parameters(gredient,parameters,LearnRate)
plt.plot(costs,'p')
plt.xlabel("opooc-iteration")
plt.ylabel("opooc-cost")
plt.show()
return parameters
if __name__ == '__main__':
#1.加载数据
train_set_x,train_set_y,test_set_x,test_set_y = load_dataset()
#2.输入像素值做归一化 ()
train_set_x = train_set_x/255.0
test_set_x = test_set_x/255.0
#3.定义全连接神经网络各层神经元个数，并初始化参数w和b,12288代表输入像素数
fc_net = [12288,4,3,2,1]
parameters = Train_Net(fc_net,train_set_x,train_set_y,iterations=2000,LearnRate=0.01)
扫一扫
12-31
316
316
05-07
791
791
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
