Deep Learning 吴恩达作业（一）

2018-06-15 2018-06-15 view times
Planar data classification with one hidden layer

不废话直接上代码，看神人的代码真的是惊叹！！！膜拜、模仿不想多说，看代码
单隐层神经网络：输入用tanh激励函数，输出用sigmoid激励函数
import numpy as np
import matplotlib.pyplot as plt
import sklearn
import sklearn.datasets
# import sklearn.linear_model

from planar_utils import  sigmoid, load_planar_dataset

#加载随机的平面点，画出样本的散点图
X, Y = load_planar_dataset()
''' # 画出样本的散点图  作业上画图的函数我这边都会报错
blue=['b']*200
color=['r']*200
color.extend(blue) #append添加单个元素 extend添加多个元素
plt.scatter(X[0, :], X[1, :], c=color, s=40) #scatter散点图
plt.show()
print(np.shape(X))
print(np.shape(Y))
'''

'''
#1. 逻辑回归
lg = sklearn.linear_model.LogisticRegression()
lg.fit(X.T, Y.ravel().T)  #训练 #.ravel()将多维数组降位一维
LG_predictions = lg.predict(X.T) #将训练数据作为测试数据放入预测结果，与正确标签比对
print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LG_predictions) + np.dot(1-Y,1-LG_predictions))/float(Y.size)*100) +'% ') #47%
plot_decision_boundary(lambda x: lg.predict(x), X, Y)

#2. 贝叶斯岭回归
br = sklearn.linear_model.BayesianRidge()
br.fit(X.T, Y.ravel().T) 
BR_predictions = br.predict(X.T)
print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,BR_predictions) + np.dot(1-Y,1-BR_predictions))/float(Y.size)*100) + '% ') #51%
'''

#3. deeplearning
# Defining the neural network structure
def layer_sizes(X, Y):
    """
    Arguments:
    X -- input dataset of shape (input size, number of examples)
    Y -- labels of shape (output size, number of examples)
    
    Returns:
    n_x -- the size of the input layer   输入层
    n_h -- the size of the hidden layer  隐藏层
    n_y -- the size of the output layer  输出层
    """
    ### START CODE HERE ### (≈ 3 lines of code)
    n_x = X.shape[0] # size of input layer 输入样本的特征个数
    n_h = 4          # 隐藏层的节点个数
    n_y = Y.shape[0] # size of output layer 输出结果
    ### END CODE HERE ###
    return (n_x, n_h, n_y)

# Initialize the model's parameters 初始化参数
def initialize_parameters(n_x, n_h, n_y):
    """
    Argument:
    n_x -- size of the input layer
    n_h -- size of the hidden layer
    n_y -- size of the output layer
    
    Returns:
    params -- python dictionary containing your parameters:
                    W1 -- weight matrix of shape (n_h, n_x)
                    b1 -- bias vector of shape (n_h, 1)
                    W2 -- weight matrix of shape (n_y, n_h)
                    b2 -- bias vector of shape (n_y, 1)
    """
    
    # np.random.seed(2) 
    
    ### START CODE HERE ### (≈ 4 lines of code)
    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))
    ### END CODE HERE ###
    
    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

# The Loop 前向传播
def forward_propagation(X, parameters):
    """
    Argument:
    X -- input data of size (n_x, m) X经过转置
    parameters -- python dictionary containing your parameters (output of initialization function)
    
    Returns:
    A2 -- The sigmoid output of the second activation
    cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
    """
    # Retrieve each parameter from the dictionary "parameters"
    ### START CODE HERE ### (≈ 4 lines of code)
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    ### END CODE HERE ###
    
    # Implement Forward Propagation to calculate A2 (probabilities)
    ### START CODE HERE ### (≈ 4 lines of code)
    Z1 = np.dot(W1,X)+b1    #.dot矩阵乘法 .multiply对应元素相乘
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2,A1)+b2
    A2 = sigmoid(Z2)
    ### END CODE HERE ###
    
    assert(A2.shape == (1, X.shape[1]))
    
    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}
    
    return A2, cache

# 计算cost function
def compute_cost(A2, Y, parameters):
    """
    Computes the cross-entropy cost given in equation (13)
    
    Arguments:
    A2 -- The sigmoid output of the second activation, of shape (1, number of examples)
    Y -- "true" labels vector of shape (1, number of examples)
    parameters -- python dictionary containing your parameters W1, b1, W2 and b2
    
    Returns:
    cost -- cross-entropy cost given equation (13)
    """
    
    m = Y.shape[1] # number of example

    # Compute the cross-entropy cost
    ### START CODE HERE ### (≈ 2 lines of code)
    logprobs = np.multiply(Y,np.log(A2))+np.multiply(1-Y,np.log(1-A2))  #一个样本的loss function
    cost = -np.sum(logprobs)/m  #所有样本的cost function
    ### END CODE HERE ###
    
    cost = np.squeeze(cost)     # makes sure cost is the dimension we expect.  #将维度为1的去掉 
                                # E.g., turns [[17]] into 17 
    assert(isinstance(cost, float)) 
    
    return cost

# 反向传播 计算参数梯度
def backward_propagation(parameters, cache, X, Y):
    """
    Implement the backward propagation using the instructions above.
    
    Arguments:
    parameters -- python dictionary containing our parameters 
    cache -- a dictionary containing "Z1", "A1", "Z2" and "A2".
    X -- input data of shape (2, number of examples)
    Y -- "true" labels vector of shape (1, number of examples)
    
    Returns:
    grads -- python dictionary containing your gradients with respect to different parameters
    """
    m = X.shape[1]
    
    # First, retrieve W1 and W2 from the dictionary "parameters".
    ### START CODE HERE ### (≈ 2 lines of code)
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    ### END CODE HERE ###
        
    # Retrieve also A1 and A2 from dictionary "cache".
    ### START CODE HERE ### (≈ 2 lines of code)
    A1 = cache["A1"]
    A2 = cache["A2"]
    ### END CODE HERE ###
    
    # Backward propagation: calculate dW1, db1, dW2, db2. 
    ### START CODE HERE ### (≈ 6 lines of code, corresponding to 6 equations on slide above)
    dZ2 = A2-Y
    dW2 = np.dot(dZ2,A1.T)/m
    db2 = np.sum(dZ2,axis=1,keepdims=True)/m   #按行相加，并且保持其二维特性
    dZ1 = np.multiply(np.dot(W2.T,dZ2),1-pow(A1,2)) 
    dW1 = np.dot(dZ1,X.T)/m
    db1 = np.sum(dZ1,axis=1,keepdims=True)/m
    ### END CODE HERE ###
    
    grads = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "db2": db2}
    
    return grads

# 更新参数 进行新一轮正向传播
def update_parameters(parameters, grads, learning_rate = 1.2):
    """
    Updates parameters using the gradient descent update rule given above
    
    Arguments:
    parameters -- python dictionary containing your parameters 
    grads -- python dictionary containing your gradients 
    
    Returns:
    parameters -- python dictionary containing your updated parameters 
    """
    # Retrieve each parameter from the dictionary "parameters"
    ### START CODE HERE ### (≈ 4 lines of code)
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    ### END CODE HERE ###
    
    # Retrieve each gradient from the dictionary "grads"
    ### START CODE HERE ### (≈ 4 lines of code)
    dW1 = grads["dW1"]
    db1 = grads["db1"]
    dW2 = grads["dW2"]
    db2 = grads["db2"]
    ## END CODE HERE ###
    
    # Update rule for each parameter
    ### START CODE HERE ### (≈ 4 lines of code)
    W1 = W1-learning_rate*dW1
    b1 = b1-learning_rate*db1
    W2 = W2-learning_rate*dW2
    b2 = b2-learning_rate*db2
    ### END CODE HERE ###
    
    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}
    
    return parameters


 
# 组合前面的函数
def nn_model(X, Y, n_h, num_iterations = 10000, print_cost=False):
    """
    Arguments:
    X -- dataset of shape (2, number of examples)
    Y -- labels of shape (1, number of examples)
    n_h -- size of the hidden layer
    num_iterations -- Number of iterations in gradient descent loop
    print_cost -- if True, print the cost every 1000 iterations

    !--用到的变量--!
    待求参数parameters = {"W1": W1,"b1": b1, "W2": W2, "b2": b2} 先初始化，然后更新
    中间变量cache = {"Z1": Z1,"A1": A1, "Z2": Z2,"A2": A2}
    代价函数cost
    梯度grads = {"dW1": dW1, "db1": db1,"dW2": dW2, "db2": db2} 
    
    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """
    
    #np.random.seed(3)
    n_x = layer_sizes(X, Y)[0] #一个样本 输入特征个数
    n_y = layer_sizes(X, Y)[2] #一个样本 输出结果
    
    # Initialize parameters, then retrieve W1, b1, W2, b2. Inputs: "n_x, n_h, n_y". Outputs = "W1, b1, W2, b2, parameters".
    ### START CODE HERE ### (≈ 5 lines of code)
    parameters = initialize_parameters(n_x, n_h, n_y) #初始化参数
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    ### END CODE HERE ###
    
    # Loop (gradient descent)
    for i in range(0, num_iterations): #梯度下降迭代次数
         
        ### START CODE HERE ### (≈ 4 lines of code)
        # Forward propagation. Inputs: "X, parameters". Outputs: "A2, cache".
        A2, cache = forward_propagation(X, parameters)
        
        # 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)
 
        # Gradient descent parameter update. Inputs: "parameters, grads". Outputs: "parameters".
        parameters = update_parameters(parameters, grads)
        
        ### END CODE HERE ###
        
        # Print the cost every 1000 iterations
        if print_cost and i % 1000 == 0:
            print ("Cost after iteration %i: %f" %(i, cost)) #每迭代1000次 输出cost function

    return parameters

# 预测值
def predict(parameters, X):
    """
    Using the learned parameters, predicts a class for each example in X
    
    Arguments:
    parameters -- python dictionary containing your parameters 
    X -- input data of size (n_x, m)
    
    Returns
    predictions -- vector of predictions of our model (red: 0 / blue: 1)
    """
    
    # Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold.
    ### START CODE HERE ### (≈ 2 lines of code)
    A2, cache = forward_propagation(X, parameters)
    predictions = np.round(A2) #四舍五入
    ### END CODE HERE ###
    
    return predictions

# Build a model with a n_h-dimensional hidden layer
n_h = 1
parameters = nn_model(X, Y, n_h, num_iterations = 10000)
# Print accuracy
predictions = predict(parameters, X)
Acc=float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100)
print ('隐藏层节点：%d'%n_h+'  '+'准确率： %0.3f' %Acc+'%')
改变隐藏层的节点数，得到的结果