Deep Neural Network for Image Classification: Application(吴恩达课程)
# GRADED FUNCTION: two_layer_modeldeftwo_layer_model(X, Y, layers_dims, learning_rate =0.0075, num_iterations =3000, print_cost=False):"""
Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.
Arguments:
X -- input data, of shape (n_x, number of examples)
Y -- true "label" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)
layers_dims -- dimensions of the layers (n_x, n_h, n_y)
num_iterations -- number of iterations of the optimization loop
learning_rate -- learning rate of the gradient descent update rule
print_cost -- If set to True, this will print the cost every 100 iterations
Returns:
parameters -- a dictionary containing W1, W2, b1, and b2
"""
np.random.seed(1)
grads ={}
costs =[]# to keep track of the cost
m = X.shape[1]# number of examples(n_x, n_h, n_y)= layers_dims
# Initialize parameters dictionary, by calling one of the functions you'd previously implemented#(≈ 1 line of code)# parameters = ...# YOUR CODE STARTS HERE
parameters = initialize_parameters(n_x, n_h, n_y)# YOUR CODE ENDS HERE# Get W1, b1, W2 and b2 from the dictionary parameters.
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]# Loop (gradient descent)for i inrange(0, num_iterations):# Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: "X, W1, b1, W2, b2". Output: "A1, cache1, A2, cache2".#(≈ 2 lines of code)# A1, cache1 = ...# A2, cache2 = ...# YOUR CODE STARTS HERE
A1, cache1 = linear_activation_forward(X, W1, b1,"relu")
A2, cache2 = linear_activation_forward(A1, W2, b2,"sigmoid")# YOUR CODE ENDS HERE# Compute cost#(≈ 1 line of code)# cost = ...# YOUR CODE STARTS HERE
cost = compute_cost(A2, Y)# YOUR CODE ENDS HERE# Initializing backward propagation
dA2 =-(np.divide(Y, A2)- np.divide(1- Y,1- A2))# Backward propagation. Inputs: "dA2, cache2, cache1". Outputs: "dA1, dW2, db2; also dA0 (not used), dW1, db1".#(≈ 2 lines of code)# dA1, dW2, db2 = ...# dA0, dW1, db1 = ...# YOUR CODE STARTS HERE
dA1, dW2, db2 = linear_activation_backward(dA2, cache2,"sigmoid")
dA0, dW1, db1 = linear_activation_backward(dA1, cache1,"relu")# YOUR CODE ENDS HERE# Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2
grads['dW1']= dW1
grads['db1']= db1
grads['dW2']= dW2
grads['db2']= db2
# Update parameters.#(approx. 1 line of code)# parameters = ...# YOUR CODE STARTS HERE
parameters = update_parameters(parameters, grads, learning_rate)# YOUR CODE ENDS HERE# Retrieve W1, b1, W2, b2 from parameters
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]# Print the cost every 100 iterationsif print_cost and i %100==0or i == num_iterations -1:print("Cost after iteration {}: {}".format(i, np.squeeze(cost)))if i %100==0or i == num_iterations:
costs.append(cost)return parameters, costs
defplot_costs(costs, learning_rate=0.0075):
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate ="+str(learning_rate))
plt.show()
# GRADED FUNCTION: L_layer_modeldefL_layer_model(X, Y, layers_dims, learning_rate =0.0075, num_iterations =3000, print_cost=False):"""
Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.
Arguments:
X -- data, numpy array of shape (num_px * num_px * 3, number of examples)
Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).
learning_rate -- learning rate of the gradient descent update rule
num_iterations -- number of iterations of the optimization loop
print_cost -- if True, it prints the cost every 100 steps
Returns:
parameters -- parameters learnt by the model. They can then be used to predict.
"""
np.random.seed(1)
costs =[]# keep track of cost# Parameters initialization.#(≈ 1 line of code)# parameters = ...# YOUR CODE STARTS HERE
parameters = initialize_parameters_deep(layers_dims)# YOUR CODE ENDS HERE# Loop (gradient descent)for i inrange(0, num_iterations):# Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.#(≈ 1 line of code)# AL, caches = ...# YOUR CODE STARTS HERE
AL, caches = L_model_forward(X, parameters)# YOUR CODE ENDS HERE# Compute cost.#(≈ 1 line of code)# cost = ...# YOUR CODE STARTS HERE
cost = compute_cost(AL, Y)# YOUR CODE ENDS HERE# Backward propagation.#(≈ 1 line of code)# grads = ... # YOUR CODE STARTS HERE
grads = L_model_backward(AL, Y, caches)# YOUR CODE ENDS HERE# Update parameters.#(≈ 1 line of code)# parameters = ...# YOUR CODE STARTS HERE
parameters = update_parameters(parameters, grads, learning_rate)# YOUR CODE ENDS HERE# Print the cost every 100 iterationsif print_cost and i %100==0or i == num_iterations -1:print("Cost after iteration {}: {}".format(i, np.squeeze(cost)))if i %100==0or i == num_iterations:
costs.append(cost)return parameters, costs