深度学习吴恩达作业题系列（5）

最新推荐文章于 2023-03-23 21:56:57 发布
最新推荐文章于 2023-03-23 21:56:57 发布
阅读量465 收藏 3
点赞数 1
分类专栏： 深度学习吴恩达 文章标签： 深度学习 机器学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42148307/article/details/108116490
版权

第一周

1.1初始化

init_utils：

import numpy as np
import matplotlib.pyplot as plt
import h5py#h5文件的相关读取操作
import sklearn
import sklearn.datasets
def sigmoid(x):
   s = 1/(1+np.exp(-x))
    return s
def relu(x):
    s = np.maximum(0,x)    
    return s
def forward_propagation(X, parameters):
   # retrieve parameters
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]  
    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    z1 = np.dot(W1, X) + b1
    a1 = relu(z1)
    z2 = np.dot(W2, a1) + b2
    a2 = relu(z2)
    z3 = np.dot(W3, a2) + b3
    a3 = sigmoid(z3)   
    cache = (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3)   
    return a3, cache
def backward_propagation(X, Y, cache):
    m = X.shape[1]
    (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3) = cache   
    dz3 = 1./m * (a3 - Y)
    dW3 = np.dot(dz3, a2.T)
    db3 = np.sum(dz3, axis=1, keepdims = True)    
    da2 = np.dot(W3.T, dz3)
    #dz2=da2*g`(z2)，np.int64将a的值转换成整数，例子，relu的求导：np.int64(A2 > 0)
    dz2 = np.multiply(da2, np.int64(a2 > 0))
    dW2 = np.dot(dz2, a1.T)
    db2 = np.sum(dz2, axis=1, keepdims = True)    
    da1 = np.dot(W2.T, dz2)
    dz1 = np.multiply(da1, np.int64(a1 > 0))
    dW1 = np.dot(dz1, X.T)
    db1 = np.sum(dz1, axis=1, keepdims = True)    
    gradients = {"dz3": dz3, "dW3": dW3, "db3": db3,
                 "da2": da2, "dz2": dz2, "dW2": dW2, "db2": db2,
                 "da1": da1, "dz1": dz1, "dW1": dW1, "db1": db1}    
    return gradients
def update_parameters(parameters, grads, learning_rate):
    L = len(parameters) // 2 # number of layers in the neural networks
    # Update rule for each parameter
    for k in range(L):
        parameters["W" + str(k+1)] = parameters["W" + str(k+1)] - learning_rate * grads["dW" + str(k+1)]
        parameters["b" + str(k+1)] = parameters["b" + str(k+1)] - learning_rate * grads["db" + str(k+1)]        
    return parameters
def compute_loss(a3, Y):
   m = Y.shape[1]
   #计算成本
    logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
    #np.nansum将矩阵中所有元素相加，包括NaN数
    loss = 1./m * np.nansum(logprobs)
    return loss
def load_cat_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 = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
    train_set_x_orig = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T
    test_set_x_orig = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
    train_set_x = train_set_x_orig/255
    test_set_x = test_set_x_orig/255
    return train_set_x, train_set_y, test_set_x, test_set_y, classes
def predict(X, y, parameters):
    m = X.shape[1]
    p = np.zeros((1,m), dtype = np.int)
    # Forward propagation
    a3, caches = forward_propagation(X, parameters)
    # convert probas to 0/1 predictions
    for i in range(0, a3.shape[1]):
        if a3[0,i] > 0.5:
            p[0,i] = 1
        else:
            p[0,i] = 0
    #正确预测的概率
    print("Accuracy: "  + str(np.mean((p[0,:] == y[0,:]))))  
    return p
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))
    # 预测对应点的Z值
    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.ravel(), cmap=plt.cm.Spectral)
    plt.show()   
def predict_dec(parameters, X):
    # Predict using forward propagation and a classification threshold of 0.5
    a3, cache = forward_propagation(X, parameters)
    predictions = (a3>0.5)
    return predictions
def load_dataset():
    np.random.seed(1)
    #生成同心圆的样本点，n_samples：样本点数目；noise：控制属于同一个圈的样本点附加的漂移程度；factor：控制内外圈的接近程度，		越大越接近，上限为1
    train_X, train_Y = sklearn.datasets.make_circles(n_samples=300, noise=.05)
    np.random.seed(2)
    #测试集
    test_X, test_Y = sklearn.datasets.make_circles(n_samples=100, noise=.05)
    # 可视化数据，train_Y代表内圈和外圈(0或1)，分别用颜色区分出来
    plt.scatter(train_X[:, 0], train_X[:, 1], c=train_Y, s=40, cmap=plt.cm.Spectral);
    train_X = train_X.T
    #1*n
    train_Y = train_Y.reshape((1, train_Y.shape[0]))
    test_X = test_X.T
    test_Y = test_Y.reshape((1, test_Y.shape[0]))
    return train_X, train_Y, test_X, test_Y

在这里插入图片描述
在这里插入图片描述

1.1.1神经网络模型

在这里插入图片描述

1.1.2参数初始化为0

在这里插入图片描述

1.1.3随机初始化

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.1.4He initialization

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、正则化

testCases：

import numpy as np
def compute_cost_with_regularization_test_case():
    np.random.seed(1)
    Y_assess = np.array([[1, 1, 0, 1, 0]])
    W1 = np.random.randn(2, 3)
    b1 = np.random.randn(2, 1)
    W2 = np.random.randn(3, 2)
    b2 = np.random.randn(3, 1)
    W3 = np.random.randn(1, 3)
    b3 = np.random.randn(1, 1)
    parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2, "W3": W3, "b3": b3}
    a3 = np.array([[ 0.40682402,  0.01629284,  0.16722898,  0.10118111,  0.40682402]])
    return a3, Y_assess, parameters
def backward_propagation_with_regularization_test_case():
    np.random.seed(1)
    X_assess = np.random.randn(3, 5)
    Y_assess = np.array([[1, 1, 0, 1, 0]])
    cache = (np.array([[-1.52855314,  3.32524635,  2.13994541,  2.60700654, -0.75942115],
         [-1.98043538,  4.1600994 ,  0.79051021,  1.46493512, -0.45506242]]),
  np.array([[ 0.        ,  3.32524635,  2.13994541,  2.60700654,  0.        ],
         [ 0.        ,  4.1600994 ,  0.79051021,  1.46493512,  0.        ]]),
  np.array([[-1.09989127, -0.17242821, -0.87785842],
         [ 0.04221375,  0.58281521, -1.10061918]]),
  np.array([[ 1.14472371],
         [ 0.90159072]]),
  np.array([[ 0.53035547,  5.94892323,  2.31780174,  3.16005701,  0.53035547],
         [-0.69166075, -3.47645987, -2.25194702, -2.65416996, -0.69166075],
         [-0.39675353, -4.62285846, -2.61101729, -3.22874921, -0.39675353]]),
  np.array([[ 0.53035547,  5.94892323,  2.31780174,  3.16005701,  0.53035547],
         [ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ],
         [ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ]]),
  np.array([[ 0.50249434,  0.90085595],
         [-0.68372786, -0.12289023],
         [-0.93576943, -0.26788808]]),
  np.array([[ 0.53035547],
         [-0.69166075],
         [-0.39675353]]),
  np.array([[-0.3771104 , -4.10060224, -1.60539468, -2.18416951, -0.3771104 ]]),
  np.array([[ 0.40682402,  0.01629284,  0.16722898,  0.10118111,  0.40682402]]),
  np.array([[-0.6871727 , -0.84520564, -0.67124613]]),
  np.array([[-0.0126646]]))
    return X_assess, Y_assess, cache
def forward_propagation_with_dropout_test_case():
    np.random.seed(1)
    X_assess = np.random.randn(3, 5)
    W1 = np.random.randn(2, 3)
    b1 = np.random.randn(2, 1)
    W2 = np.random.randn(3, 2)
    b2 = np.random.randn(3, 1)
    W3 = np.random.randn(1, 3)
    b3 = np.random.randn(1, 1)
    parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2, "W3": W3, "b3": b3}   
    return X_assess, parameters
def backward_propagation_with_dropout_test_case():
    np.random.seed(1)
    X_assess = np.random.randn(3, 5)
    Y_assess = np.array([[1, 1, 0, 1, 0]])
    cache = (np.array([[-1.52855314,  3.32524635,  2.13994541,  2.60700654, -0.75942115],
           [-1.98043538,  4.1600994 ,  0.79051021,  1.46493512, -0.45506242]]), np.array([[ True, False,  True,  True,  True],
           [ True,  True,  True,  True, False]], dtype=bool), np.array([[ 0.        ,  0.        ,  4.27989081,  5.21401307,  0.        ],
           [ 0.        ,  8.32019881,  1.58102041,  2.92987024,  0.        ]]), np.array([[-1.09989127, -0.17242821, -0.87785842],
           [ 0.04221375,  0.58281521, -1.10061918]]), np.array([[ 1.14472371],
           [ 0.90159072]]), np.array([[ 0.53035547,  8.02565606,  4.10524802,  5.78975856,  0.53035547],
           [-0.69166075, -1.71413186, -3.81223329, -4.61667916, -0.69166075],
           [-0.39675353, -2.62563561, -4.82528105, -6.0607449 , -0.39675353]]), np.array([[ True, False,  True, False,  True],
           [False,  True, False,  True,  True],
           [False, False,  True, False, False]], dtype=bool), np.array([[ 1.06071093,  0.        ,  8.21049603,  0.        ,  1.06071093],
           [ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ],
           [ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ]]), np.array([[ 0.50249434,  0.90085595],
           [-0.68372786, -0.12289023],
           [-0.93576943, -0.26788808]]), np.array([[ 0.53035547],
           [-0.69166075],
           [-0.39675353]]), np.array([[-0.7415562 , -0.0126646 , -5.65469333, -0.0126646 , -0.7415562 ]]), np.array([[ 0.32266394,  0.49683389,  0.00348883,  0.49683389,  0.32266394]]), np.array([[-0.6871727 , -0.84520564, -0.67124613]]), np.array([[-0.0126646]]))
    return X_assess, Y_assess, cache

reg_utils：

import numpy as np
import matplotlib.pyplot as plt
import h5py
import sklearn
import sklearn.datasets
import sklearn.linear_model
import scipy.io
def sigmoid(x):
    s = 1/(1+np.exp(-x))
    return s
def relu(x):
   s = np.maximum(0,x)  
    return s
def load_planar_dataset(seed):
    np.random.seed(seed)  
    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 initialize_parameters(layer_dims):
     np.random.seed(3)
    parameters = {}
    L = len(layer_dims) # number of layers in the network
    for l in range(1, L):
    #运用之前初始化参数的方法
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) / np.sqrt(layer_dims[l-1])
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))       
        assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1]))
        assert(parameters['W' + str(l)].shape == layer_dims[l], 1)
    return parameters
def forward_propagation(X, parameters):
   
    # retrieve parameters
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]   
    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    Z1 = np.dot(W1, X) + b1
    A1 = relu(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)
    Z3 = np.dot(W3, A2) + b3
    A3 = sigmoid(Z3)   
    cache = (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3)   
    return A3, cache
def backward_propagation(X, Y, cache):
    m = X.shape[1]
    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache    
    dZ3 = A3 - Y
    dW3 = 1./m * np.dot(dZ3, A2.T)
    db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)   
    dA2 = np.dot(W3.T, dZ3)
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    dW2 = 1./m * np.dot(dZ2, A1.T)
    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)   
    dA1 = np.dot(W2.T, dZ2)
    dZ1 = np.multiply(dA1, np.int64(A1 > 0))
    dW1 = 1./m * np.dot(dZ1, X.T)
    db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)  
    gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,
                 "dA2": dA2, "dZ2": dZ2, "dW2": dW2, "db2": db2,
                 "dA1": dA1, "dZ1": dZ1, "dW1": dW1, "db1": db1}  
    return gradients
def update_parameters(parameters, grads, learning_rate):
    
    n = len(parameters) // 2 # number of layers in the neural networks
    # Update rule for each parameter
    for k in range(n):
        parameters["W" + str(k+1)] = parameters["W" + str(k+1)] - learning_rate * grads["dW" + str(k+1)]
        parameters["b" + str(k+1)] = parameters["b" + str(k+1)] - learning_rate * grads["db" + str(k+1)]        
    return parameters
def predict(X, y, parameters):
   
    m = X.shape[1]
    p = np.zeros((1,m), dtype = np.int)
    # Forward propagation
    a3, caches = forward_propagation(X, parameters)
    # convert probas to 0/1 predictions
    for i in range(0, a3.shape[1]):
        if a3[0,i] > 0.5:
            p[0,i] = 1
        else:
            p[0,i] = 0
    # print results
    #print ("predictions: " + str(p[0,:]))
    #print ("true labels: " + str(y[0,:]))
    print("Accuracy: "  + str(np.mean((p[0,:] == y[0,:]))))
    return p
def compute_cost(a3, Y):
    
    m = Y.shape[1]
    logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
    cost = 1./m * np.nansum(logprobs)
    return cost
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 = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
    train_set_x_orig = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T
    test_set_x_orig = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
    train_set_x = train_set_x_orig/255
    test_set_x = test_set_x_orig/255
    return train_set_x, train_set_y, test_set_x, test_set_y, classes
def predict_dec(parameters, X):
    """
    Used for plotting decision boundary.
    Arguments:
    parameters -- python dictionary containing your parameters 
    X -- input data of size (m, K)
    Returns
    predictions -- vector of predictions of our model (red: 0 / blue: 1)
    """
    # Predict using forward propagation and a classification threshold of 0.5
    a3, cache = forward_propagation(X, parameters)
    predictions = (a3>0.5)
    return predictions
def load_planar_dataset(randomness, seed):
    np.random.seed(seed)
    m = 50
    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 = 2 # maximum ray of the flower
    for j in range(2):
        ix = range(N*j,N*(j+1))
        if j == 0:
            t = np.linspace(j, 4*3.1415*(j+1),N) #+ np.random.randn(N)*randomness # theta
            r = 0.3*np.square(t) + np.random.randn(N)*randomness # radius
        if j == 1:
            t = np.linspace(j, 2*3.1415*(j+1),N) #+ np.random.randn(N)*randomness # theta
            r = 0.2*np.square(t) + np.random.randn(N)*randomness # radius
        X[ix] = np.c_[r*np.cos(t), r*np.sin(t)]
        Y[ix] = j
    X = X.T
    Y = Y.T
    return X, Y
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.ravel(), cmap=plt.cm.Spectral)
    plt.show()
def load_2D_dataset():
    data = scipy.io.loadmat('datasets/data.mat')#加载mat数据
    train_X = data['X'].T
    train_Y = data['y'].T
    test_X = data['Xval'].T
    test_Y = data['yval'].T
    plt.scatter(train_X[0, :], train_X[1, :], c=train_Y.ravel(), s=40, cmap=plt.cm.Spectral);
    return train_X, train_Y, test_X, test_Y

在这里插入图片描述

2.1非正则化模型

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.2 L2正则化

在这里插入图片描述
在这里插入图片描述
正则化的后向传播：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3dropout正则化

简单来说就是关闭某些层的一些神经元，已到达简化神经网络的作用，从而降低过拟合。

2.3.1dropout前向传播

在这里插入图片描述
在这里插入图片描述

2.3.2dropout后向传播

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3、梯度检验

testCases：

import numpy as np
def gradient_check_n_test_case(): 
    np.random.seed(1)
    x = np.random.randn(4,3)
    y = np.array([1, 1, 0])
    W1 = np.random.randn(5,4) 
    b1 = np.random.randn(5,1) 
    W2 = np.random.randn(3,5) 
    b2 = np.random.randn(3,1) 
    W3 = np.random.randn(1,3) 
    b3 = np.random.randn(1,1) 
    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2,
                  "W3": W3,
                  "b3": b3}
    return x, y, parameters

gc_utils：

import numpy as np
def sigmoid(x):
    s = 1/(1+np.exp(-x))
    return s
def relu(x):
    s = np.maximum(0,x)
    return s
 #将字典变成数组
def dictionary_to_vector(parameters):
    keys = []
    count = 0
    for key in ["W1", "b1", "W2", "b2", "W3", "b3"]:
        # 将矩阵维数变成n*1
        new_vector = np.reshape(parameters[key], (-1,1))
        keys = keys + [key]*new_vector.shape[0]
        if count == 0:
            theta = new_vector
        else:
        #axis=0表示沿着数组垂直方向进行拼接
            theta = np.concatenate((theta, new_vector), axis=0)
        count = count + 1
    return theta, keys
def vector_to_dictionary(theta):
    parameters = {}
    parameters["W1"] = theta[:20].reshape((5,4))
    parameters["b1"] = theta[20:25].reshape((5,1))
    parameters["W2"] = theta[25:40].reshape((3,5))
    parameters["b2"] = theta[40:43].reshape((3,1))
    parameters["W3"] = theta[43:46].reshape((1,3))
    parameters["b3"] = theta[46:47].reshape((1,1))
    return parameters
def gradients_to_vector(gradients):
       count = 0
    for key in ["dW1", "db1", "dW2", "db2", "dW3", "db3"]:
        new_vector = np.reshape(gradients[key], (-1,1))
        if count == 0:
            theta = new_vector
        else:
            theta = np.concatenate((theta, new_vector), axis=0)
        count = count + 1
    return theta

在这里插入图片描述

3.1一维梯度检测

前向传播：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.2N维梯度检测

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

身影王座
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
吴恩达 深度学习课后作业系列 5
06-12
吴恩达 深度学习课后作业 深度学习系列课后作业系列1 ，week课后作业原题 看完视频还是得多多练习。
吴恩达深度学习编程作业 part 1-5
weixin_41992565的博客
06-11 538
import time import numpy as np import h5py import matplotlib.pyplot as plt import scipy from PIL import Image from scipy import ndimage %matplotlib inline plt.rcParams['figure.figsize'] = (5.0, 4.0) ...
吴恩达深度学习五门课作业链接资料
fighting1_1的博客
03-30 866
https://blog.csdn.net/u013733326/article/details/79827273
[个人笔记]吴恩达深度学习lesson5 week2自然语言处理与词嵌入（Natural Language Processing and Word Embeddings）
YuQiao0303的博客
07-04 175
这是一篇个人向的笔记。 推荐学习顺序： （可选）最好掌握线性代数、微积分、概率论的一些基本知识 学习吴恩达机器学习课程 学习吴恩达深度学习的前4课（也可以选择性学习部分内容）即第五课第一周 然后可以学习本课，即吴恩达深度学习第五课的第二周内容 本课程视频 本课程文字版 目录2.1 词汇表征（Word Representation） 2.1 词汇表征（Word Representation） ...
吴恩达机器学习课后作业5——怎么通过观察偏差和方差（bias vs variance）来调参
weixin_46915208的博客
06-23 588
在本练习中，您将实现正则化线性回归，并使用它来研究具有不同偏差-方差特性的模型。在练习的前半部分，您将实现正则化线性回归，利用水库水位的变化来预测从大坝流出的水量。在后半部分中，您将对调试学习算法进行一些诊断，并检查偏差和偏差的影响。之前的题目中我们只用到了训练集，用训练集来训练模型，又用训练集来验证模型，这样的泛化能力就比较差。 正常做法一般是先用训练集进行模型训练，训练好几个模型；然后用验证集来验证哪个模型效果好，选择好的模型并进行优化；最后是通过测试集对优化好的模型来进行最终的测试。......
吴恩达 课后作业 深度学习系列1
06-12
【深度学习系列1 - 吴恩达课后作业解析】 深度学习是现代人工智能领域中的一个核心组成部分，由著名学者吴恩达（Andrew Ng）教授的深度学习课程深受全球学习者欢迎。这个“深度学习系列1”包含了他在课程中布置的...
吴恩达 深度学习系列课后作业系列11
06-12
【标题】：“吴恩达 深度学习系列课后作业系列11”是指由著名计算机科学家、深度学习领域的领军人物吴恩达教授提供的深度学习课程中的第11个系列课后作业。这个系列的作业是针对已经完成观看吴恩达深度学习课程的...
吴恩达深度学习系列课后作业系列7
06-12
这个名为"吴恩达深度学习系列课后作业系列7"的资源包含了他在深度学习系列课程中的第七周课后作业，旨在帮助学员深入理解TensorFlow的使用以及深度学习的相关概念。吴恩达作为全球知名的人工智能专家，他的课程覆盖...
吴恩达-深度学习-课后作业-答案与总结
最新发布
05-17
资源名称：人工智能+物理神经网络+利用物理信息神经网络和断层带声学监测预测实验室地震+源码 ...【附加价值】：这些项目资源不仅具有很高的学习价值，而且能够直接应用于实际项目中，提高开发效率。对于有志于深入研
吴恩达深度学习作业.zip
08-17
吴恩达深度学习作业用到的planar_utils.py和testCases_cv2.py
吴恩达深度学习选择题（带解析）
12-25
这是吴恩达老师deep learning.ai即深度学习课程的选择题整理，里面包含博主对每道题的解析，配合网易云课堂教学视频效果更佳，分享给大家！
吴恩达深度学习课程 第一课 作业 （原题 + 自己写的答案）
12-28
吴恩达深度学习课程 第一课作业：包括 原题 以及 自己写的答案。 自己写的答案均检测过，其中因为代码更新而导致的问题也修改了。 原题没任何改动，但我加了一个修改提示文档。
吴恩达深度学习 | (5) 神经网络与深度学习专项课程第三周编程作业
sdu_hao的博客
12-03 2841
吴恩达深度学习专项课程的所有实验均采用JupyterNotebooks实现，不熟悉的朋友可以提前使用一下Notebooks。本周的实验主要是训练一个单隐层神经网络，进行2分类任务。采用的数据集都是平面数据集(2维数据集，输入特征数=2）。 目录 1.实验综述 2.导入必要的包 3.数据集 4.简单逻辑回归 5.神经网络模型 6.在其他数据集上进行尝试 1.实验综述 2...
吴恩达深度学习第二课-第一周笔记及课后编程题
m0_52370089的博客
03-23 451
吴恩达深度学习第二课-第一周笔记及课后编程题
深度学习吴恩达作业题系列（1）
qq_42148307的博客
08-12 3129
1、Python的基本操作_Numpy 第一个程序： 输出Hello world! 1.1建立运行numpy的基本函数 1.1.1sigmoid函数与np.exp() x = [1, 2, 3] basic_sigmoid(x) 运行就会出错，原因就是这里建立的是数组，而数组不能用于该模块里面的函数，需要将其转化为向量列表在numpy库里面的函数中运行才行，在该库的方法中，根据Python的广播机制，向量列表可以和常数一起运算。 1.1.2Sigmoid导数 1.1.3reshape arra
Course 2 - 改善深层神经网络 - 第一周作业(1&2&3) - 1.3梯度校验
qq_24599703的博客
03-28 331
1.梯度检查用于判断求导数的结果是否正确 1.1实现工具类 # -*- coding: utf-8 -*- import numpy as np import matplotlib.pyplot as plt def sigmoid(x): """ Compute the sigmoid of x Arguments: x -- ...
改善深层神经网络第一周-Gradient Checking（梯度检查）
bxg1065283526的博客
05-04 1241
Gradient CheckingWelcome to the final assignment for this week! In this assignment you will learn to implement and use gradient checking.You are part of a team working to make mobile payments availabl...
【深度学习_2.2】神经网络之算法优化
OliverChrist的博客
02-26 604
通过梯度下降可以更新参数并最小化cost函数，通过算法优化可以加速学习并可能会得到更优的cost函数值一、梯度下降L是神经网络的层数，α代表学习率， 所有参数都存在parameters字典里    Arguments:    parameters -- python dictionary containing your parameters to be updated:              ...
深度学习吴恩达作业题系列（6）
qq_42148307的博客
08-23 605
第二周：优化方法 opt_utils： import numpy as np import matplotlib.pyplot as plt import h5py import scipy.io import sklearn import sklearn.datasets def sigmoid(x): s = 1/(1+np.exp(-x)) return s def relu(x): s = np.maximum(0,x) return s def load_params
58-深度学习吴恩达谈深度学习：数据科学家需要知道这些.docx
12-14
深度学习专家吴恩达（Andrew Ng）在2015年的ExtractConf会议上发表演讲，探讨了数据科学家应掌握的深度学习基础知识。吴恩达通过实际案例，如机器看图说话、机器问答以及Dulight和Faceyou应用，阐述了深度学习在现实...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

身影王座

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值