吴恩达深度学习第一课第三周课后作业
Planar data classification with one hidden layer
建立只有一个隐藏层的神经网络
主程序如下：
# coding:utf-8
import numpy as np
import matplotlib.pyplot as plt
from testCases import *
import sklearn
import sklearn.datasets
import sklearn.linear_model
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets
np.random.seed(1) # set a seed so that the results are consistent
X, Y = load_planar_dataset()
shape_X = X.shape
shape_Y = Y.shape
m = shape_X[1] # training set size
print ('The shape of X is: ' + str(shape_X)) #每个样本为2维，即输入层为2个单元，总共有400个样本
print ('The shape of Y is: ' + str(shape_Y)) #总共有400个标签，400个样本
print ('I have m = %d training examples!' % (m))
# 定义每个层的单元数
def layer_sizes(X, Y):
n_x = X.shape[0] # size of input layer
n_h = 4 #hide_layer神经元的个数
n_y = Y.shape[0] # size of output layer
return (n_x, n_h, n_y)
X_assess, Y_assess = layer_sizes_test_case() #从testcases中导入输入层、输出层单元数
(n_x, n_h, n_y) = layer_sizes(X_assess, Y_assess)
print("The size of the input layer is: n_x = " + str(n_x)) #输入层为5
print("The size of the hidden layer is: n_h = " + str(n_h)) # 隐藏层为4
print("The size of the output layer is: n_y = " + str(n_y)) #输出层为2
#初始化权重
#神经网络中权重不能初始化为0，针对逻辑回归，可为0
def initialize_parameters(n_x, n_h, n_y):
np.random.seed(2) # we set up a seed so that your output matches ours although the initialization is random.
W1 = np.random.randn(n_h, n_x) * 0.01
b1 = np.zeros((n_h, 1))
W2 = np.random.randn(n_y, n_h) * 0.01
b2 = np.zeros((n_y, 1))
assert (W1.shape == (n_h, n_x))
assert (b1.shape == (n_h, 1))
assert (W2.shape == (n_y, n_h))
assert (b2.shape == (n_y, 1))
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
n_x, n_h, n_y = initialize_parameters_test_case() #从testcase中导入输入、中间、输出层的单元数
parameters = initialize_parameters(n_x, n_h, n_y)
print("W1 = " + str(parameters["W1"])) #4,2
print("b1 = " + str(parameters["b1"])) #4,1
print("W2 = " + str(parameters["W2"])) #1,4
print("b2 = " + str(parameters["b2"])) #1,1
def forward_propagation(X, parameters):
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache #A2为最终的输出，cache为每一层的缓存，即每层的z值，**值
X_assess, parameters = forward_propagation_test_case() #从testcase中给定权值以及输出值
A2, cache = forward_propagation(X_assess, parameters)
print(np.mean(cache['Z1']) ,np.mean(cache['A1']),np.mean(cache['Z2']),np.mean(cache['A2']))
def compute_cost(A2, Y, parameters):
m = Y.shape[1] # number of example
logprobs = Y * np.log(A2) + (1 - Y) * np.log(1 - A2) #A2为输出值
cost = -1./ m * np.sum(logprobs) #一定要注意，此处为-1. 浮点数 否则为计算出错
cost = np.squeeze(cost) # makes sure cost is the dimension we expect.
assert (isinstance(cost, float)) #isinstance(object, classinfo) 判断cost的数据类型 返回True or false
return cost
A2, Y_assess, parameters = compute_cost_test_case()
print("cost = " + str(compute_cost(A2, Y_assess, parameters)))
def backward_propagation(parameters, cache, X, Y):
m = X.shape[1] #数据的个数
W1 = parameters["W1"]
W2 = parameters["W2"]
A1 = cache["A1"]
A2 = cache["A2"]
dZ2 = A2 - Y
dW2 = 1. / m * np.dot(dZ2, A1.T)
db2 = 1./ m * np.sum(dZ2, axis=1, keepdims=True) #此处的1要全部改为1. 浮点数运算
dZ1 = np.dot(W2.T, dZ2) * (1. - np.power(A1, 2)) #np.power 计算A1的平方 此处用的**函数为tanh（z），导数为1-a1的平方
dW1 = 1. / m * np.dot(dZ1, X.T)
db1 = 1. / m * np.sum(dZ1, axis=1, keepdims=True)
grads = {"dW1": dW1,
"db1": db1,
"dW2": dW2,
"db2": db2}
return grads
parameters, cache, X_assess, Y_assess = backward_propagation_test_case()
grads = backward_propagation(parameters, cache, X_assess, Y_assess)
print ("dW1 = "+ str(grads["dW1"]))
print ("db1 = "+ str(grads["db1"]))
print ("dW2 = "+ str(grads["dW2"]))
print ("db2 = "+ str(grads["db2"]))
def update_parameters(parameters, grads, learning_rate=1.2):
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
dW1 = grads["dW1"]
db1 = grads["db1"]
dW2 = grads["dW2"]
db2 = grads["db2"]
W1 = W1 - learning_rate * dW1
b1 = b1 - learning_rate * db1
W2 = W2 - learning_rate * dW2
b2 = b2 - learning_rate * db2
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
parameters, grads = update_parameters_test_case()
parameters = update_parameters(parameters, grads)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
def nn_model(X, Y, n_h, num_iterations=10000, print_cost=False):
np.random.seed(3)
n_x = layer_sizes(X, Y)[0]
n_y = layer_sizes(X, Y)[2]
# 初始化权重, then retrieve W1, b1, W2, b2. Inputs: "n_x, n_h, n_y". Outputs = "W1, b1, W2, b2, parameters".
parameters = initialize_parameters(n_x, n_h, n_y)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# Loop (gradient descent)
for i in range(0, num_iterations):
# Forward propagation. Inputs: "X, parameters". Outputs: "A2, cache".
A2, cache = forward_propagation(X, parameters) #A2为前向传播的最终输出，cache为每一层的z值和**值
# Cost function. Inputs: "A2, Y, parameters". Outputs: "cost".
cost = compute_cost(A2, Y, parameters)
# Backpropagation. Inputs: "parameters, cache, X, Y". Outputs: "grads".
grads = backward_propagation(parameters, cache, X, Y) #梯度，为每一层的dw dz
# Gradient descent parameter update. Inputs: "parameters, grads". Outputs: "parameters".
parameters = update_parameters(parameters, grads) #对每一层的权重进行更新
# Print the cost every 1000 iterations
if print_cost and i % 1000 == 0:
print ("Cost after iteration %i: %f" % (i, cost))
return parameters
X_assess, Y_assess = nn_model_test_case()
parameters = nn_model(X_assess, Y_assess, 4, num_iterations=10000, print_cost=False)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
def predict(parameters, X):
# Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold.
A2, cache = forward_propagation(X, parameters)
predictions = np.round(A2)
return predictions
parameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)其中还包括一下两部分程序
主要用来实现**函数，初始化权重等
1.testCases
import numpy as np
def layer_sizes_test_case():
np.random.seed(1)
X_assess = np.random.randn(5, 3)
Y_assess = np.random.randn(2, 3)
return X_assess, Y_assess
def initialize_parameters_test_case():
n_x, n_h, n_y = 2, 4, 1
return n_x, n_h, n_y
def forward_propagation_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
parameters = {'W1': np.array([[-0.00416758, -0.00056267],
[-0.02136196, 0.01640271],
[-0.01793436, -0.00841747],
[0.00502881, -0.01245288]]),
'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]),
'b1': np.array([[0.],
[0.],
[0.],
[0.]]),
'b2': np.array([[0.]])}
return X_assess, parameters
def compute_cost_test_case():
np.random.seed(1)
Y_assess = np.random.randn(1, 3)
parameters = {'W1': np.array([[-0.00416758, -0.00056267],
[-0.02136196, 0.01640271],
[-0.01793436, -0.00841747],
[0.00502881, -0.01245288]]),
'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]),
'b1': np.array([[0.],
[0.],
[0.],
[0.]]),
'b2': np.array([[0.]])}
a2 = (np.array([[0.5002307, 0.49985831, 0.50023963]]))
return a2, Y_assess, parameters
def backward_propagation_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
Y_assess = np.random.randn(1, 3)
parameters = {'W1': np.array([[-0.00416758, -0.00056267],
[-0.02136196, 0.01640271],
[-0.01793436, -0.00841747],
[0.00502881, -0.01245288]]),
'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]),
'b1': np.array([[0.],
[0.],
[0.],
[0.]]),
'b2': np.array([[0.]])}
cache = {'A1': np.array([[-0.00616578, 0.0020626, 0.00349619],
[-0.05225116, 0.02725659, -0.02646251],
[-0.02009721, 0.0036869, 0.02883756],
[0.02152675, -0.01385234, 0.02599885]]),
'A2': np.array([[0.5002307, 0.49985831, 0.50023963]]),
'Z1': np.array([[-0.00616586, 0.0020626, 0.0034962],
[-0.05229879, 0.02726335, -0.02646869],
[-0.02009991, 0.00368692, 0.02884556],
[0.02153007, -0.01385322, 0.02600471]]),
'Z2': np.array([[0.00092281, -0.00056678, 0.00095853]])}
return parameters, cache, X_assess, Y_assess
def update_parameters_test_case():
parameters = {'W1': np.array([[-0.00615039, 0.0169021],
[-0.02311792, 0.03137121],
[-0.0169217, -0.01752545],
[0.00935436, -0.05018221]]),
'W2': np.array([[-0.0104319, -0.04019007, 0.01607211, 0.04440255]]),
'b1': np.array([[-8.97523455e-07],
[8.15562092e-06],
[6.04810633e-07],
[-2.54560700e-06]]),
'b2': np.array([[9.14954378e-05]])}
grads = {'dW1': np.array([[0.00023322, -0.00205423],
[0.00082222, -0.00700776],
[-0.00031831, 0.0028636],
[-0.00092857, 0.00809933]]),
'dW2': np.array([[-1.75740039e-05, 3.70231337e-03, -1.25683095e-03,
-2.55715317e-03]]),
'db1': np.array([[1.05570087e-07],
[-3.81814487e-06],
[-1.90155145e-07],
[5.46467802e-07]]),
'db2': np.array([[-1.08923140e-05]])}
return parameters, grads
def nn_model_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
Y_assess = np.random.randn(1, 3)
return X_assess, Y_assess
def predict_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
parameters = {'W1': np.array([[-0.00615039, 0.0169021],
[-0.02311792, 0.03137121],
[-0.0169217, -0.01752545],
[0.00935436, -0.05018221]]),
'W2': np.array([[-0.0104319, -0.04019007, 0.01607211, 0.04440255]]),
'b1': np.array([[-8.97523455e-07],
[8.15562092e-06],
[6.04810633e-07],
[-2.54560700e-06]]),
'b2': np.array([[9.14954378e-05]])}
return parameters, X_assess
2.planar_utils
import matplotlib.pyplot as plt
import numpy as np
import sklearn
import sklearn.datasets
import sklearn.linear_model
def plot_decision_boundary(model, X, y):
# Set min and max values and give it some padding
x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
h = 0.01
# Generate a grid of points with distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
# Predict the function value for the whole grid
Z = model(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.ylabel('x2')
plt.xlabel('x1')
plt.scatter(X[0, :], X[1, :], c=y, cmap=plt.cm.Spectral)
def sigmoid(x):
"""
Compute the sigmoid of x
Arguments:
x -- A scalar or numpy array of any size.
Return:
s -- sigmoid(x)
"""
s = 1 / (1 + np.exp(-x))
return s
def load_planar_dataset():
np.random.seed(1)
m = 400 # number of examples
N = int(m / 2) # number of points per class
D = 2 # dimensionality
X = np.zeros((m, D)) # data matrix where each row is a single example
Y = np.zeros((m, 1), dtype='uint8') # labels vector (0 for red, 1 for blue)
a = 4 # maximum ray of the flower
for j in range(2):
ix = range(N * j, N * (j + 1))
t = np.linspace(j * 3.12, (j + 1) * 3.12, N) + np.random.randn(N) * 0.2 # theta
r = a * np.sin(4 * t) + np.random.randn(N) * 0.2 # radius
X[ix] = np.c_[r * np.sin(t), r * np.cos(t)]
Y[ix] = j
X = X.T
Y = Y.T
return X, Y
def load_extra_datasets():
N = 200
noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3)
noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2)
blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6)
gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2,
n_classes=2, shuffle=True, random_state=None)
no_structure = np.random.rand(N, 2), np.random.rand(N, 2)
return noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure下图为反向传播时，每一层dw、db的计算方式，依照以下的方式依次计算每一层的权重即可
主要流程为：
1.定义输入层、隐藏层、输出层的神经元个数
2.根据不同的层数、初始化权重（不能为0）
3.实现前向传播
4.计算loss
5.反向传播
6.更新权重
7.定义总的模型函数
8.做出预测