神经网络

///参考资料中文////参考资料英文///

双层神经网络

模块导入

import numpy as np  
import matplotlib.pyplot as plt  
import sklearn  
import sklearn.datasets  
import sklearn.linear_model  
from planar_utils import plot_decision_boundary, sigmoid , load_planar_dataset  

%matplotlib inline  

np.random.seed(1)  

X, Y = load_planar_dataset()#加载数据  

数据可视化

plt.scatter(X[0, :], X[1, :], c = np.squeeze(Y), s = 40, cmap=plt.cm.Spectral)  

<matplotlib.collections.PathCollection at 0x1d800b7e6a0>  

数据分析

shape_X = X.shape  
shape_Y = Y.shape  
m = Y.shape[1]  

print(shape_X)  
print(shape_Y)  
print(m)  

(2, 400)  
(1, 400)  
400  

神经搭建

数据结构获取

def layer_size(X, Y):  
    n_x = X.shape[0]  
    n_h = 4  
    n_y = Y.shape[0]  

    return (n_x, n_h, n_y)  

参数初始化

def initialize_parametiers(n_x, n_h, n_y):  
    np.random.seed(2)  
    W1 = np.random.randn(n_h, n_x) *  0.01  
    b1 = np.zeros(shape=(n_h, 1))  
    W2 = np.random.randn(n_y, n_h) * 0.01  
    b2 = np.zeros(shape=(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  

向前传播

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)  

计算成本函数

def compute_cost(A2, Y, parameters):  
    m = Y.shape[1]  
    W1 = parameters["W1"]  
    W2 = parameters["W2"]  

    logprobs = np.multiply(np.log(A2), Y) + np.multiply( np.log(1 - A2), (1 - Y))  
    cost = -np.sum(logprobs) / m  
    cost = float(np.squeeze(cost))  

    assert(isinstance(cost, float))  

    return cost  

反向传播

def backward_propagation(parameters, chche, X, Y):  
    m = X.shape[1]  

    W1 = parameters["W1"]  
    W2 = parameters["W2"]  

    A1 = chche["A1"]  
    A2 = chche["A2"]  

    dZ2 = A2 - Y  
    dW2 = (1 / m) * np.dot(dZ2, A1.T)  
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)  
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))  
    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  

更新参数

def update_parameters(parameters, grads, learning_rate=1.2):  
    W1, W2 = parameters["W1"], parameters["W2"]  
    b1, b2 = parameters["b1"], parameters["b2"]  

    dW1, dW2 = grads["dW1"], grads["dW2"]  
    db1, db2 = grads["db1"], 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  

整合

def nn_model(X, Y, n_h, num_iterations, learning_rate=0.5, print_cost=False):  
    np.random.seed(3)  
    n_x, n_y = layer_size(X, Y)[0], layer_size(X, Y)[2]  

    parameters = initialize_parametiers(n_x, n_h, n_y)  
    W1, b1 = parameters["W1"], parameters["b1"]  
    W2, b2 = parameters["W2"], parameters["b2"]  

    for i in range(num_iterations):  
        A2, cache = forward_propagation(X, parameters)  
        cost = compute_cost(A2, Y, parameters)  
        grads = backward_propagation(parameters, cache, X, Y)  
        parameters = update_parameters(parameters, grads, learning_rate)  

        if print_cost:  
            if i % 1000 == 0:  
                print("第%d次循环， 成本为：%s" % (i, str(cost)))  

    return parameters  

构建预测

def predict(parameters, X):  
    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)  

#plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)  
plot_decision_boundary(lambda x: predict(parameters, x.T), X, np.squeeze(Y))  
plt.title("Decison Boundary for hidden layer size" + str(4))  

predictions = predict(parameters, X)  
print ('准确率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')  

第0次循环， 成本为：0.6930480201239823  
第1000次循环， 成本为：0.3098018601352803  
第2000次循环， 成本为：0.2924326333792646  
第3000次循环， 成本为：0.2833492852647412  
第4000次循环， 成本为：0.27678077562979253  
第5000次循环， 成本为：0.26347155088593144  
第6000次循环， 成本为：0.24204413129940763  
第7000次循环， 成本为：0.23552486626608762  
第8000次循环， 成本为：0.23140964509854278  
第9000次循环， 成本为：0.22846408048352365  
准确率: 90%  

plt.figure(figsize=(16, 32))  
hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50] #隐藏层数量  
for i, n_h in enumerate(hidden_layer_sizes):  
    plt.subplot(5, 2, i + 1)  
    plt.title('Hidden Layer of size %d' % n_h)  
    parameters = nn_model(X, Y, n_h, num_iterations=5000)  
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, np.squeeze(Y))  
    predictions = predict(parameters, X)  
    accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)  
    print ("隐藏层的节点数量： {}  ，准确率: {} %".format(n_h, accuracy))  

隐藏层的节点数量： 1  ，准确率: 67.25 %  
隐藏层的节点数量： 2  ，准确率: 66.5 %  
隐藏层的节点数量： 3  ，准确率: 89.25 %  
隐藏层的节点数量： 4  ，准确率: 90.0 %  
隐藏层的节点数量： 5  ，准确率: 89.75 %  
隐藏层的节点数量： 20  ，准确率: 90.0 %  
隐藏层的节点数量： 50  ，准确率: 89.75 %  

planar_utils.py文件源码解析

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):  
    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