Reformate code and imports

Author: Star We

lesson4/train_with_numpy.py

@@ -24,7 +24,8 @@
 
 import planar_utils
 
-#定义函数：设置网络结构
+
+# 定义函数：设置网络结构
 def layer_sizes(X, Y):
  """
  参数含义:
@@ -36,11 +37,12 @@ def layer_sizes(X, Y):
  n_h -- 隐藏层节点数
  n_y -- 输出层节点数
  """
- n_x = X.shape[0] #输入层大小（节点数）
+ n_x = X.shape[0]  # 输入层大小（节点数）
  n_h = 4
- n_y = Y.shape[0] #输出层大小（节点数）
+ n_y = Y.shape[0]  # 输出层大小（节点数）
  return (n_x, n_h, n_y)
 
+
 # 定义函数：初始化参数
 def initialize_parameters(n_x, n_h, n_y):
  """
@@ -57,9 +59,9 @@ def initialize_parameters(n_x, n_h, n_y):
  b2 -- （输出层）偏移量，维度是 (n_y, 1)
  """
 
- np.random.seed(2) # 设置随机种子
+ np.random.seed(2)  # 设置随机种子
 
- #随机初始化参数
+  # 随机初始化参数
  W1 = np.random.randn(n_h, n_x) * 0.01
  b1 = np.zeros((n_h, 1))
  W2 = np.random.randn(n_y, n_h) * 0.01
@@ -76,6 +78,7 @@ def initialize_parameters(n_x, n_h, n_y):
  "b2": b2}
  return parameters
 
+
 # 定义函数：前向传播
 def forward_propagation(X, parameters):
  """
@@ -97,7 +100,7 @@ def forward_propagation(X, parameters):
  Z2 = np.dot(W2, A1) + b2
  A2 = 1 / (1 + np.exp(-Z2))
 
- assert(A2.shape == (1, X.shape[1]))
+ assert (A2.shape == (1, X.shape[1]))
 
  cache = {"Z1": Z1,
  "A1": A1,
@@ -106,6 +109,7 @@ def forward_propagation(X, parameters):
 
  return A2, cache
 
+
 # 定义函数：成本函数
 def compute_cost(A2, Y, parameters):
  """
@@ -120,17 +124,18 @@ def compute_cost(A2, Y, parameters):
  cost -- 成本函数
  """
 
- m = Y.shape[1] #样本个数
+ m = Y.shape[1]  # 样本个数
 
- #计算成本
+ # 计算成本
  logprobs = np.multiply(np.log(A2), Y) + np.multiply(np.log(1 - A2), 1 - Y)
- cost =  -1. / m * np.sum(logprobs)
+ cost = -1. / m * np.sum(logprobs)
 
- cost = np.squeeze(cost)  # 确保维度的正确性
- assert(isinstance(cost, float))
+ cost = np.squeeze(cost) # 确保维度的正确性
+ assert (isinstance(cost, float))
 
  return cost
 
+
 # 定义函数：后向传播
 def backward_propagation(parameters, cache, X, Y):
  """
@@ -145,7 +150,7 @@ def backward_propagation(parameters, cache, X, Y):
  """
  m = X.shape[1]
 
- #首先从"parameters"获取W1,W2
+ # 首先从"parameters"获取W1,W2
  W1 = parameters["W1"]
  W2 = parameters["W2"]
 
@@ -156,10 +161,10 @@ def backward_propagation(parameters, cache, X, Y):
  # 后向传播: 计算dW1, db1, dW2, db2.
  dZ2 = A2 - Y
  dW2 = 1. / m * np.dot(dZ2, A1.T)
- db2 = 1. / m * np.sum(dZ2, axis = 1, keepdims = True)
+ db2 = 1. / m * np.sum(dZ2, axis=1, keepdims=True)
  dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2))
  dW1 = 1. / m * np.dot(dZ1, X.T)
- db1 = 1. / m * np.sum(dZ1, axis = 1, keepdims = True)
+ db1 = 1. / m * np.sum(dZ1, axis=1, keepdims=True)
 
  grads = {"dW1": dW1,
  "db1": db1,
@@ -168,7 +173,8 @@ def backward_propagation(parameters, cache, X, Y):
 
  return grads
 
-#定义函数：参数更新
+
+# 定义函数：参数更新
 def update_parameters(parameters, grads, learning_rate=1.2):
  """
  使用梯度更新参数
@@ -180,7 +186,7 @@ def update_parameters(parameters, grads, learning_rate=1.2):
  返回值:
  parameters -- 包含更新后参数的python
  """
- #从"parameters"中读取全部参数
+ # 从"parameters"中读取全部参数
  W1 = parameters["W1"]
  b1 = parameters["b1"]
  W2 = parameters["W2"]
@@ -192,7 +198,7 @@ def update_parameters(parameters, grads, learning_rate=1.2):
  dW2 = grads["dW2"]
  db2 = grads["db2"]
 
- #更新参数
+ # 更新参数
  W1 = W1 - learning_rate * dW1
  b1 = b1 - learning_rate * db1
  W2 = W2 - learning_rate * dW2
@@ -206,7 +212,7 @@ def update_parameters(parameters, grads, learning_rate=1.2):
  return parameters
 
 
-#定义函数：神经网络模型
+# 定义函数：神经网络模型
 def nn_model(X, Y, n_h, num_iterations=10000, print_cost=False):
  """
  参数:
@@ -224,35 +230,35 @@ def nn_model(X, Y, n_h, num_iterations=10000, print_cost=False):
  n_x = layer_sizes(X, Y)[0]
  n_y = layer_sizes(X, Y)[2]
 
- #根据n_x, n_h, n_y初始化参数，并取出W1,b1,W2,b2
+ # 根据n_x, n_h, n_y初始化参数，并取出W1,b1,W2,b2
  parameters = initialize_parameters(n_x, n_h, n_y)
  W1 = parameters["W1"]
  b1 = parameters["b1"]
  W2 = parameters["W2"]
  b2 = parameters["b2"]
 
-
  for i in range(0, num_iterations):
 
- #前向传播， 输入: "X, parameters". 输出: "A2, cache".
+ # 前向传播， 输入: "X, parameters". 输出: "A2, cache".
  A2, cache = forward_propagation(X, parameters)
 
- #成本计算. 输入: "A2, Y, parameters". 输出: "cost".
+ # 成本计算. 输入: "A2, Y, parameters". 输出: "cost".
  cost = compute_cost(A2, Y, parameters)
 
- #后向传播， 输入: "parameters, cache, X, Y". 输出: "grads".
+ # 后向传播， 输入: "parameters, cache, X, Y". 输出: "grads".
  grads = backward_propagation(parameters, cache, X, Y)
 
- #参数更新. 输入: "parameters, grads". 输出: "parameters".
+ # 参数更新. 输入: "parameters, grads". 输出: "parameters".
  parameters = update_parameters(parameters, grads)
 
- #每1000次训练打印一次成本函数值
+ # 每1000次训练打印一次成本函数值
  if print_cost and i % 1000 == 0:
  print ("Cost after iteration %i: %f" % (i, cost))
 
  return parameters
 
-#定义函数：预测
+
+# 定义函数：预测
 def predict(parameters, X):
  """
  使用训练所得参数，对每个训练样本进行预测
@@ -265,13 +271,14 @@ def predict(parameters, X):
  predictions -- 模型预测值向量(红色: 0 / 蓝色: 1)
  """
 
- #使用训练所得参数进行前向传播计算，并将模型输出值转化为预测值（大于0.5视作1，即True）
+ # 使用训练所得参数进行前向传播计算，并将模型输出值转化为预测值（大于0.5视作1，即True）
  A2, cache = forward_propagation(X, parameters)
  predictions = A2 > 0.5
 
  return predictions
 
-#定义函数：main函数
+
+# 定义函数：main函数
 def main():
  """
  参数:
@@ -284,14 +291,15 @@ def main():
  # 预测训练集
  predictions = predict(parameters, train_x)
  # 输出准确率
- print('Train Accuracy: %d' % float((np.dot(train_y, predictions.T)+
+ print('Train Accuracy: %d' % float((np.dot(train_y, predictions.T) +
  np.dot(1 - train_y, 1 - predictions.T)) /
  float(train_y.size) * 100) + '%')
- #预测测试集
+ # 预测测试集
  predictions = predict(parameters, test_x)
  print('Test Accuracy: %d' % float((np.dot(test_y, predictions.T) +
  np.dot(1 - test_y, 1 - predictions.T)) /
  float(test_y.size) * 100) + '%')
 
+
 if __name__ == '__main__':
  main()

lesson4/train_with_paddle.py

@@ -19,10 +19,10 @@
 7.预测并测试准确率train_accuracy和test_accuracy
 """
 
-
 import matplotlib
 import numpy as np
 import paddle.v2 as paddle
+
 matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 
@@ -204,6 +204,7 @@ def test_accuracy(probs_test, test_data):
 
  return test_accuracy
 
+
 # 搭建神经网络结构
 def netconfig():
  """
@@ -234,6 +235,7 @@ def netconfig():
 
  return image, y_predict, y_label
 
+
 # 展示模型训练曲线
 def plot_costs(costs):
  """
@@ -265,7 +267,7 @@ def main():
  # 载入数据
  load_data()
 
- #配置网络结构
+ # 配置网络结构
  image, y_predict, y_label = netconfig()
 
  # 定义成本函数为交叉熵损失函数multi_binary_label_cross_entropy_cost
@@ -338,9 +340,9 @@ def event_handler(event):
  print("train_accuracy: {} %".format(train_accuracy(probs_train, train_data)))
  print("test_accuracy: {} %".format(test_accuracy(probs_test, test_data)))
 
- #绘制成本函数折线图
+ # 绘制成本函数折线图
  plot_costs(costs)
 
 
 if __name__ == '__main__':
- main()
+ main()

lesson5/train_with_numpy.py

@@ -56,6 +56,6 @@ def main():
  print('Test accuracy:')
  pred_test = dnn_app_utils_v2.predict(test_x, test_y, parameters)
 
+
 if __name__ == '__main__':
  main()
-

lesson5/train_with_paddle.py

@@ -19,17 +19,12 @@
 7.预测并测试准确率train_accuracy和test_accuracy
 """
 
-import sys
+import matplotlib
 import numpy as np
-
 import paddle.v2 as paddle
-import h5py
-import scipy
-import matplotlib
+
 matplotlib.use('Agg')
 import matplotlib.pyplot as plt
-from scipy import ndimage
-from PIL import Image
 
 from lr_utils import load_dataset
 
@@ -289,7 +284,7 @@ def main():
  # 载入数据
  load_data()
 
- #构建神经网络结构
+ # 构建神经网络结构
  image, y_predict, y_label = netconfig()
 
  # 定义成本函数为交叉熵损失函数multi_binary_label_cross_entropy_cost
@@ -366,4 +361,4 @@ def event_handler(event):
 
 
 if __name__ == '__main__':
- main()
+ main()