吴恩达-神经网络-week1-hw3

Ref：https://blog.csdn.net/u013733326/article/details/79702148

点击查看代码

from testCases import *
from planar_utils import plot_decision_boundary, \
    sigmoid, load_planar_dataset, load_extra_datasets

import sklearn
import sklearn.datasets
import sklearn.linear_model
import numpy as np
import matplotlib.pyplot as plt
import traceback

np.random.seed(1)
X, Y = load_planar_dataset()

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

# --------------------dimension------------------------------------------
shape_X = X.shape
shape_Y = Y.shape
m = shape_Y[1]  # the number of training set
print("X的维度: " + str(shape_X))
print("Y的维度: " + str(shape_Y))
print("数据集的数据个数： " + str(m) + "个")

# ------------------Logistics Reg----------------------------------------
print('======================Logistics Regression===============================')

LR_model = sklearn.linear_model.LogisticRegressionCV()
LR_model.fit(X.T, Y.T)

plt.figure()
plot_decision_boundary(lambda x: LR_model.predict(x), X, Y)
plt.title("Logistic Regression")

LR_predictions = LR_model.predict(X.T)
accur = (np.dot(Y, LR_predictions) + np.dot(1 - Y, 1 - LR_predictions)) / float(Y.size) * 100
print("逻辑回归准确性：%d" % float(accur)
      + '% ' + '(正确标记的数据点所占的百分比)')  # 47%

# -------------------NN----------------------------------------------------
def layers_size(X, Y, h_layers=4):
    """
    :param X: Input features
    :param Y: Label
    :param h_layers: # ( the hidden layers )
    :return: the number of input layer, the hidden of input layer, the number of output layer
    """
    n_x = X.shape[0]  # input
    n_h = h_layers  # hidden layer
    n_y = Y.shape[0]  # output
    return (n_x, n_h, n_y)

def initial_parameter(n_x, n_h, n_y):
    """
    W[i] 的维度是 （n[i], n[i-1])
    b[i] 的维度是  (n[i], 1)
    :param n_x: the number of input layer
    :param n_h: the number of hidden layer
    :param n_y: the number of output layer
    :return: 初始化的参数
    """
    np.random.seed(2)
    W1 = np.random.randn(n_h, n_x) * 0.02
    b1 = np.zeros(shape=(n_h, 1))

    W2 = np.random.randn(n_y, n_h) * 0.02
    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))

    paras = {
        'W1': W1,
        'b1': b1,
        'W2': W2,
        'b2': b2,
    }
    return paras

def forward_propagation(X, paras):
    """
    two layers nn model, 计算前向传播， tanh 和 SIGMOID 激活函数
    :param X:
    :param paras:
    :return:
    """
    W1 = paras['W1']
    b1 = paras['b1']
    W2 = paras['W2']
    b2 = paras['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):
    """
    this function compute the cost,
    :param A2: the activation of second layer
    :param Y: label: 0(not cat); 1(cat)
    :return: the cost of 2 layers nn model
    """
    try:
        m = Y.shape[1]
        log_prob = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
        cost = - np.sum(log_prob) / m
        cost = float(np.squeeze(cost))

        assert (isinstance(cost, float))
        return cost
    except:
        print(traceback.print_exc())

def back_propagation(paras, cache, X, Y):
    """
    the backward propagation of two layers nn model
    :param paras: the parameters of nn model
    :param cache: the activations of nn model
    :param X: input features
    :param Y: label
    :return: gradient: dW2, db2, dW1, db1
    """
    m = X.shape[1]
    W1 = paras['W1']
    W2 = paras['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)

    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_params(params, grads, alpha=0.01):
    """
    update the parameters of nn model according to the gradient of backward propagation
    :param params: the parameters of the last iteration in the path of backward propagation
    :param grads: the gradient of backward propagation
    :param alpha: learning rate, default is 0.01
    :return: the updated parameters
    """
    W1, W2 = params['W1'], params['W2']
    b1, b2 = params['b1'], params['b2']

    dw1, dw2 = grads['dW1'], grads['dW2']
    db1, db2 = grads['db1'], grads['db2']

    W1 = W1 - alpha * dw1
    W2 = W2 - alpha * dw2
    b1 = b1 - alpha * db1
    b2 = b2 - alpha * db2

    parameters = {
        'W1': W1,
        'b1': b1,
        'W2': W2,
        'b2': b2
    }

    return parameters

def nn_model(X, Y, n_h=4, num_iterations=10000, print_cost=False):
    """
    two layers of nn model,
    :param X: input features
    :param Y: output, the label
    :param n_h: the number of the hidden layer
    :param iterations: the number of the iterations
    :param print_cost: default is False
    :return: the parameters of the nn model which have been trained
    """
    np.random.seed(3)
    n_x = layers_size(X, Y)[0]
    n_y = layers_size(X, Y)[2]

    params = initial_parameter(n_x, n_h, n_y)

    for i in range(num_iterations):
        A2, cache = forward_propagation(X, params)
        cost = compute_cost(A2, Y)
        grads = back_propagation(params, cache, X, Y)
        params = update_params(params, grads, alpha=0.5)

        if i % 1000 == 0 and print_cost:
            print(f'第{i}次循环成本为：' + str(cost))

    return params

def predict_y(X, params):
    """
    :param X: input features
    :param params:
    :return: 0 or 1
    """
    A2, cache = forward_propagation(X, params)
    predict_y = np.round(A2)
    return predict_y

print('======================Two layers nn model===============================')
parameters = nn_model(X, Y, n_h=4, num_iterations=10000, print_cost=True)

prediction_y = predict_y(X, parameters)
accu = float((np.dot(Y, prediction_y.T) + np.dot(1 - Y, 1 - prediction_y.T)) / float(Y.size) * 100)
# print('准确率: %.1f' % accu + "%")
print(f'Hidden layer: 的准确率为{accu}')

# figure
plt.figure()
plot_decision_boundary(lambda x: predict_y(x.T, parameters), X, Y)
plt.title('Decision Boundary for hidden layer size ' + str(4))

# Multi hidden layers
plt.figure(figsize=(16, 32))
hidde_layers = [1, 2, 4, 6, 10, 20, 50]

for i, n_h in enumerate(hidde_layers):
    params = nn_model(X, Y, n_h, num_iterations=2000, print_cost=False)
    prediction_y = predict_y(X, params)
    plt.subplot(5, 2, i + 1)
    plot_decision_boundary(lambda x: predict_y(x.T, parameters), X, Y)
    plt.title(f'Decision Boundary for hidden layer size {n_h}')
    accu = float((np.dot(Y, prediction_y.T) + np.dot(1 - Y, 1 - prediction_y.T)) / float(Y.size) * 100)
    print(f'Hidden layer: {n_h}的准确率为{accu}')

plt.savefig('hidden layer.png')

if __name__ == "__main__":
    pass