def main():
# 读取并绘制数据: blue/red dots in circles
train_X, train_Y, test_X, test_Y = load_dataset()
# 选择一个初始化方法
parameters = initialize_parameters_he([2, 4, 1])
# 打印随机初始化后各参数的值
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
# 通过神经网络模型进行训练，得到参数
parameters = model(train_X, train_Y, initialization = "he")
# 用训练得到的参数进行预测，并分别输出训练集和测试集的预测准确率
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
# 打印预测结果
print (predictions_train)
print (predictions_test)
# 绘制红蓝点分离情况图
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, np.squeeze(train_Y)) # 注意最后一个参数不能直接用train_Y，要加上np.squeeze()
def main(initialization='he'):
train_X, train_Y, test_X, test_Y = load_dataset()
# try different initialization methods
if initialization == 'zero':
parameters = model(train_X, train_Y, initialization='zero')
elif initialization == 'random':
parameters = model(train_X, train_Y, initialization='random')
else:
parameters = model(train_X, train_Y, initialization='he')
# make predictions
print("-----The result of using " + initialization + "-----")
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
# plot the result
plt.title("Model with " + initialization + " initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
def test_models_random():
parameters = model(train_X, train_Y, initialization = "random")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
print (predictions_train)
print (predictions_test)
plt.title("Model with large random initialization")
def test_models_zeros():
parameters = model(train_X, train_Y, initialization = "zeros")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
print ("predictions_train = " + str(predictions_train))
print ("predictions_test = " + str(predictions_test))
def test_models_he():
parameters = model(train_X, train_Y, initialization = "he")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
def ex_2():
parameters = initialize_parameters_random([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
parameters = model(train_X, train_Y, initialization='random')
print('On the train set:')
predictions_train = predict(train_X, train_Y, parameters)
print('On the test set:')
predictions_test = predict(test_X, test_Y, parameters)
def main():
plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# load image dataset: blue/red dots in circles
train_X, train_Y, test_X, test_Y = load_dataset()
parameters = model(train_X, train_Y, initialization = "he")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
plt.figure()
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
plt.show()
def test_random():
parameters = initialize_parameters_random([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
parameters = model(train_X, train_Y, initialization="random")
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
print(predictions_train)
print(predictions_test)
plt.title("Model with large random initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
def main():
train_X, train_Y, test_X, test_Y = load_dataset()
# not so good initialization
parameters = model(train_X, train_Y, initialization="random")
print("On the train set:")
predict(train_X, train_Y, parameters)
print("On the test set:")
predict(test_X, test_Y, parameters)
# good initialization
parameters = model(train_X, train_Y, initialization="he")
print("On the train set:")
predict(train_X, train_Y, parameters)
print("On the test set:")
predict(test_X, test_Y, parameters)
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
def main1():
#%matplotlib inline
plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# load image dataset: blue/red dots in circles
train_X, train_Y, test_X, test_Y = load_dataset()
parameters = initialize_parameters_zeros([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
parameters = model(train_X, train_Y, initialization="zeros")
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
print("predictions_train = " + str(predictions_train))
print("predictions_test = " + str(predictions_test))
plt.title("Model with Zeros initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
parameters = initialize_parameters_random([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
parameters = model(train_X, train_Y, initialization="random")
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
print(predictions_train)
print(predictions_test)
plt.title("Model with large random initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
parameters = initialize_parameters_he([2, 4, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
parameters = model(train_X, train_Y, initialization="he")
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
A3, cache = forward_propagation(X, parameters)
grads = backward_propagation(X, Y, cache)
parameters = update_parameters(parameters, grads, learning_rate)
cost = compute_loss(A3, Y)
if i % 1000 == 0:
print(f'cost after iteration {i}:{cost}')
return parameters
layer_dimension = [train_X.shape[0], 10, 5, 1]
# 3. measure different initialize methods(cost,train/test accuracy,decision boundry) with train/test dataset
#3.1 zero_initialization
print('zero_initialization')
parameters = ini_model(train_X, train_Y, layer_dimension, 'zero', 0.01)
print('train accuracy:')
predict(train_X, train_Y, parameters)
print('test accuracy:')
predict(test_X, test_Y, parameters)
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
# 3.2 random initialization
print('random initialization')
parameters = ini_model(train_X, train_Y, layer_dimension, 'random', 0.01)
print('train accuracy:')
predict(train_X, train_Y, parameters)
print('test accuracy:')
predict(test_X, test_Y, parameters)
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X,
train_Y)
# 3.3 he initialization
print('he initialization')
# **b2**
# </td>
# <td>
# [[ 0.]]
# </td>
# </tr>
#
# </table>
# Run the following code to train your model on 15,000 iterations using zeros initialization.
# In[5]:
parameters = model(train_X, train_Y, initialization = "zeros")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
# The performance is really bad, and the cost does not really decrease, and the algorithm performs no better than random guessing. Why? Lets look at the details of the predictions and the decision boundary:
# In[6]:
print ("predictions_train = " + str(predictions_train))
print ("predictions_test = " + str(predictions_test))
# In[7]:
plt.title("Model with Zeros initialization")
def ex_3():
parameters = model(train_X, train_Y, initialization='he')
print('On the train set:')
predictions_train = predict(train_X, train_Y, parameters)
print('On the test set:')
predictions_test = predict(test_X, test_Y, parameters)
params = init_utils.update_parameters(params, grads, alpha)
if (i + 1) % 100 == 0:
print(f'No.{i+1} iteration\'s loss: {cost}')
plt.plot(costs)
plt.xlabel('step')
plt.ylabel('loss')
plt.title('loss circle')
plt.show()
return params
# %%
# use 'zero' to initial parameters
params = model(X_train, Y_train, init_method='zeros')
print('train set')
prediction = init_utils.predict(X_train, Y_train, params)
print('test set')
prediction = init_utils.predict(X_test, Y_test, params)
# %%
# use 'random' to initial parameters
np.random.seed(1)
params = model(X_train,
Y_train,
alpha=0.001,
loops=15000,
init_method='random')
print('train set')
prediction = init_utils.predict(X_train, Y_train, params)
print('test set')
prediction = init_utils.predict(X_test, Y_test, params)
parameters = {}
L = len(layers_dims)
for l in range(1,L):
parameters['W'+str(l)] = np.random.randn(layers_dims[l],layers_dims[l-1])*np.sqrt(2/layers_dims[l-1])
parameters['b'+str(l)] = np.zeros((layers_dims[l],1))
#使用断言保证数据格式正确
assert(parameters['W'+str(l)].shape == (layers_dims[l],layers_dims[l-1]))
assert(parameters['b'+str(l)].shape == (layers_dims[l],1))
return parameters
parameters = model(train_X, train_Y, initialization = "he",is_polt=True)
print("训练集:")
predictions_train = init_utils.predict(train_X, train_Y, parameters)
print("测试集:")
init_utils.predictions_test = init_utils.predict(test_X, test_Y, parameters)
plt.title("Model with He initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
init_utils.plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)
# 不同的初始化方法可能导致性能最终不同
#
# 随机初始化有助于打破对称，使得不同隐藏层的单元可以学习到不同的参数。
#
# 初始化时，初始值不宜过大。
#
elif initialization == "he":
plt.savefig('/home/guanlingh/local2server/homework5/he.jpg')
return parameters
print(
"-------------------------------------When initialization is zeros------------------------------------\n"
)
parameters1 = model(train_X, train_Y, initialization="zeros")
print("Train1 : ")
train_prediction1 = predict(train_X, train_Y, parameters1)
print("Test1 : ")
test_predition1 = predict(test_X, test_Y, parameters1)
print("Train predictions1: " + str(train_prediction1))
print("Test predictions1: " + str(test_predition1))
print(
"-------------------------------------When initialization is random------------------------------------\n"
)
parameters2 = model(train_X, train_Y, initialization="random")
print("Train2 : ")
train_prediction2 = predict(train_X, train_Y, parameters2)
print("Test2 : ")
cost = compute_cost(a3, Y)
# Backward propagation.
grads = L_model_backward(X, Y, cache)
# Update parameters.
parameters = update_parameters(parameters, grads, learning_rate)
# Print the loss every 1000 iterations
if print_cost and i % 1000 == 0:
print("Cost after iteration {}: {}".format(i, cost))
costs.append(cost)
# plot the loss
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
return parameters
parameters = model(X_train, y_train)
from init_utils import predict
print("On the train set:")
predictions_train = predict(X_train, y_train, parameters)
print("On the test set:")
predictions_test = predict(X_train, y_train, parameters)
# **b2**
# </td>
# <td>
# [[ 0.]]
# </td>
# </tr>
#
# </table>
# Run the following code to train your model on 15,000 iterations using zeros initialization.
# In[32]:
parameters = model(train_X, train_Y, initialization="zeros")
print("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
# The performance is really bad, and the cost does not really decrease, and the algorithm performs no better than random guessing. Why? Lets look at the details of the predictions and the decision boundary:
# In[33]:
print("predictions_train = " + str(predictions_train))
print("predictions_test = " + str(predictions_test))
# In[34]:
plt.title("Model with Zeros initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
bL -- bias vector of shape (layers_dims[L], 1)
"""
parameters = {}
L = len(layers_dims) # number of layers in the network
for l in range(1, L):
parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l-1]))
parameters['b' + str(l)] = np.zeros((layers_dims[l],1))
return parameters
parameters = initialize_parameters_zeros([3,2,1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = "parameters = model(train_X, train_Y, initialization = "zeros")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters) + str(parameters["b2"]))
print ("predictions_train = " + str(predictions_train))
print ("predictions_test = " + str(predictions_test))
plt.title("Model with Zeros initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)
def initialize_parameters_random(layers_dims):
"""
Arguments:
layer_dims -- python array (list) containing the size of each layer.
print("b1 = " + str(params["b1"]))
print("W2 = " + str(params["W2"]))
print("b2 = " + str(params["b2"]))
# 使用全零初始化方式训练模型
# In[6]:
params = model(train_X, train_Y, init="zeros", is_plot=True)
# 计算训练集和测试集准确率
# In[7]:
print("Train set:")
predictions_train = init_utils.predict(train_X, train_Y, params)
print("Test Set:")
predictions_test = init_utils.predict(test_X, test_Y, params)
# 观察预测值：
# In[8]:
print("predictions_train: " + str(predictions_train))
print("prediction_test: " + str(predictions_test))
# Plot Decision Boundary
plt.title("Zero init")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
paramters = update_parameters(parameters, grads, learning_rate)
if print_cost and i % 1000 == 0:
print("Cost after iteration {}: {}".format(i, cost))
costs.append(cost)
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
return parameters
if __name__ == "__main__":
print("train:")
p = model(train_X, train_Y, initialization="zeros")
print("preditc on trein")
pred = predict(train_X, train_Y, p)
print("predictions_train = " + str(pred))
print("preditc on test")
pred = predict(test_X, test_Y, p)
print("predictions_test = " + str(pred))
plt.title("Model with large random initialization")
axes = plt.gca()
axes.set_xlim([-1.5, 1.5])
axes.set_ylim([-1.5, 1.5])
plot_decision_boundary(lambda x: predict_dec(p, x.T), train_X,
np.squeeze(train_Y))
