ng深度学习第一节代码总结：深层神经网络识别猫咪图片

之前在网易云课堂上看完了ng深度学习第一节课四周的内容，但是没有代码实践，总觉得学的很虚，于是去了coursera......

这堂课的编程作业是从2层神经网络开始，过渡到n层的，我这里做了下整理，放出n层神经网络识别猫咪的代码：

###多层神经网络实现图像识别

import h5py
import numpy as np
import matplotlib.pyplot as plt
import scipy
#from PIL import Image
from scipy import ndimage

#读取数据集
def load_data():
train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
train_set_x_orig = np.array(train_dataset["train_set_x"][:])  # your train set features
train_set_y_orig = np.array(train_dataset["train_set_y"][:])  # your train set labels

test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
test_set_x_orig = np.array(test_dataset["test_set_x"][:])  # your
4000
test set features
test_set_y_orig = np.array(test_dataset["test_set_y"][:])  # your test set labels

classes = np.array(test_dataset["list_classes"][:])  # the list of classes

train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))

return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

#sigmoid function
def sigmoid(Z):

A = 1/(1+np.exp(-Z))
cache = Z

return A,cache

#relu function
def relu(Z):

A = np.maximum(0,Z)

assert(A.shape == Z.shape)

cache = Z
return A,cache

def sigmoid_backward(dA,cache):

Z = cache
s = 1/(1+np.exp(-Z))
dZ = dA * s * (1-s)

assert (dZ.shape == Z.shape)

return dZ

def relu_backward(dA,cache):

Z = cache
dZ = np.array(dA,copy=True)

dZ[Z <= 0] = 0

assert (dZ.shape == Z.shape)

return dZ

#初始化参数
#layer_dim:如果[2,4,1]，表示2,4,1的2层网络，其中2为输入层，4为隐藏层，1为输出层
def initialize_parameters_deep(layer_dims):

parameters = {}
L = len(layer_dims)  # number of layers in the network

for l in range(1, L):
parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l - 1]) / np.sqrt(
layer_dims[l - 1])  # *0.01
#parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l - 1]) * 0.01
parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))

assert (parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l - 1]))
assert (parameters['b' + str(l)].shape == (layer_dims[l], 1))

return parameters

#向前传播的线性部分
def linear_forward(A,W,b):

Z = np.dot(W, A) + b

assert(Z.shape == (W.shape[0],A.shape[1]))
cache = (A, W, b)

return Z, cache

#向前传播的激活函数部分
def linear_activation_forward(A_pre, W, b, activation):

if activation == "sigmoid":
Z, linear_cache = linear_forward(A_pre, W, b)
A, activation_cache = sigmoid(Z)

elif activation == "relu":
Z, linear_cache = linear_forward(A_pre, W, b)
A, activation_cache = relu(Z)

assert (A.shape == (W.shape[0],A_pre.shape[1]))
cache = (linear_cache, activation_cache)

return A,cache

#向前传播模型
def L_model_forward(X, parameters):

caches = []
A = X
#神经网络的layer数
L = len(parameters) // 2  #a//b表示向下取整

for l in range(1,L):
A_prev = A
A, cache = linear_activation_forward(A_prev, parameters["W"+str(l)], parameters["b"+str(l)], activation="relu")
caches.append(cache)

AL, cache = linear_activation_forward(A, parameters["W"+str(L)], parameters["b"+str(L)], activation="sigmoid")
caches.append(cache)

assert (AL.shape == (1, X.shape[1]))

return AL, caches

#计算代价函数cost function
def compute_cost(AL, Y):

m = Y.shape[1]

#损失函数的计算公式
cost = -(np.dot(Y, np.log(AL).T) + np.dot((1 - Y), np.log(1 - AL).T)) / m

# To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).
cost = np.squeeze(cost)

assert (cost.shape == ())

return cost

#计算反向传输的线性部分
def linear_backward(dZ,cache):

A_prev, W, b = cache
m = A_prev.shape[1]

dW = np.dot(dZ, A_prev.T) / m
db = np.sum(dZ, axis=1, keepdims=True) / m
dA_prev = np.dot(W.T, dZ)

assert (dA_prev.shape == A_prev.shape)
assert (dW.shape == W.shape)
assert (db.shape == b.shape)

return dA_prev, dW, db

#计算反向传输的激活函数部分
def linear_activation_backward(dA, cache, activation):

linear_cache, activation_cache = cache

if activation == "relu":
dZ =relu_backward(dA, activation_cache)
dA_prev, dW, db = linear_backward(dZ, linear_cache)
elif activation == "sigmoid":
dZ = sigmoid_backward(dA, activation_cache)
dA_prev, dW, db = linear_backward(dZ, linear_cache)

return dA_prev, dW, db

#多层神经网络反向传输模型
def L_model_backward(AL, Y, caches):

grads = {}
L = len(caches)
m = AL.shape[1]
Y = Y.reshape(AL.shape)

#初始化反向传播
dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))

current_cache = caches[L-1]
grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, activation="sigmoid")

for l in reversed(range(L-1)):
current_cache = caches[l]
dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA"+str(l+2)], current_cache, activation="relu")
grads["dA" + str(l + 1)] = dA_prev_temp
grads["dW" + str(l + 1)] = dW_temp
grads["db" + str(l + 1)] = db_temp

return grads

#更新参数
def update_parameters(parameters, grads, learning_rate):

L = len(parameters) // 2

for l in range(L):
parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]
parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * grads["db" + str(l + 1)]

return parameters

#多层神经网络模型
def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000,print_cost=False):

costs = []

parameters = initialize_parameters_deep(layers_dims)

for i in range(0, num_iterations):

AL, caches = L_model_forward(X, parameters)

cost = compute_cost(AL, Y)

grads = L_model_backward(AL, Y, caches)

parameters = update_parameters(parameters, grads, learning_rate)

if print_cost and i % 100 == 0:
print("Cost after iteration %i: %f" % (i, cost))
if print_cost and i % 100 == 0:
costs.append(cost)

#plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()

return parameters

#预测函数
def predict(X,Y,parameters):

m = X.shape[1]
n = len(parameters) // 2
p = np.zeros((1,m))

probas,caches = L_model_forward(X,parameters)

for i in range(0,probas.shape[1]):
if probas[0,i] > 0.5:
p[0,i] = 1
else:
p[0,i] = 0

print("Accuracy: " + str(np.sum((p == Y) / m)))

return p

train_x_orig, train_y, test_x_orig, test_y, classes = load_data()

#reshape训练集和测试集
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T

#标准化数据集，使输出限定在0和1之间
train_x = train_x_flatten/255.
test_x = test_x_flatten/255.

layers_dims = [12288, 20, 7, 5, 1] #实际上是四层，第一层12288是输入参数
parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations=2500, print_cost=True)
#predicrions_train = predict(train_x, train_y, parameters)
#predicrions_test = predict(test_x,test_y,parameters)

####test image
my_image = "flower01.jpg"
my_label_y = [1]

num_px = train_x_orig.shape[1]
d=fname = "images/"+my_image
image = np.array(ndimage.imread(fname, flatten=False))
my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))
my_predicted_image = predict(my_image,my_label_y,parameters)

plt.imshow(image)   #imshow方法绘制二维图片
plt.show()
print ("y = " + str(np.squeeze(my_predicted_image)) + ", your L-layer model predicts a \"" + classes[int(np.squeeze(my_predicted_image)),].decode("utf-8") +  "\" picture.")

效果图：

效果1:







对第一张图中可爱的小猫咪，从第二张图可以看到模型的误差最终减小到0.004329，预测结果是该图片是猫。

效果2:







对第一张图的小狗狗，从第二张图可以看出，神经网络觉得它是只猫，虽然很像猫，但它确实是条小狗，这就是神经网络的误差了。但是在这个例子中，神经网络的误差有0.122831，大于效果1中的误差，这是由于随即初始化时参数不同导致的，但是这里算出的结果差距有点大，可能是陷入局部最优解。

效果3:







对第一张图的花，从第二张图可以看出，神经网络觉得它不是猫。在这个例子中，神经网络的误差仅有0.003791，但是迭代的过程不太稳定，这样的情况偶尔会发生，可能与参数的初始值有关。