Add files via upload

Author: Umer Farooq

Deep Learning and Neural Network/week1/deep-learning-notation.pdf

@@ -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

Deep Learning and Neural Network/week2/week2-Logistic+Regression+with+a+Neural+Network+mindset.ipynb

@@ -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

Deep Learning and Neural Network/week2/week2-Python+Basics+With+Numpy.ipynb

@@ -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
+

Deep Learning and Neural Network/week3/planar_utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+
+def linear_forward_test_case():
+    X = np.array([[-1.02387576, 1.12397796],
+ [-1.62328545, 0.64667545],
+ [-1.74314104, -0.59664964]])
+    W = np.array([[ 0.74505627, 1.97611078, -1.24412333]])
+    b = 5
+    
+    return X, W, b
+
+def linear_activation_forward_test_case():
+    X = np.array([[-1.02387576, 1.12397796],
+ [-1.62328545, 0.64667545],
+ [-1.74314104, -0.59664964]])
+    W = np.array([[ 0.74505627, 1.97611078, -1.24412333]])
+    b = 5
+    return X, W, b
+
+def L_model_forward_test_case():
+    X = np.array([[-1.02387576, 1.12397796],
+ [-1.62328545, 0.64667545],
+ [-1.74314104, -0.59664964]])
+    parameters = {'W1': np.array([[ 1.62434536, -0.61175641, -0.52817175],
+        [-1.07296862,  0.86540763, -2.3015387 ]]),
+ 'W2': np.array([[ 1.74481176, -0.7612069 ]]),
+ 'b1': np.array([[ 0.],
+        [ 0.]]),
+ 'b2': np.array([[ 0.]])}
+    return X, parameters
+
+def compute_cost_test_case():
+    Y = np.asarray([[1, 1, 1]])
+    aL = np.array([[.8,.9,0.4]])
+    
+    return Y, aL
+
+def linear_backward_test_case():
+    z, linear_cache = (np.array([[ 3.1980455 ,  7.85763489]]), (np.array([[-1.02387576,  1.12397796],
+       [-1.62328545,  0.64667545],
+       [-1.74314104, -0.59664964]]), np.array([[ 0.74505627,  1.97611078, -1.24412333]]), 5))
+    
+    return z, linear_cache
+
+def linear_activation_backward_test_case():
+    aL, linear_activation_cache = (np.array([[ 3.1980455 ,  7.85763489]]), ((np.array([[-1.02387576,  1.12397796], [-1.62328545,  0.64667545], [-1.74314104, -0.59664964]]), np.array([[ 0.74505627,  1.97611078, -1.24412333]]), 5), np.array([[ 3.1980455 ,  7.85763489]])))
+    
+    return aL, linear_activation_cache
+
+def L_model_backward_test_case():
+    X = np.random.rand(3,2)
+    Y = np.array([[1, 1]])
+    parameters = {'W1': np.array([[ 1.78862847,  0.43650985,  0.09649747]]), 'b1': np.array([[ 0.]])}
+
+    aL, caches = (np.array([[ 0.60298372,  0.87182628]]), [((np.array([[ 0.20445225,  0.87811744],
+           [ 0.02738759,  0.67046751],
+           [ 0.4173048 ,  0.55868983]]),
+    np.array([[ 1.78862847,  0.43650985,  0.09649747]]),
+    np.array([[ 0.]])),
+   np.array([[ 0.41791293,  1.91720367]]))])
+
+    return X, Y, aL, caches
+
+def update_parameters_test_case():
+    parameters = {'W1': np.array([[ 1.78862847,  0.43650985,  0.09649747],
+        [-1.8634927 , -0.2773882 , -0.35475898],
+        [-0.08274148, -0.62700068, -0.04381817],
+        [-0.47721803, -1.31386475,  0.88462238]]),
+ 'W2': np.array([[ 0.88131804,  1.70957306,  0.05003364, -0.40467741],
+        [-0.54535995, -1.54647732,  0.98236743, -1.10106763],
+        [-1.18504653, -0.2056499 ,  1.48614836,  0.23671627]]),
+ 'W3': np.array([[-1.02378514, -0.7129932 ,  0.62524497],
+        [-0.16051336, -0.76883635, -0.23003072]]),
+ 'b1': np.array([[ 0.],
+        [ 0.],
+        [ 0.],
+        [ 0.]]),
+ 'b2': np.array([[ 0.],
+        [ 0.],
+        [ 0.]]),
+ 'b3': np.array([[ 0.],
+        [ 0.]])}
+    grads = {'dW1': np.array([[ 0.63070583,  0.66482653,  0.18308507],
+        [ 0.        ,  0.        ,  0.        ],
+        [ 0.        ,  0.        ,  0.        ],
+        [ 0.        ,  0.        ,  0.        ]]),
+ 'dW2': np.array([[ 1.62934255,  0.        ,  0.        ,  0.        ],
+        [ 0.        ,  0.        ,  0.        ,  0.        ],
+        [ 0.        ,  0.        ,  0.        ,  0.        ]]),
+ 'dW3': np.array([[-1.40260776,  0.        ,  0.        ]]),
+ 'da1': np.array([[ 0.70760786,  0.65063504],
+        [ 0.17268975,  0.15878569],
+        [ 0.03817582,  0.03510211]]),
+ 'da2': np.array([[ 0.39561478,  0.36376198],
+        [ 0.7674101 ,  0.70562233],
+        [ 0.0224596 ,  0.02065127],
+        [-0.18165561, -0.16702967]]),
+ 'da3': np.array([[ 0.44888991,  0.41274769],
+        [ 0.31261975,  0.28744927],
+        [-0.27414557, -0.25207283]]),
+ 'db1': 0.75937676204411464,
+ 'db2': 0.86163759922811056,
+ 'db3': -0.84161956022334572}
+    return parameters, grads