x[m,n]是通过numpy库引用数组或矩阵中的某一段数据集的一种写法，
m代表第m维，n代表m维中取第几段特征数据。
通常用法：
x[:,n]或者x[n,:]
1.x[:,n]表示在全部数组（维）中取第n个数据，直观来说，x[:,n]就是取所有集合的第n个数据,
1 import numpy as np 2 3 X = np.array([[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[16,17],[18,19]]) 4 print X[:,0]
X[:,0]输出结果是：
1 import numpy as np 2 3 X = np.array([[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[16,17],[18,19]]) 4 print X[:,1]
2. x[n,:]表示在n个数组（维）中取全部数据，直观来说，x[n,:]就是取第n集合的所有数据,
X[1,:]即取第一维中下标为1的元素的所有值，输出结果：
X[:, m:n]，即取所有数据的第m到n-1列数据，含左不含右
例：输出X数组中所有行第1到2列数据
X = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11],[12,13,14],[15,16,17],[18,19,20]])
print X[:,1:3]
以下 numpy.random.shuffle() 简称 shuffle，numpy.random.permutation() 简称 permutation。
shuffle 的参数只能是 array_like，而 permutation 除了 array_like 还可以是 int 类型，如果是 int 类型，那就随机打乱 numpy.arange(int)。
shuffle 返回 None，这点尤其要注意，也就是说没有返回值，而 permutation 则返回打乱后的 array。
def permutation(self, object x): '''这里都是帮助文档，我就省略了''' if isinstance(x, (int, long, np.integer)): arr = np.arange(x) else: arr = np.array(x) self.shuffle(arr) return arr
所以permutation内部调用的也是shuffle
1.获取mini-batch：
def random_mini_batches(X,Y,mini_batch_size=64,seed=0):
第一，打乱顺序
permutation = list(np.random.permutation(m)) #它会返回一个长度为m的随机数组，且里面的数是0到m-1 shuffled_X = X[:,permutation] #将每一列的数据按permutation的顺序来重新排列。 shuffled_Y = Y[:,permutation].reshape((1,m))
X - 输入数据，维度为(输入节点数量，样本的数量) Y - 对应的是X的标签，【1 | 0】（蓝|红），维度为(1,样本的数量)
这一步就相当于对X的维度=1随机取，等于被打乱了（因为那个位置对应的都是样本）
第二.分割
num_complete_minibatches = math.floor(m / mini_batch_size) #把你的训练集分割成多少份,请注意，如果值是99.99，那么返回值是99，剩下的0.99会被舍弃 for k in range(0,num_complete_minibatches): mini_batch_X = shuffled_X[:,k * mini_batch_size:(k+1)*mini_batch_size] mini_batch_Y = shuffled_Y[:,k * mini_batch_size:(k+1)*mini_batch_size]
类似于
a = np.array([[1,2,3,4,5,6,7,8,9],
[9,8,7,6,5,4,3,2,1],
[1,2,3,4,5,6,7,8,9]])
k=1
mini_batch_size=3
print(a[:,1*3:(1+1)*3]) #从第4列到第6列
'''
[[4 5 6]
[6 5 4]
[4 5 6]]
'''
k=2
print(a[:,2*3:(2+1)*3]) #从第7列到第9列
'''
[[7 8 9]
[3 2 1]
[7 8 9]]
'''
包含动量的梯度下降：
这里的V还是指的dw与db的值
def initialize_velocity(parameters): """ 初始化速度，velocity是一个字典： - keys: "dW1", "db1", ..., "dWL", "dbL" - values:与相应的梯度/参数维度相同的值为零的矩阵。 参数： parameters - 一个字典，包含了以下参数： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl 返回: v - 一个字典变量，包含了以下参数： v["dW" + str(l)] = dWl的速度 v["db" + str(l)] = dbl的速度 """ L = len(parameters) // 2 #神经网络的层数 v = {} for l in range(L): v["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)]) v["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)]) return v
def update_parameters_with_momentun(parameters,grads,v,beta,learning_rate): """ 使用动量更新参数 参数： parameters - 一个字典类型的变量，包含了以下字段： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl grads - 一个包含梯度值的字典变量，具有以下字段： grads["dW" + str(l)] = dWl grads["db" + str(l)] = dbl v - 包含当前速度的字典变量，具有以下字段： v["dW" + str(l)] = ... v["db" + str(l)] = ... beta - 超参数，动量，实数 learning_rate - 学习率，实数 返回： parameters - 更新后的参数字典 v - 包含了更新后的速度变量 """ L = len(parameters) // 2 for l in range(L): #计算速度 v["dW" + str(l + 1)] = beta * v["dW" + str(l + 1)] + (1 - beta) * grads["dW" + str(l + 1)] v["db" + str(l + 1)] = beta * v["db" + str(l + 1)] + (1 - beta) * grads["db" + str(l + 1)] #更新参数 parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * v["dW" + str(l + 1)] parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * v["db" + str(l + 1)] return parameters,v
Adam算法
def initialize_adam(parameters): """ 初始化v和s，它们都是字典类型的变量，都包含了以下字段： - keys: "dW1", "db1", ..., "dWL", "dbL" - values：与对应的梯度/参数相同维度的值为零的numpy矩阵 参数： parameters - 包含了以下参数的字典变量： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl 返回： v - 包含梯度的指数加权平均值，字段如下： v["dW" + str(l)] = ... v["db" + str(l)] = ... s - 包含平方梯度的指数加权平均值，字段如下： s["dW" + str(l)] = ... s["db" + str(l)] = ... """ L = len(parameters) // 2 v = {} s = {} for l in range(L): v["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)]) v["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)]) s["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)]) s["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)]) return (v,s)
np.arange(24).reshape(4,6)
def update_parameters_with_adam(parameters,grads,v,s,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8): """ 使用Adam更新参数 参数： parameters - 包含了以下字段的字典： parameters['W' + str(l)] = Wl parameters['b' + str(l)] = bl grads - 包含了梯度值的字典，有以下key值： grads['dW' + str(l)] = dWl grads['db' + str(l)] = dbl v - Adam的变量，第一个梯度的移动平均值，是一个字典类型的变量 s - Adam的变量，平方梯度的移动平均值，是一个字典类型的变量 t - 当前迭代的次数 learning_rate - 学习率 beta1 - 动量，超参数,用于第一阶段，使得曲线的Y值不从0开始（参见天气数据的那个图） beta2 - RMSprop的一个参数，超参数 epsilon - 防止除零操作（分母为0） 返回： parameters - 更新后的参数 v - 第一个梯度的移动平均值，是一个字典类型的变量 s - 平方梯度的移动平均值，是一个字典类型的变量 """ L = len(parameters) // 2 v_corrected = {} #偏差修正后的值 s_corrected = {} #偏差修正后的值 for l in range(L): #梯度的移动平均值,输入："v , grads , beta1",输出：" v " v["dW" + str(l + 1)] = beta1 * v["dW" + str(l + 1)] + (1 - beta1) * grads["dW" + str(l + 1)] v["db" + str(l + 1)] = beta1 * v["db" + str(l + 1)] + (1 - beta1) * grads["db" + str(l + 1)] #计算第一阶段的偏差修正后的估计值，输入"v , beta1 , t" , 输出："v_corrected" v_corrected["dW" + str(l + 1)] = v["dW" + str(l + 1)] / (1 - np.power(beta1,t)) v_corrected["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - np.power(beta1,t)) #计算平方梯度的移动平均值，输入："s, grads , beta2"，输出："s" s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * np.square(grads["dW" + str(l + 1)]) s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * np.square(grads["db" + str(l + 1)]) #计算第二阶段的偏差修正后的估计值，输入："s , beta2 , t"，输出："s_corrected" s_corrected["dW" + str(l + 1)] = s["dW" + str(l + 1)] / (1 - np.power(beta2,t)) s_corrected["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - np.power(beta2,t)) #更新参数，输入: "parameters, learning_rate, v_corrected, s_corrected, epsilon". 输出: "parameters". parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * (v_corrected["dW" + str(l + 1)] / np.sqrt(s_corrected["dW" + str(l + 1)] + epsilon)) parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * (v_corrected["db" + str(l + 1)] / np.sqrt(s_corrected["db" + str(l + 1)] + epsilon)) return (parameters,v,s)
现在用类似之前的模型来写个程序
def model(X,Y,layers_dims,optimizer,learning_rate=0.0007, mini_batch_size=64,beta=0.9,beta1=0.9,beta2=0.999, epsilon=1e-8,num_epochs=10000,print_cost=True,is_plot=True): """ 可以运行在不同优化器模式下的3层神经网络模型。 参数： X - 输入数据，维度为（2，输入的数据集里面样本数量） Y - 与X对应的标签 layers_dims - 包含层数和节点数量的列表 optimizer - 字符串类型的参数，用于选择优化类型，【 "gd" | "momentum" | "adam" 】 learning_rate - 学习率 mini_batch_size - 每个小批量数据集的大小 beta - 用于动量优化的一个超参数 beta1 - 用于计算梯度后的指数衰减的估计的超参数 beta1 - 用于计算平方梯度后的指数衰减的估计的超参数 epsilon - 用于在Adam中避免除零操作的超参数，一般不更改 num_epochs - 整个训练集的遍历次数，（视频2.9学习率衰减，1分55秒处，视频中称作“代”）,相当于之前的num_iteration print_cost - 是否打印误差值，每遍历1000次数据集打印一次，但是每100次记录一个误差值，又称每1000代打印一次 is_plot - 是否绘制出曲线图 返回： parameters - 包含了学习后的参数 """ L = len(layers_dims) costs = [] t = 0 #每学习完一个minibatch就增加1 seed = 10 #随机种子 #初始化参数 parameters = opt_utils.initialize_parameters(layers_dims) #选择优化器 注意注意，重点操作！优化用的是啥就指望这个呢！这里是初始化V与S
if optimizer == "gd": pass #不使用任何优化器，直接使用梯度下降法 elif optimizer == "momentum": v = initialize_velocity(parameters) #使用动量 elif optimizer == "adam": v, s = initialize_adam(parameters)#使用Adam优化 else: print("optimizer参数错误，程序退出。") exit(1) #开始学习 for i in range(num_epochs): #定义随机 minibatches,我们在每次遍历数据集之后增加种子以重新排列数据集，使每次数据的顺序都不同 seed = seed + 1 minibatches = random_mini_batches(X,Y,mini_batch_size,seed) for minibatch in minibatches: #选择一个minibatch (minibatch_X,minibatch_Y) = minibatch #前向传播 A3 , cache = opt_utils.forward_propagation(minibatch_X,parameters) #计算误差 cost = opt_utils.compute_cost(A3 , minibatch_Y) #反向传播 grads = opt_utils.backward_propagation(minibatch_X,minibatch_Y,cache) #更新参数 注意注意 重点操作第二步，这里头是更新不同的参数 if optimizer == "gd": parameters = update_parameters_with_gd(parameters,grads,learning_rate) elif optimizer == "momentum": parameters, v = update_parameters_with_momentun(parameters,grads,v,beta,learning_rate) elif optimizer == "adam": t = t + 1 #这个t是用来修正v和s的corrected的 parameters , v , s = update_parameters_with_adam(parameters,grads,v,s,t,learning_rate,beta1,beta2,epsilon) #记录误差值 if i % 100 == 0: costs.append(cost) #是否打印误差值 if print_cost and i % 1000 == 0: print("第" + str(i) + "次遍历整个数据集，当前误差值：" + str(cost)) #是否绘制曲线图 if is_plot: plt.plot(costs) plt.ylabel('cost') plt.xlabel('epochs (per 100)') plt.title("Learning rate = " + str(learning_rate)) plt.show() return parameters
普通
#使用普通的梯度下降 layers_dims = [train_X.shape[0],5,2,1] parameters = model(train_X, train_Y, layers_dims, optimizer="gd",is_plot=True)
adam优化后
layers_dims = [train_X.shape[0], 5, 2, 1] #使用Adam优化的梯度下降 parameters = model(train_X, train_Y, layers_dims, optimizer="adam",is_plot=True)
预测（这里一直不是很懂，回头再看看opt_utils的代码研究研究）
#预测 preditions = opt_utils.predict(train_X,train_Y,parameters) #绘制分类图 plt.title("Model with Adam optimization") axes = plt.gca() axes.set_xlim([-1.5, 2.5]) axes.set_ylim([-1, 1.5]) opt_utils.plot_decision_boundary(lambda x: opt_utils.predict_dec(parameters, x.T), train_X, train_Y)
opt_utils的代码
1 # -*- coding: utf-8 -*- 2 3 #opt_utils.py 4 5 import numpy as np 6 import matplotlib.pyplot as plt 7 import sklearn 8 import sklearn.datasets 9 10 def sigmoid(x): 11 """ 12 Compute the sigmoid of x 13 14 Arguments: 15 x -- A scalar or numpy array of any size. 16 17 Return: 18 s -- sigmoid(x) 19 """ 20 s = 1/(1+np.exp(-x)) 21 return s 22 23 def relu(x): 24 """ 25 Compute the relu of x 26 27 Arguments: 28 x -- A scalar or numpy array of any size. 29 30 Return: 31 s -- relu(x) 32 """ 33 s = np.maximum(0,x) 34 35 return s 36 37 38 def load_params_and_grads(seed=1): 39 np.random.seed(seed) 40 W1 = np.random.randn(2,3) 41 b1 = np.random.randn(2,1) 42 W2 = np.random.randn(3,3) 43 b2 = np.random.randn(3,1) 44 45 dW1 = np.random.randn(2,3) 46 db1 = np.random.randn(2,1) 47 dW2 = np.random.randn(3,3) 48 db2 = np.random.randn(3,1) 49 50 return W1, b1, W2, b2, dW1, db1, dW2, db2 51 52 def initialize_parameters(layer_dims): 53 """ 54 Arguments: 55 layer_dims -- python array (list) containing the dimensions of each layer in our network 56 57 Returns: 58 parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL": 59 W1 -- weight matrix of shape (layer_dims[l], layer_dims[l-1]) 60 b1 -- bias vector of shape (layer_dims[l], 1) 61 Wl -- weight matrix of shape (layer_dims[l-1], layer_dims[l]) 62 bl -- bias vector of shape (1, layer_dims[l]) 63 64 Tips: 65 - For example: the layer_dims for the "Planar Data classification model" would have been [2,2,1]. 66 This means W1's shape was (2,2), b1 was (1,2), W2 was (2,1) and b2 was (1,1). Now you have to generalize it! 67 - In the for loop, use parameters['W' + str(l)] to access Wl, where l is the iterative integer. 68 """ 69 70 np.random.seed(3) 71 parameters = {} 72 L = len(layer_dims) # number of layers in the network 73 74 for l in range(1, L): 75 parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1])* np.sqrt(2 / layer_dims[l-1]) 76 parameters['b' + str(l)] = np.zeros((layer_dims[l], 1)) 77 78 assert(parameters['W' + str(l)].shape == layer_dims[l], layer_dims[l-1]) 79 assert(parameters['W' + str(l)].shape == layer_dims[l], 1) 80 81 return parameters 82 83 def forward_propagation(X, parameters): 84 """ 85 Implements the forward propagation (and computes the loss) presented in Figure 2. 86 87 Arguments: 88 X -- input dataset, of shape (input size, number of examples) 89 parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3": 90 W1 -- weight matrix of shape () 91 b1 -- bias vector of shape () 92 W2 -- weight matrix of shape () 93 b2 -- bias vector of shape () 94 W3 -- weight matrix of shape () 95 b3 -- bias vector of shape () 96 97 Returns: 98 loss -- the loss function (vanilla logistic loss) 99 """ 100 101 # retrieve parameters 102 W1 = parameters["W1"] 103 b1 = parameters["b1"] 104 W2 = parameters["W2"] 105 b2 = parameters["b2"] 106 W3 = parameters["W3"] 107 b3 = parameters["b3"] 108 109 # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID 110 z1 = np.dot(W1, X) + b1 111 a1 = relu(z1) 112 z2 = np.dot(W2, a1) + b2 113 a2 = relu(z2) 114 z3 = np.dot(W3, a2) + b3 115 a3 = sigmoid(z3) 116 117 cache = (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3) 118 119 return a3, cache 120 121 def backward_propagation(X, Y, cache): 122 """ 123 Implement the backward propagation presented in figure 2. 124 125 Arguments: 126 X -- input dataset, of shape (input size, number of examples) 127 Y -- true "label" vector (containing 0 if cat, 1 if non-cat) 128 cache -- cache output from forward_propagation() 129 130 Returns: 131 gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables 132 """ 133 m = X.shape[1] 134 (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3) = cache 135 136 dz3 = 1./m * (a3 - Y) 137 dW3 = np.dot(dz3, a2.T) 138 db3 = np.sum(dz3, axis=1, keepdims = True) 139 140 da2 = np.dot(W3.T, dz3) 141 dz2 = np.multiply(da2, np.int64(a2 > 0)) 142 dW2 = np.dot(dz2, a1.T) 143 db2 = np.sum(dz2, axis=1, keepdims = True) 144 145 da1 = np.dot(W2.T, dz2) 146 dz1 = np.multiply(da1, np.int64(a1 > 0)) 147 dW1 = np.dot(dz1, X.T) 148 db1 = np.sum(dz1, axis=1, keepdims = True) 149 150 gradients = {"dz3": dz3, "dW3": dW3, "db3": db3, 151 "da2": da2, "dz2": dz2, "dW2": dW2, "db2": db2, 152 "da1": da1, "dz1": dz1, "dW1": dW1, "db1": db1} 153 154 return gradients 155 156 def compute_cost(a3, Y): 157 158 """ 159 Implement the cost function 160 161 Arguments: 162 a3 -- post-activation, output of forward propagation 163 Y -- "true" labels vector, same shape as a3 164 165 Returns: 166 cost - value of the cost function 167 """ 168 m = Y.shape[1] 169 170 logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y) 171 cost = 1./m * np.sum(logprobs) 172 173 return cost 174 175 def predict(X, y, parameters): 176 """ 177 This function is used to predict the results of a n-layer neural network. 178 179 Arguments: 180 X -- data set of examples you would like to label 181 parameters -- parameters of the trained model 182 183 Returns: 184 p -- predictions for the given dataset X 185 """ 186 187 m = X.shape[1] 188 p = np.zeros((1,m), dtype = np.int) 189 190 # Forward propagation 191 a3, caches = forward_propagation(X, parameters) 192 193 # convert probas to 0/1 predictions 194 for i in range(0, a3.shape[1]): 195 if a3[0,i] > 0.5: 196 p[0,i] = 1 197 else: 198 p[0,i] = 0 199 200 # print results 201 202 #print ("predictions: " + str(p[0,:])) 203 #print ("true labels: " + str(y[0,:])) 204 print("Accuracy: " + str(np.mean((p[0,:] == y[0,:])))) 205 206 return p 207 208 def predict_dec(parameters, X): 209 """ 210 Used for plotting decision boundary. 211 212 Arguments: 213 parameters -- python dictionary containing your parameters 214 X -- input data of size (m, K) 215 216 Returns 217 predictions -- vector of predictions of our model (red: 0 / blue: 1) 218 """ 219 220 # Predict using forward propagation and a classification threshold of 0.5 221 a3, cache = forward_propagation(X, parameters) 222 predictions = (a3 > 0.5) 223 return predictions 224 225 def plot_decision_boundary(model, X, y): 226 # Set min and max values and give it some padding 227 x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1 228 y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1 229 h = 0.01 230 # Generate a grid of points with distance h between them 231 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) 232 # Predict the function value for the whole grid 233 Z = model(np.c_[xx.ravel(), yy.ravel()]) 234 Z = Z.reshape(xx.shape) 235 # Plot the contour and training examples 236 plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral) 237 plt.ylabel('x2') 238 plt.xlabel('x1') 239 plt.scatter(X[0, :], X[1, :], c=y, cmap=plt.cm.Spectral) 240 plt.show() 241 242 def load_dataset(is_plot = True): 243 np.random.seed(3) 244 train_X, train_Y = sklearn.datasets.make_moons(n_samples=300, noise=.2) #300 #0.2 245 # Visualize the data 246 if is_plot: 247 plt.scatter(train_X[:, 0], train_X[:, 1], c=train_Y, s=40, cmap=plt.cm.Spectral); 248 train_X = train_X.T 249 train_Y = train_Y.reshape((1, train_Y.shape[0])) 250 251 return train_X, train_Y