def linear_activation_forward(A_prev, W, b, activation): """ 实现Linear->Activation这一层的前向传播 参数: A_prev - 来自上一层(或输入层)的激活,维度为(上一层的节点数量,示例数) W - 权重矩阵,numpy数组,维度为(当前层的节点数量,前一层的大小) b - 偏向量,numpy阵列,维度为(当前层节点的数量,1) activation - 选择在此层中使用的激活函数名,字符串类型,【“sigmoid”|“relu”】 返回: A - 激活函数的输出,也称激活后的值 cache - 一个包含“linear_cache”和“activation_cache”的字典,我们需要存储它,以用于有效的后向传播运算 linear_cache为前向传播获得的A,W,b """ if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): z = linear_forward(A_prev, W, b) if (activation == 'sigmoid'): a, z = sigmoid(z) else: a, z = relu(z) return a
def linear_activation_forward(A_prev, W, b, activation): """ Implement the forward propagation for the LINEAR->ACTIVATION layer Arguments: A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples) W -- weights matrix: numpy array of shape (size of current layer, size of previous layer) b -- bias vector, numpy array of shape (size of the current layer, 1) activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu" Returns: A -- the output of the activation function, also called the post-activation value cache -- a python dictionary containing "linear_cache" and "activation_cache"; stored for computing the backward pass efficiently """ if activation == "sigmoid": # Inputs: "A_prev, W, b". Outputs: "A, activation_cache". Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": # Inputs: "A_prev, W, b". Outputs: "A, activation_cache". Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev,W,b,activation): """ 实现LINEAR-> ACTIVATION 这一层的前向传播 参数: A_prev - 来自上一层(或输入层)的激活,维度为(上一层的节点数量,示例数) W - 权重矩阵,numpy数组,维度为(当前层的节点数量,前一层的大小) b - 偏向量,numpy阵列,维度为(当前层的节点数量,1) activation - 选择在此层中使用的激活函数名,字符串类型,【"sigmoid" | "relu"】 返回: A - 激活函数的输出,也称为激活后的值 cache - 一个包含“linear_cache”和“activation_cache”的字典,我们需要存储它以有效地计算后向传递 """ if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert(A.shape == (W.shape[0],A_prev.shape[1])) cache = (linear_cache,activation_cache) return A,cache
def linear_activation_forward(A_prev, W, b, activation): """activation part of forward prop Arguments: A_prev {np array} -- [(l-1 x m)] W {[np.array]} -- [(l x l-1)] b {[np.array]} -- [(1 x b)] activation {string} -- [relu or sigmoid] Returns: [np.array] -- [A , (A_prev, W , b, Z)] """ if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def L_model_forward(X, parameters): L = len(parameters) // 2 A = X for l in range(1, L): A = linear_activation_forward(A, parameters["W" + str(l)], parameters["b" + str(l)], lambda Z: relu(Z)) Z = tf.add(tf.matmul(parameters["W" + str(L)], A), parameters["b" + str(L)]) return Z
def forward_propagation(X,parameters): #print(type(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 linear_activation_forward(A_prev, W, b, activation): Z, linear_cache = linear_forward(A_prev, W, b) if activation == 'relu': A, activation_cache = relu(Z) elif activation == 'sigmoid': A, activation_cache = sigmoid(Z) else: A, activation_cache = Z,Z assert A.shape == Z.shape == (W.shape[0], A_prev.shape[1]) cache = linear_cache, activation_cache return A, cache
def linear_activation_forward(A_prev, W, b, activation): if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): ''' Implement the forward propagation for the LINEAR->ACTIVATION layer ''' if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): """ A_prev means previous A, b. activation is activation method """ if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) elif activation == "softmax": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = softmax(Z) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): ''' #2..正向传播计算激活函数,并保存计算中用到中间变量, 包括:线性部分Z的中间变量缓存(A_prev,W,b),和激活函数计算的中间变量缓存Z ''' #线性部分计算 Z, linear_cache = linear_forward(A_prev, W, b) #激活函数计算 if activation == "relu": A, active_cache = utils.relu(Z) elif activation == "sigmoid": A, active_cache = utils.sigmoid(Z) cache = (linear_cache, active_cache) return A, cache
def linear_activation_forward(self, A_prev, W, b, activation): # 每一层的线性+激活 """ A_prev 是来自上一层的激活值,这一层的输入 W,b是本层的权重,偏差 """ if activation == "sigmoid": Z, linear_cache = self.linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = self.linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) # linear_cache装有(上层的A也即本层的输入,本层的W,本层的b),activation_cache就是本层的Z cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_pre,W,b,activation): """ Implement neural unit with the activation of Relu or sigmoid """ if activation == "Relu": Z = linear_forward(W,A_pre,b) A,activation_cache = relu(Z) elif activation == "sigmoid": Z = linear_forward(W,A_pre,b) A,activation_cache = sigmoid(Z) backward_used_cache = (A_pre,W,b) cache = (backward_used_cache,activation_cache) return A,cache
def linear_activation_forward(A_prev, W, b, activationFn): """ Returns: A -- the output of the activation function, also called the post-activation value cache -- a python dictionary containing "A_prev", "W", "b" and corresponding "Z"; stored for computing the backward pass efficiently """ Z = np.dot(W, A_prev) + b assert (Z.shape == (W.shape[0], A_prev.shape[1])) cache = (A_prev, W, b, Z) if activationFn == "relu": A, activation_cache = utils.relu(Z) else: A, activation_cache = utils.sigmoid(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) return A, cache
def __linear_activation_forward(self, A_prev, W, b, activation): """ A_prev -- activations from previous layer or input data(size of previous layer, number of examples) W -- weight matrix (size of current layer, previous layer) b -- bias vector (size of current layer, 1) returns: A -- the output of activation function cache -- a directory contain linear cache and activation cache, used in back propagation """ Z, linear_cache = self.__linear_forward(A_prev, W, b) if activation == "sigmoid": A, activation_cache = sigmoid(Z) elif activation == "relu": A, activation_cache = relu(Z) elif activation == "tanh": A, activation_cache = tanh_activate(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev,W,b,activation): ''' 实现linear->activation这一层的前向传播 :param A_prev: 来自上一层(或输入层)的激活,维度为(上一层的节点数量,示例数) :param W:权重矩阵,numpy数组,维度为(当前的节点数量,前一层的大小 :param b: 偏向量,numpy阵列,维度为(当前层的节点数量,1) :param activation: 选择在此层中使用的就激活函数名,字符串类型,['sigmoid'|'relu'] :return: A-激活函数的输出,也称为激活后的值 cache-一个包含'linear_cache'和'activation_cache'的的字典,我们需要存储它以有效地计算后向传递 ''' if activation == 'sigmoid': Z,linear_cache= linear_forward(A_prev,W,b) A,activation_cache = sigmoid(Z) elif activation == 'relu': Z,linear_cache = linear_forward(A_prev,W,b) A,activation_cache = relu(Z) assert (A.shape == (W.shape[0],A_prev.shape[1])) cache = (linear_cache,activation_cache) return A,cache
def linear_activation_forward(A, W, b, activation): """ :param A: activation from previous layers :param W: weight values :param b: bias values :param activation: activation function :return: A: output of activation function cache: tuple containing linear and activation cache """ if activation == "sigmoid": Z, linear_cache = linear_forward(A, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A, W, b) A, activation_cache = relu(Z) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): """ 实现【LINEAR -> ACTIVATION】线性激活部分。 :param A_prev: 上一层(或输入层)激活后的值,维度(l-1层单元数, 样本数) :param W: 权重矩阵,numpy数组,维度为(l层单元数, l-1层单元数) :param b: 偏置向量,numpy向量,维度为(l层单元数, 1) :param activation: 本层使用的激活函数,字符串类型,{"sigmoid" | "relu"} :returns: A: 激活函数的输出,也称激活后的值 cache: 包含“linear_cache”和“activation_cache”的字典,我们需要存储它以有效地计算后向传递 """ # 激活函数为sigmoid if activation == "sigmoid": # 本层的Z, linear_cache(上层的A, 本层的W, 本层的b) Z, linear_cache = linear_forward(A_prev, W, b) # 本层的A(Sigmoid), activation_cache(本层的Z) A, activation_cache = sigmoid(Z) # 激活函数为relu elif activation == "relu": # 本层的Z, linear_cache(上层的A, 本层的W, 本层的b) Z, linear_cache = linear_forward(A_prev, W, b) # 本层的A(ReLU), activation_cache(本层的Z) A, activation_cache = relu(Z) # 确保数据正确性 assert (A.shape == (W.shape[0], A_prev.shape[1])) # 缓存cache(上层的A, 本层的W, 本层的b, 本层的Z)由两部分组成: # linear_cache(上层的A, 本层的W, 本层的b) # activation_cache(本层的Z) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): """ 实现LINEAR->ACTIVATION这一层的前向传播 参数: A_prev-来自上一层的(或者输入层)的激活,维度(上一层节点数量,示例数) W - 权重矩阵,numpy数组,维度(当前层的节点数量,前一层的大小) b - 偏向量,维度(当前层的节点数量,1) activation -选择在该层使用的激活函数,字符串类型[sigmoid|relu] 返回: A -激活函数的输出,也称为激活后的值 cache - 一个包含linear_cache和activation_cache的字典,存储塔用来有效的计算后向传递 """ if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): """ 在上一个方法中实现了Z=W*X+b,在此方法中加上激活函数sigmoid or Relu :param A_prev: 上一层的激活,维度为(上一层的节点数量,示例数) :param W: :param b: :param activation:选择在此层中使用的激活函数名,字符串类型,【"sigmoid" | "relu"】 :return: A - 激活函数的输出,也称为激活后的值 cache - 一个包含“linear_cache”和“activation_cache”的字典,我们需要存储它以有效地计算后向传递 linear_cache- 存着A,W,b, 也就是上一层的激活值A_prev以及W、b activation_cache 存着Z Z=W*A_prev+b activation_cache是linear_cache线性运算之后的值 """ if activation == "sigmoid": Z, linear_cache = line_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation == "relu": Z, linear_cache = line_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): ''' 实现linear->activation这一层的前向传播 :param A_prev:来自上一层(或输入层)的激活,维度为(上一层节点数,样本数) :param W:权重矩阵,numpy数组,维度为(当前层节点数量,上一层节点数量) :param b:偏向量,numpy阵列,维度为(当前层节点数量,1) :param activation:选择在此层中的激活函数,字符串类型,【sigmoid,relu】 :return: A:激活函数的输出,也称为激活后的值 cache:一个包含'linear_cache'和'activation_cache'的字典,我们需要存储它以有效地计算后向传播 ''' if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) # linear_cache = (A, W, b) A, activation_cache = sigmoid(Z) # activation_cache = Z elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) # linear_cache = (A, W, b) A, activation_cache = relu(Z) # activation_cache = Z assert (A.shape == (W.shape[0], A.shape[1])) cache = (linear_cache, activation_cache) # (A,W,b,Z),其实是个一列表 return A, cache
def linear_activation_forward(A_prev, W, b, activation): """ 实现LINEAR->AVTIVATION这一层前向传播 参数: A_prev: 来自上一层(或输入层)的激活,维度为(上一层的节点数量,示例数) W:权重矩阵,numpy数组,维度为(当前层的节点数量,前一层大小) b:偏向量,numpy阵列,维度为(当前层的节点数量,1) activation:此层集合函数类型,字符串类型【"sigmoid"|"relu"】 返回: A:激活函数的输出,也称为激活后的值 cache:一个包含“linear_cache”和“activation_cache”的字典,我们需要存储它以有效地计算后向传递 """ if (activation == "sigmoid"): Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) elif (activation == "relu"): Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"])) #Sigmoid and Relu Activation def linear_activation_forward(A_prev, W, b, activation): if activation = "sigmoid" Z = np.dot(W, A_prev) + b linear_cache = (A_prev, W, b) A, activation_cache = sigmoid(Z) elif activation = "relu" Z = np.dot(W, A_prev) + b linear_cache = (A_prev, W, b) A, activation_cache = relu(Z) assert(A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache A_prev, W, b = linear_activation_forward_test_case() A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "sigmoid") print("With sigmoid: A = " + str(A)) A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "relu") print("With ReLU: A = " + str(A)) #Forward Propagation
# ``` python # A, activation_cache = sigmoid(Z) # ``` # # - **ReLU**: The mathematical formula for ReLu is $A = RELU(Z) = max(0, Z)$. We have provided you with the `relu` function. This function returns **two** items: the activation value "`A`" and a "`cache`" that contains "`Z`" (it's what we will feed in to the corresponding backward function). To use it you could just call: # ``` python # A, activation_cache = relu(Z) # ``` # For more convenience, you are going to group two functions (Linear and Activation) into one function (LINEAR->ACTIVATION). Hence, you will implement a function that does the LINEAR forward step followed by an ACTIVATION forward step. # # **Exercise**: Implement the forward propagation of the *LINEAR->ACTIVATION* layer. Mathematical relation is: $A^{[l]} = g(Z^{[l]}) = g(W^{[l]}A^{[l-1]} +b^{[l]})$ where the activation "g" can be sigmoid() or relu(). Use linear_forward() and the correct activation function. # In[8]: relu(Z) # In[9]: # GRADED FUNCTION: linear_activation_forward def linear_activation_forward(A_prev, W, b, activation): """ Implement the forward propagation for the LINEAR->ACTIVATION layer Arguments: A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples) W -- weights matrix: numpy array of shape (size of current layer, size of previous layer) b -- bias vector, numpy array of shape (size of the current layer, 1) activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"