deeplearning.ai-lecture1-building deep neural network-summary

 先上一张summary map



1. L层神经网络参数初始化: 返回各层参数W(1)…W(l-1)

def initialize_parameters_deep(layer_dims):

   for
l in
range(1,L):

        parameters['W'+str(l)]=np.random.randn(layer_dims[l],layer_dims[l-1])*0.01

        parameters['b'+str(l)]=np.zeros((layer_dims[l],1))

return parameters

 

Step 2:
1.网络的前向传播的线性部分:inputa[l-1]  output a[l],cache(z[l],w[l],b[l])/ 这里的A后续会由A_pre代替
def linear_forward(A,W,b):

    Z=np.dot(W,A)+b

   cache=(A,W,b)

    return Z,cache

2.实现relu和 sigmoid激活函数：input z[l], output a[l]/
返回a[l],z[l]

def sigmoid(Z):

       A =
1/(1+np.exp(-Z))

   cache = Z

    return A,
cache

def relu(Z):

    cache = Z
    A = np.maximum(0,Z)   

    assert(A.shape== Z.shape)

    cache = Z
   return
A,
cache

 
3.联合前两步，实现网络前向传播的一个【linear->activation】层 函数

def linear_activation_forward(A_prev,W,
b,
activation):

      
Z,
linear_cache= linear_forward(A_prev,
W,
b)

   A,
activation_cache = sigmoidor
relu(Z)

   cache = (linear_cache,
activation_cache)#activation_cache就是Z

return A,
cache#这里cache里存了（A,W,b和Z)

4.实现前向传播的前L-1层【linear->relu】最后一层的【linear->sigmoid】函数

def L_model_forward(X,
parameters):

    caches = []

    A = X
   for
l in
range(1,
L):

        A_prev= A

       A,
cache =linear_activation_f
1190f
orward(A_prev,
parameters['W'
+ str(l)],
parameters['b'
+ str(l)],
activation=
"relu")

           caches.append(cache)
        AL,
cache =linear_activation_forward(activation
= "sigmoid")

   caches.append(cache)#把所有中间参数（A,W,b和Z)存在caches里了

   return
AL,
caches

 

Step 3:计算损失函数

def compute_cost(AL,
Y):

   return
cost

 

Step 4:反向传播的实现：input da[l]  output da[l-1], dw[l],
db[l]

 

1.计算神经网络线性部分（linear part）的反向传播 （假设你已经知道dZ[l]，计算dW[l],db[l],dA[l-1]）
inputdZ[l]，A_prev,W  output dA_prev,dW,db
dZ与g(z)这个激活函数有关，所以要另外求呢

def linear_backward(dZ,
cache):    inputdZ[l]，A_prev,W 
output dA_prev,dW,db

    A_prev,W,
b = cache

    m = A_prev.shape[1]

   dW = 1./m * np.dot(dZ,A_prev.T)

    db = 1./m* np.sum(dZ,
axis =
1,
keepdims =True)

    dA_prev = np.dot(W.T,dZ)

   return
dA_prev,
dW,
db

2.求出relu和sigmoid函数的梯度函数（relu_backward/relu_backward）

假设dA已经，

dz[l] = da[l]*g[l]'(z[l])

dz[l] = w[l+1]Tdz[l+1]*g[l]'(z[l])(*是逐个元素相乘）

def relu_backward(dA,
cache):#这里的cache存储的是Z

    Z = cache

    dZ = np.array(dA,
copy=True)
#just converting dz to a correct object.   

    # When z <= 0, you should set dzto 0 as well.

    dZ[Z <= 0] =
0   

    assert (dZ.shape== Z.shape)   

       return
dZ

def sigmoid_backward(dA,
cache):

    Z = cache   

    s = 1/(1+np.exp(-Z))

    dZ = dA * s * (1-s)   

    assert (dZ.shape== Z.shape)

   return
dZ

3.联合前两步，实现一个新的【linear->Activation】反向函数

def linear_activation_backward(dA,
cache,
activation):

    linear_cache,
activation_cache= cache   

    if activation==
"relu":

        dZ = relu_backward(dA,
activation_cache)

        dA_prev, dW,
db = linear_backward(dZ,
linear_cache)       

    elif activation==
"sigmoid":

        dZ = sigmoid_backward(dA,
activation_cache)

        dA_prev, dW,
db = linear_backward(dZ,
linear_cache)   

    return dA_prev,
dW,
db

4.整合，实现最后一层的【linear->sigmoid】和前L-1层的【linear->relu】的反向函数

求Da

 

 

 

（A,W,b和Z)存在caches里了
def
L_model_backward(AL,
Y,
caches):

    grads = {}

    L = len(caches)# the number oflayers

    m = AL.shape[1]

    Y = Y.reshape(AL.shape) # after this line, Y is the same shapeas AL

    # Initializing thebackpropagation

    dAL = - (np.divide(Y,
AL)- np.divide(1
- Y,
1 - AL))

    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs:"AL, Y, caches". Outputs: "grads["dAL"],grads["dWL"], grads["dbL"]

    current_cache = caches[L-1]

    grads["dA" +
str(L)],
grads["dW"
+ str(L)],
grads["db"+
str(L)] = linear_activation_backward(dAL,
current_cache,
activation =
"sigmoid")

    for lin
reversed(range(L-1)):

        # lth layer: (RELU -> LINEAR) gradients.

        current_cache = caches[l]

        dA_prev_temp,
dW_temp,db_temp =linear_activation_backward(grads["dA"
+str(l +
2)],
current_cache,
activation =
"relu")

        grads["dA"
+ str(l+
1)] = dA_prev_temp

        grads["dW"
+ str(l+
1)] = dW_temp

        grads["db"
+ str(l+
1)] = db_temp

return grads

Step 5:更新参数

def update_parameters(parameters,
grads,
learning_rate):

   return
parameters

6.实现一个预测函数，来预测测试集的正确率

def predict(X,
y,
parameters):

 m = X.shape[1]

    n =
len(parameters) //
2 #number of layers in the neural network

    p = np.zeros((1,m))

   

    # Forward propagation

    probas,caches =L_model_forward(X,
parameters)

# convert probas to 0/1predictions

    for iin
range(0,
probas.shape[1]):

        if probas[0,i]>
0.5:

            p[0,i] =1

        else:

            p[0,i] =0

    print("p="+str(p))

    #print results

    #print ("predictions: " +str(p))

    #print ("true labels: " +str(y))

    print("Accuracy: " 
+ str(np.sum((p == y)/m)))

       

    return p

 

def L_layer_model(X, Y, layers_dims, learning_rate =
0.0075, num_iterations =
3000,print_cost=False):#lr
was 0.009

   np.random.seed(1)

   costs = []                        #keep track of cost   

   #Parameters initialization.

    parameters= initialize_parameters_deep(layers_dims)   

   #Loop (gradient descent)

   for i
in range(0,
num_iterations):

       #Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.

        AL,caches = L_model_forward(X,parameters)      

       #Compute cost.

        cost =compute_cost(AL,Y)

       #Backward propagation.

        grads= L_model_backward(AL,Y,caches)

       #Update parameters.

       parameters = update_parameters(parameters,grads,learning_rate)

       #Print the cost every 100 training example

       if print_cost
and i
% 100
== 0:

            print ("Cost after iteration %i:%f"
%(i, cost))

       if print_cost
and i
% 100
== 0:

           costs.append(cost)        

   #plot the cost

   plt.plot(np.squeeze(costs))

   plt.ylabel('cost')

   plt.xlabel('iterations(per tens)')

   plt.title("Learningrate ="
+ str(learning_rate))

    plt.show()

   return parameters

parameters = L_layer_model(train_x,train_y, layers_dims, num_iterations =
2500,print_cost =
True)