def forward_propaganda(X,parameters):
w1,b1,w2,b2=parameters
Z1=np.dot(w1,X)+b1
A1=np.tanh(Z1)
Z2=np.dot(w2,A1)+b2
A2=sigmoid(Z2)
return Z1,A1,Z2,A2
def forward_propagation(X, parameters):
"""
Argument:
X -- the input matrix of size (n_x,m), from which to extract features
parameters -- contains the initialised weights (W) and bias terms from
the function initialize_parameters()
-- stored in a python dictionary
Returns:
Y -- A2 the sigmoid output of the second activation
-- takes on 1 if y_predicted > 0.5 and 0 otherwise
cache -- a dictionary containing z1, z2, a1 and a2
"""
# Retrieve each parameter from the dictionary parameters
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# Implement forward propagation to compute a2
z1 = np.dot(W1, X) + b1
activation1 = np.tanh(z1)
#print("shape[a1]:", activation1.shape)
z2 = np.dot(W2, activation1) + b2
activation2 = sigmoid(z2)
#print("shape[a2]:", activation2.shape)
assert (activation2.shape == (1, X.shape[1]))
cache = {"z1": z1, "A1": activation1, "z2": z2, "A2": activation2}
return activation2, cache
def forward_propagation(X, parameters):
"""
Perform forward propagation
Parameters
----------
X : numpy array
input data size (n_x, m_size).
paramaters : dict
dictionary containing parameters.
Returns
-------
A2 : sigmoid output of the second activation function.
cache : dictionary containing Z1, A1, Z2, A2.
"""
# Get randomly initialzied parameters
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# Use equations to implement forward propagation
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
# cache the equations and return cache and A2
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2}
return A2, cache
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Implement Forward Propagation to calculate A2 (probabilities)
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert(A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
##assert(A2.shape == (1, X.shape[1]))##hard coded for our dataset
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
m -- size of training set.
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2", We need these values to calculate the partial derivation of the
loss function w.r.t to the parameters. Mainly, we will use them in the chain rule.
"""
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Implement Forward Propagation to calculate A2 (probabilities)
# Tangent hyberbolic function is used as the non-linear activation function for the hidden layer. And a sigmoid activation
# is used for the output layer.
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
# Retrieve each parameter from the dictionary "parameters"
### START CODE HERE ### (≈ 4 lines of code)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
### END CODE HERE ###
# Implement Forward Propagation to calculate A2 (probabilities)
### START CODE HERE ### (≈ 4 lines of code)
Z1 = W1 @ X + b1 ## (n_h, m) = (n_h, n_x) @ (n_x, m) + (n_h, 1)
A1 = np.tanh(Z1) ## (n_h, m) = (n_h, m)
Z2 = W2 @ A1 + b2 ## (n_y, m) = (n_y, n_h) @ (n_h, m) + (n_y, 1)
A2 = sigmoid(Z2) ## (n_y, m) = (n_y, m)
### END CODE HERE ###
assert(A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
def forward_propagation( X , parameters ):
"""
参数：
X - 维度为（n_x，m）的输入数据。
parameters - 初始化函数（initialize_parameters）的输出
返回：
A2 - 使用sigmoid()函数计算的第二次激活后的数值
cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型变量
"""
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
#前向传播计算A2
Z1 = np.dot(W1 , X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2 , A1) + b2
A2 = sigmoid(Z2)
#使用断言确保我的数据格式是正确的
assert(A2.shape == (1,X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return (A2, cache)
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Implement Forward Propagation to calculate A2 (probabilities)
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert(A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
def forward_propagation(X, parameters):
"""
Argument:
X -- input data of size (n_x, m)
parameters -- python dictionary containing your parameters (output of initialization function)
Returns:
A2 -- The sigmoid output of the second activation
cache -- a dictionary containing "Z1", "A1", "Z2" and "A2"
"""
# Retrieve each parameter from the dictionary "parameters"
### START CODE HERE ### (≈ 4 lines of code)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
### END CODE HERE ###
# print('> X ' + str(X.shape))
# print('> W1 ' + str(W1.shape))
# print('> b1 ' + str(b1.shape))
# print('> W2 ' + str(W2.shape))
# print('> b2 ' + str(b2.shape))
# Implement Forward Propagation to calculate A2 (probabilities)
### START CODE HERE ### (≈ 4 lines of code)
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
### END CODE HERE ###
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X,parameters):
'''
:param X:维度为(n_x,m)的输入数据.
:param parameters: 初始化函数(initialize_parameters)
:return:
A2 - 使用sigmoid()函数计算的第二次激活后的数值
cache-包含'Z1','A1','Z2','A2'的字典类型变量
'''
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
#前向计算A2
Z1 = np.dot(W1,X)+b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2,A1)+b2
A2 = sigmoid(Z2)
#使用断言确保数据格式正确
assert(A2.shape ==(1,X.shape[1]))
cache = {
'Z1':Z1,
'A1':A1,
'Z1':Z2,
'A2':A2
}
return (A2,cache)
def forward_propagation1(X, parameters):
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# Implement Forward Propagation to calculate A2 (probabilities)
Z1 = np.dot(W1, X) + b1
A1 = sigmoid(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def predict(self, x):
assert self.is_trained
print(x.shape)
assert x.shape == (2, x.shape[1])
Z1 = np.dot(self.W1, x) + self.b1
A1 = np.tanh(Z1)
Z2 = np.dot(self.W2, A1) + self.b2
A2 = sigmoid(Z2)
return A2
def evolution(self, X):
'''
:param X:输入测试数据
:return: 返回其类别
'''
Z1 = np.dot(self.W1, X) + self.B1
A1 = np.tanh(Z1)
Z2 = np.dot(self.W2, A1) + self.B2
A2 = sigmoid(Z2)
predictions = np.round(A2)
return predictions
def forward_propagation(X, parameters):
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X, parameters):
W1 = parameters['W1']
W2 = parameters['W2']
b1 = parameters['b1']
b2 = parameters['b2']
Z1 = np.dot(W1, X) + b1 # (n_h,m)
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2 #(n_y,m)
A2 = sigmoid(Z2)
cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2}
return cache, A2
def forward_propagation(X, parameters):
Z1 = np.dot(parameters['W1'], X) + parameters['b1']
A1 = np.tanh(Z1)
Z2 = np.dot(parameters['W2'], A1) + parameters['b2']
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X, b1, W1, b2, W2):
"""
Returns:
A2 -- The sigmoid output of the second activation
"Z1", "A1", "Z2" and "A2"
"""
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
# A1 = ReLu(Z1) # using ReLu as the activation function.
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
return Z1, A1, Z2, A2
def forward_propagation(self):
Z1 = np.dot(self.W1, self.X) + self.b1
self.A1 = np.tanh(Z1)
Z2 = np.dot(self.W2, self.A1) + self.b2
self.A2 = sigmoid(Z2)
self.validate()
cost = -1.0 / self.sample_amount * np.sum(
np.log(self.A2) * self.Y + (1 - self.Y) * np.log(1 - self.A2))
self.current_cost = np.squeeze(cost)
return self
def forward_propagation(X, parameters):
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X, params):
W1 = params['W1']
B1 = params['B1']
W2 = params['W2']
B2 = params['B2']
Z1 = np.dot(W1, X) + B1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + B2
A2 = sigmoid(Z2)
cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2}
return A2, cache
def forward_propagation(X, parameters):
np.random.seed(2)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
cache = {"Z1": Z1,"A1": A1,"Z2": Z2,"A2": A2}
return A2, cache
def forward_propagation(X, parameters):
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
Z1 = np.dot(W1.T, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2.T, A1) + b2
A2 = sigmoid(Z2)
cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2}
return A2, cache
def forward_propagation(X, parameters):
w1 = parameters['w1']
b1 = parameters['b1']
w2 = parameters['w2']
b2 = parameters['b2']
#前向传播
z1 = np.dot(w1, X) + b1
a1 = np.tanh(z1)
z2 = np.dot(w2, a1) + b2
a2 = sigmoid(z2)
assert (a2.shape == (1, X.shape[1]))
cache = {'Z1': z1, 'A1': a1, 'Z2': z2, 'A2': a2}
return (a2, cache)
def forward_propagation(X, parameters):
# Retriving the parameters
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# Forword propagation calcualtion
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_propagation(X, parameters):
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# 前向传播法计算
# 第一层到第二层
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
# 第二层到第五层
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
# 使用断言确保数据格式正确
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return (A2, cache)
def forward_propagation(X, parameters):
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# 前向传播
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
assert (A2.shape == (1, X.shape[1]))
cache = {'Z1': Z1,
'A1': A1,
'Z2': Z2,
'A2': A2}
return A2, cache
def forward_propagation(x, parameters):
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
z1 = np.dot(W1, x) + b1
A1 = np.tanh(z1)
z2 = np.dot(W2, A1) + b2
A2 = sigmoid(z2)
assert (A2.shape == (1, x.shape[1]))
cache = {"z1": z1, "A1": A1, "z2": z2, "A2": A2}
return A2, cache
def forward_propagation(X, parameters):
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
#print("W2",W2)
#print("A1",A1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
liA2.append(A2.tolist()[0])
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return (A2, cache)
def forward_propagation(X, parameters):
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
### END CODE HERE ###
assert (A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2, cache
def forward_prop(X,params):
# Retrieve parameters
W1 = params['W1']
b1 = params['b1']
W2 = params['W2']
b2 = params['b2']
# Implement forward propagation
Z1 = np.dot(W1,X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2,A1) + b2
A2 = sigmoid(Z2)
assert(A2.shape == (1,X.shape[1]))
cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}
return A2,cache
