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) else: 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): """ 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): """ implement the forward propagaton for the LINEAR-ACTIVATION layer # it contains: Z=WA+b; A=g(Z) :param A_prev: activations from previous layer (or input data): (size of previous layer, number of examples) :param W:weights matrix:numpy array of shape (size of current layer,size of previous layer) :param b:bias vector, numpy array of shape (size of the current layer,1) :param activation: the activation to be used in this layer, stored as a text string: sigmoid or relu :return: 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 BP """ 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): ''' Implement the forward propgation 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 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 effienciently ''' 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 Arguments: A_prev {np.array} -- activations from previous layer W {np.array} -- weight matrix b {np.array} -- bias vector activation {str} -- the activation name Returns: A {np.array} -- the output of the activation function cache {tuple} -- ("linear_cache", "activation_cache") """ if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) if 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 forward(self, i, A, activation): Z = np.dot(self.W[i], A) + self.B[i] if activation == 'relu': A, cache = relu(Z) else: A, cache = sigmoid(Z) 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) #返回本层的A值, 及((上一层的A值, 本层的W,b), 本层的A值) return A, cache
def linear_activation_forward(A_prev, W, b, activation): Z, linear_cache = linear_forward(A_prev, W, b) if activation == "sigmoid": A, activation_cache = sigmoid(Z) elif activation == "relu": A, activation_cache = relu(Z) cache = (linear_cache, activation_cache) return A, cache
def linear_activation_forward(A_prev, W, b, activation): Z, linear_cache = linear_forward(A_prev, W, b) if activation == "sigmoid": A, activation_cache = sigmoid(Z) # activation_cache = Z elif activation == "relu": A, activation_cache = relu(Z) cache = (linear_cache, activation_cache) #把Z也加到了cache当中,cache = [A, W, b, Z] 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 linear_activation_forward(A_prev, W, b, activation): if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) #得到Z、A_prev、W、b A, activation_cache = sigmoid(Z) #得到当前层的L和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) #cache中的值依次为A_prev, W, b, Z return A, cache
def linearActivationForward(A_prev, W, b, activation): if activation == "sigmoid": Z, linearCache = linearForward(A_prev, W, b) outputActivationFunc, activationCache = sigmoid(Z) elif activation == "relu": Z, linearCache = linearForward(A_prev, W, b) outputActivationFunc, activationCache = relu(Z) cache = (linearCache, activationCache) # outputActivationFunc = sigmoid/relu(Z) = A # cache = (linearCache = (A_prev,W,b) , activationCache = Z) return outputActivationFunc, 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): # assume using RELU fx in hidden layer and SIGMOID in output layer if activation == 'sigmoid': Z, linear_cache = linear_forward(A=A_prev, W=W, b=b) A, activation_cache = sigmoid(Z) elif activation == 'relu': Z, linear_cache = linear_forward(A=A_prev, W=W, b=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) #sigoid 和 relu的返回值是计算出来的 A 和 原始数据 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): if activation == "sigmoid": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) #activation_cache used for backpropagation elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) #activation_cache used for backpropagation assert(A.shape == (W.shape[0], A_prev.shape[1])) #Used in backpropagation 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": # Inputs: "A_prev, W, b". Outputs: "A, activation_cache". ### START CODE HERE ### (≈ 2 lines of code) 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): """ Implement the forward propagation for the LINEAR->ACTIVATION layer Arguments: A_prev : np.ndarray Activations from previous layer (or input data) (size of previous layer, number of examples) W : np.ndarray weights matrix (size of current layer, size of previous layer) b : np.ndarray bias vector (size of the current layer, 1)-- activations from previous layer (or input data): (size of previous layer, number of examples) activation : string The activation to be used in this layer, stored as a text string: "sigmoid" or "relu" Returns: A, cache : np.ndarray, tuple A : np.ndarray The output of the activation function, also called the post-activation value cache : linear_cache, activation_cache stored for computing the backward pass efficiently linear_cache : tuple a python tuple containing "A", "W" and "b" stored for computing the backward pass efficiently activation_cache: np.ndarray Z (size of current layer, number of examples) """ 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 L_model_forward(X, parameters): caches = [] A = X L = len(parameters) # number of layers in the neural network # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list. for l in range(1, L): A_prev = A A, cache = relu(np.dot(parameters["W"+str(l)],A_prev) + parameters["b"+str(l)]) caches.append(cache) # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list. AL, cache = sigmoid(np.dot(parameters["W"+str(L)],A) + parameters["b"+str(L)]) caches.append(cache) assert(AL.shape == (1,X.shape[1])) return AL, caches
def liner_activate_forward(A_prev,W,b,activation): ''' :param A_prev: 前一层的输出值 :param W: 本层的权重 :param b: 本层偏置项 :param activation: 激活函数类型 sifmod ReLu :return: ''' # Z=np.dot(W,A_prev)+b if activation=='sigmod': Z,liner_cache=liner_forward(A_prev,W,b) A,actication_cache=dnn_utils_v2.sigmoid(Z) elif activation=='relu': Z,liner_cache=liner_forward(A_prev,W,b) A,actication_cache=dnn_utils_v2.relu(Z) assert (A.shape==(W.shape[0],A_prev.shape[1])) cache=(liner_cache,actication_cache) #本层的输入 权重w+b; 本层的z return A,cache
def linear_activation_forward(A_prev, W, b, activation): """ Implement the forward propagation for the LINEAR->ACTIVATION layer Arguments: 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 """ Z, linear_cache = linear_forward(A_prev, W, b) if activation == "sigmoid": A, activation_cache = sigmoid(Z) elif activation == "relu": A, activation_cache = relu(Z) 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) else: Z, linear_cache = linear_forward(A, W, b) A, activation_cache = relu(Z) cache = (linear_cache, activation_cache) return A, cache
def L_model_forward(X, parameters): """ Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation Arguments: X -- data, numpy array of shape (input size, number of examples) parameters -- output of initialize_parameters_deep() Returns: AL -- last post-activation value caches -- list of caches containing: every cache of linear_relu_forward() (there are L-1 of them, indexed from 0 to L-2) the cache of linear_sigmoid_forward() (there is one, indexed L-1) """ caches = [] A = X L = len(parameters) // 2 # number of layers in the neural network # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list. for l in range(1, L): A_prev = A ### START CODE HERE ### (≈ 2 lines of code) A, cache = relu( np.dot(parameters["W" + str(l)], A) + parameters["b" + str(l)]) caches.append(cache) ### END CODE HERE ### # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list. ### START CODE HERE ### (≈ 2 lines of code) AL, cache = sigmoid( np.dot(parameters["W" + str(L)], A) + parameters["b" + str(L)]) caches.append(cache) ### END CODE HERE ### assert (AL.shape == (1, X.shape[1])) return AL, caches
def linear_activation_forward(A_prev, W, b, activation): """ 神经网络一层 (LINEAR->ACTIVATION) 的前向传播 :param A_prev: 前一层的激活值 :param W: 当前层的权重 :param b: 当前层的偏置 :param activation: 当前层的激活函数,string: "sigmoid" or "relu" :return A: 当前层激活函数的输出值 :return cache: 元组,包含 "linear_cache" and "activation_cache (Z)", 存储用来高效的计算后向传播 """ # 激活函数为 sigmoid() if activation == 'sigmoid': Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = sigmoid(Z) # activation_cache 存储的为 Z # 激活函数为 relu() elif activation == "relu": Z, linear_cache = linear_forward(A_prev, W, b) A, activation_cache = relu(Z) # activation_cache 存储的为 Z assert (A.shape == (W.shape[0], A_prev.shape[1])) cache = (linear_cache, activation_cache) return A, cache
def linear_relu(A_previous, W, b): #A_previous is the outoupt of previous layer, W,b is the parameter of current layer Z = np.dot(W, A_previous) + b A, _ = relu(Z) return A, Z