deeplearning第1专题编程作业

Author: HuangCongQing

01神经网络和深度学习/Code编程作业/deeplearning第1专题编程作业/deeplearning编程作业/week2/Logistic Regression as a Neural Network/Logistic Regression with a Neural Network mindset v3.ipynb

@@ -0,0 +1,19 @@
+import numpy as np
+import h5py
+    
+    
+def load_dataset():
+    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
+    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
+    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels
+
+    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
+    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
+    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels
+
+    classes = np.array(test_dataset["list_classes"][:]) # the list of classes
+    
+    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
+    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
+    
+    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

01神经网络和深度学习/Code编程作业/deeplearning第1专题编程作业/deeplearning编程作业/week2/Logistic Regression as a Neural Network/datasets/test_catvnoncat.h5

@@ -0,0 +1,66 @@
+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

01神经网络和深度学习/Code编程作业/deeplearning第1专题编程作业/deeplearning编程作业/week2/Logistic Regression as a Neural Network/datasets/train_catvnoncat.h5

@@ -0,0 +1,119 @@
+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

01神经网络和深度学习/Code编程作业/deeplearning第1专题编程作业/deeplearning编程作业/week2/Logistic Regression as a Neural Network/lr_utils.py

@@ -0,0 +1,82 @@
+import numpy as np
+
+def sigmoid(Z):
+    """
+    Implements the sigmoid activation in numpy
+    
+    Arguments:
+    Z -- numpy array of any shape
+    
+    Returns:
+    A -- output of sigmoid(z), same shape as Z
+    cache -- returns Z as well, useful during backpropagation
+    """
+    
+    A = 1/(1+np.exp(-Z))
+    cache = Z
+    
+    return A, cache
+
+def relu(Z):
+    """
+    Implement the RELU function.
+
+    Arguments:
+    Z -- Output of the linear layer, of any shape
+
+    Returns:
+    A -- Post-activation parameter, of the same shape as Z
+    cache -- a python dictionary containing "A" ; stored for computing the backward pass efficiently
+    """
+    
+    A = np.maximum(0,Z)
+    
+    assert(A.shape == Z.shape)
+    
+    cache = Z 
+    return A, cache
+
+
+def relu_backward(dA, cache):
+    """
+    Implement the backward propagation for a single RELU unit.
+
+    Arguments:
+    dA -- post-activation gradient, of any shape
+    cache -- 'Z' where we store for computing backward propagation efficiently
+
+    Returns:
+    dZ -- Gradient of the cost with respect to Z
+    """
+    
+    Z = cache
+    dZ = np.array(dA, copy=True) # just converting dz to a correct object.
+    
+    # When z <= 0, you should set dz to 0 as well. 
+    dZ[Z <= 0] = 0
+    
+    assert (dZ.shape == Z.shape)
+    
+    return dZ
+
+def sigmoid_backward(dA, cache):
+    """
+    Implement the backward propagation for a single SIGMOID unit.
+
+    Arguments:
+    dA -- post-activation gradient, of any shape
+    cache -- 'Z' where we store for computing backward propagation efficiently
+
+    Returns:
+    dZ -- Gradient of the cost with respect to Z
+    """
+    
+    Z = cache
+    
+    s = 1/(1+np.exp(-Z))
+    dZ = dA * s * (1-s)
+    
+    assert (dZ.shape == Z.shape)
+    
+    return dZ
+