PaddlePaddle 深度学习实战（第一部分）

PaddlePaddle 深度学习实战（第二部分）

PaddlePaddle 深度学习实战（第三部分）

PaddlePaddle 深度学习实战（第四部分）

PaddlePaddle 深度学习实战（第五部分）

浅层神经网络、BP算法(反向传播)

浅层神经网络的结构、前向传播、反向传播(BP算法)、梯度下降、激活函数(非线性函数/非线性映射)

import random
import numpy as npdef load_data_sets():"""加载数据Return:train_x:训练集的Xtrain_y:训练集的labelX:测试集的XY:测试集的label"""N = 200      # 每个类型的点数量 number of points per classD = 2     # 维度大小 dimensionalityK = 2     # 类型数量 number of classesnumber = N * KX = np.zeros((N * K, D))        # 矩阵中每行是一个样本数据 data matrix (each row = single example)y = np.zeros(N * K, dtype='uint8')   # 类型标签 class labels#实质自动往X原数据集和y标签集数据填充数据for j in range(K):ix = range(N * j, N * (j + 1))r = np.linspace(0.0, 1, N)      # 半径长度/半径范围 radiust = np.linspace(j * 4, (j + 1) * 4, N) + np.random.randn(N) * 0.2  # thetaX[ix] = np.c_[r * np.sin(t), r * np.cos(t)]y[ix] = jX = X.T   #(2,400) 即(特征列数,样本数)Y = y.reshape(1, number) #(1,400) 即(特征列数,标签数)# 训练集 随机从1~400中选取320个数字作为样本数据的索引train_num = random.sample(range(number), 320)  # 共400组数据，训练集取其中80%，即320组train_x = X[:, train_num] #train_x.shape为(2,320)train_y = Y[:, train_num] #train_y.shape为(1,320)result = [train_x, train_y, X, Y]return result

"""使用python及numpy库来实现浅层神经网络识别花型图案，关键步骤如下：1.载入数据和预处理：load_planar_dataset2.初始化模型参数（Parameters）3.循环：a) 计算成本（Cost）b)  计算梯度（Gradient）c)  更新参数（Gradient Descent）4.搭建双层神经网络，利用模型进行预测5.分析预测结果6.定义model函数来按顺序将上述步骤合并
"""
import matplotlib.pyplot as plt
import numpy as np
import utilsdef layer_sizes(X, Y):"""设置网络结构Args:X: 输入的数据Y: 输出值Return:n_x: 输入层节点数n_h: 隐藏层节点数n_y: 输出层节点数""" n_x = X.shape[0]  # 输入层大小（节点数），X.shape为(特征列数,样本数)n_h = 4n_y = Y.shape[0]  # 输出层大小（节点数），Y.shape为(特征列数,标签数)return (n_x, n_h, n_y)def initialize_parameters(n_x, n_h, n_y):"""初始化参数Args:n_x: 输入层大小n_h: 隐藏层大小n_y: 输出层大小Return:parameters: 一个包含所有参数的python字典，参数如下W1 -- 隐藏层权重，维度是 (n_h, n_x)，即 (隐藏层节点数,输入层节点数)b1 -- 隐藏层偏移量，维度是 (n_h, 1)，即 (隐藏层节点数,1)W2 -- 输出层权重，维度是 (n_y, n_h)，即 (输出层节点数,隐藏层节点数)b2 -- 输出层偏移量，维度是 (n_y, 1)，即 (输出层节点数,1)"""np.random.seed(2)  # 设置随机种子# 随机初始化参数，偏移量初始化为0W1 = 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 #第二层输出层权重b2 = np.zeros((n_y, 1))       #第二层输出层偏置assert W1.shape == (n_h, n_x)assert b1.shape == (n_h, 1)assert W2.shape == (n_y, n_h)assert b2.shape == (n_y, 1)parameters = {"W1": W1,"b1": b1,"W2": W2,"b2": b2}return parameters

def forward_propagation(X, parameters):"""前向传播Args:X: 输入值parameters: 一个python字典，包含权值W1，W2和bias b1，b2Return:A2: 模型输出值cache: 一个字典，包含 "Z1", "A1", "Z2" and "A2""""W1 = parameters["W1"] #第一层隐藏层权重b1 = parameters["b1"] #第一层隐藏层偏置W2 = parameters["W2"] #第二层输出层权重b2 = parameters["b2"] #第二层输出层偏置# 计算隐藏层：线性输出Z1、非线性输出A1 Z1 = np.dot(W1, X) + b1     #线性函数wx+bA1 = np.tanh(Z1)     #非线性函数/非线性映射tanh# 计算输出层：线性输出Z2、非线性输出A2(模型预测值) Z2 = np.dot(W2, A1) + b2     #线性函数wx+bA2 = 1 / (1 + np.exp(-Z2))  #非线性函数/非线性映射sigmoidassert A2.shape == (1, X.shape[1]) #预测值A2的形状为(1,样本数)，X.shape为(特征列数,样本数)cache = {"Z1": Z1,"A1": A1,"Z2": Z2,"A2": A2}return A2, cache

def calculate_cost(A2, Y, parameters):"""根据第四章给出的公式计算成本Args:A2: 模型输出值Y: 真实值parameters: 一个python字典包含参数 W1, b1, W2和b2Return:cost: 成本函数"""m = Y.shape[1]  # 样本个数，Y.shape为(特征列数,标签数)，标签数即等于样本个数# 计算成本，使用交叉熵损失函数multi_binary_label_cross_entropy_costlogprobs = np.multiply(np.log(A2), Y) + np.multiply(np.log(1 - A2), 1 - Y) #cost = -1. / m * np.sum(logprobs)cost = np.squeeze(cost)  # 确保维度的正确性。squeeze可以对矩阵和list进行压缩/降维。assert isinstance(cost, float)return cost

def backward_propagation(parameters, cache, X, Y):"""后向传播Args:parameters: 一个python字典，包含所有参数cache: 一个python字典包含"Z1", "A1", "Z2"和"A2".X: 输入值Y: 真实值Return:grads: 一个pyth字典包含所有参数的梯度dW1，db1，dW2，db2"""m = X.shape[1] #m为样本数，X.shape为(特征列数,样本数)# 首先从"parameters"获取W1、W2，即 每层的权重WW1 = parameters["W1"] #第一层隐藏层权重 W2 = parameters["W2"] #第二层输出层权重# 从"cache"中获取A1、A2，即每层的输出AA1 = cache["A1"] #第一层隐藏层的非线性输出A1 A2 = cache["A2"] #第二层输出层的非线性输出A2(模型预测值) """反向传播：计算参数W的梯度dW1、dW2和参数b的梯度db1、db2，根据链式法则+梯度下降的向量化实现理论得出如下1.第二层输出层：1.dZ2=A2-Y。模型预测值A2 减去 真实值Y2.dW2=dot(dZ2,A1.T)/m。dot为点乘运算。3.db2=sum(dZ2)/m。dZ2的总和除以样本数m2.第一层隐藏层：1.dZ1=dot(W2.T,dZ2)*(1-A1的平方)。dot为点乘运算。2.dW1=dot(dZ1.T,X.T)/m。3.db1=sum(dZ1)/m。dZ1的总和除以样本数m"""# 后向传播: 计算参数W的梯度dW1、dW2和参数b的梯度db1、db2dZ2 = A2 - Y #dZ2=A2-YdW2 = 1. / m * np.dot(dZ2, A1.T) #dW2=dot(dZ2,A1.T)/m db2 = 1. / m * np.sum(dZ2, axis=1, keepdims=True) #db2=sum(dZ2)/mdZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2)) #dZ1=dot(W2.T,dZ2)*(1-A1的平方) dW1 = 1. / m * np.dot(dZ1, X.T) #dW1=dot(dZ1.T,X.T)/mdb1 = 1. / m * np.sum(dZ1, axis=1, keepdims=True) #db1=sum(dZ1)/mgrads = {"dW1": dW1,"db1": db1,"dW2": dW2,"db2": db2}return gradsdef update_parameters(parameters, grads, learning_rate=1.2):"""使用梯度更新参数Args:parameters: 包含所有参数的python字典grads: 包含所有参数梯度的python字典learning_rate: 学习步长Return:parameters: 包含更新后参数的python"""# 从"parameters"中读取全部参数W1 = parameters["W1"]#第一层隐藏层权重b1 = parameters["b1"]#第一层隐藏层偏置W2 = parameters["W2"]#第二层输出层权重b2 = parameters["b2"]#第二层输出层偏置# 从"grads"中读取全部梯度dW1 = grads["dW1"]#第一层隐藏层权重的梯度值db1 = grads["db1"]#第一层隐藏层偏置的梯度值dW2 = grads["dW2"]#第二层输出层权重的梯度值db2 = grads["db2"]#第二层输出层偏置的梯度值# 更新参数W1 = W1 - learning_rate * dW1b1 = b1 - learning_rate * db1W2 = W2 - learning_rate * dW2b2 = b2 - learning_rate * db2parameters = {"W1": W1,"b1": b1,"W2": W2,"b2": b2}return parameters

def train(X, Y, n_h, num_iterations=10000, print_cost=False):"""定义神经网络模型，把之前的操作合并到一起Args:X: 输入值Y: 真实值n_h: 隐藏层大小/节点数num_iterations: 训练次数print_cost: 设置为True，则每1000次训练打印一次成本函数值Return:parameters: 模型训练所得参数，用于预测"""np.random.seed(3) # 设置随机种子n_x = layer_sizes(X, Y)[0] #n_x输入层节点数n_y = layer_sizes(X, Y)[2] #n_y输出层节点数#n_x输入层节点数, n_h隐藏层节点数, n_y输出层节点数# 根据n_x, n_h, n_y初始化参数，并取出W1,b1,W2,b2parameters = 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".A2, cache = forward_propagation(X, parameters)# 成本计算. 输入: "A2模型预测值, Y真实值, parameters". 输出: "cost".cost = calculate_cost(A2, Y, parameters)# 后向传播， 输入: "parameters, cache, X, Y". 输出: "grads".grads = backward_propagation(parameters, cache, X, Y)# 参数更新. 输入: "parameters, grads". 输出: "parameters".parameters = update_parameters(parameters, grads)# 每1000次训练打印一次成本函数值if print_cost and i % 1000 == 0:print "Cost after iteration %i: %f" % (i, cost)#返回训练好的参数return parameters

def predict(parameters, X):"""使用训练所得参数，对每个训练样本进行预测Args:parameters: 存有参数的python字典X: 输入值Return：predictions: 模型预测值向量(红色: 0 / 蓝色: 1)"""# 使用训练好所得的参数进行前向传播计算，并将模型输出值转化为预测值（大于0.5视作1，即True）A2, cache = forward_propagation(X, parameters)predictions = A2 > 0.5 #多个预测值中，有预测值大于0.5视作1，即Truereturn predictions

import matplotlib.pyplot as plt
import numpy as npdef plot_decision_boundary(model, X, Y):"""把数据和分界展示在图上Args:model: 模型X: 数据集的XY: 数据集的标签Return:"""# Set min and max values and give it some paddingx_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1h = 0.01# Generate a grid of points with distance h between themxx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))# Predict the function value for the whole gridZ = model(np.c_[xx.ravel(), yy.ravel()])Z = Z.reshape(xx.shape)# Plot the contour and training examplesplt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)plt.ylabel('x2')plt.xlabel('x1')plt.scatter(X[0, :], X[1, :], c=Y, cmap=plt.cm.Spectral)def main():"""程序入口"""# 加载数据：train_X训练集数据(2,320)，train_Y训练标签集数据(1,320)，test_X测试集数据(2,320)，test_Y测试标签集数据(1,400)train_X, train_Y, test_X, test_Y = utils.load_data_sets()print "1. show the data set"shape_X = train_X.shapeshape_Y = train_Y.shapeprint ('The shape of X is: ' + str(shape_X))print ('The shape of Y is: ' + str(shape_Y))plt.scatter(test_X.T[:, 0], test_X.T[:, 1], c=test_Y, s=40, cmap=plt.cm.Spectral)plt.title("show the data set")plt.show()print "2. begin to training"# 训练模型parameters = train(train_X, train_Y, n_h=10, num_iterations=10000, print_cost=True)# 预测训练集predictions = predict(parameters, train_X)# 输出准确率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) + '%')#把数据和分界展示在图上print "3. output the division"utils.plot_decision_boundary(lambda x: predict(parameters, x.T), train_X, train_Y)plt.title("Decision Boundary for hidden layer size " + str(4))plt.show()if __name__ == '__main__':main()

"""使用paddle框架实现浅层神经网络识别“花，型图案，关键步骤如下：1.载入数据和预处理：load_data()2.定义train()和test()用于读取训练数据和测试数据，分别返回一个reader3.初始化4.配置网络结构和设置参数：- 定义成本函数cost- 创建parameters- 定义优化器optimizer5.定义event_handler6.定义trainer7.开始训练8.预测infer()并输出准确率train_accuracy和test_accuracy9.展示学习曲线plot_costs()
"""import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import paddle.v2 as paddle
import utilsTRAINING_SET = None #包含训练集和标签集
TEST_SET = None    #包含测试集和标签集
DATA_DIM = None   #一个样本的特征数(列数)，即一个样本的特征维度def load_data():"""载入数据，数据项包括：train_set_x：原始训练数据集train_set_y：原始训练数据标签test_set_x：原始测试数据集test_set_y：原始测试数据标签"""global TRAINING_SET, TEST_SET, DATA_DIMtrain_set_x, train_set_y, test_set_x, test_set_y = utils.load_data_sets()# 定义纬度，即一个样本的特征数(列数)，即一个样本的特征维度DATA_DIM = 2# 使用numpy.hstack实现numpy数组的横向合并。# np.hstack把两个矩阵进行堆叠组合在一起，默认在asix=0的列上进行堆叠，即增加一列，相当于把标签集作为一列增加到训练集中的最后一列的后面。TRAINING_SET = np.hstack((train_set_x.T, train_set_y.T))TEST_SET = np.hstack((test_set_x.T, test_set_y.T))def read_data(data_set):"""读取训练数据或测试数据，服务于train()和test()Args:data_set: 要获取的数据集Return:reader: 用于获取训练数据集及其标签的生成器generator"""def reader():"""一个readerArgs:Return:data[:-1], data[-1:] -- 使用yield返回生成器(generator)，data[:-1]表示前n-1个元素，也就是训练数据，data[-1:]表示最后一个元素，也就是对应的标签"""for data in data_set:yield data[:-1], data[-1:]return readerdef train():"""定义一个reader来获取训练数据集及其标签Args:Return:read_data: 用于获取训练数据集及其标签的reader"""global TRAINING_SETreturn read_data(TRAINING_SET)def test():"""定义一个reader来获取测试数据集及其标签Return:read_data: 用于获取测试数据集及其标签的reader"""global TEST_SETreturn read_data(TEST_SET)def get_data(data_creator):"""使用参数data_creator来获取测试数据Args:data_creator: 数据来源,可以是train()或者test()Return:result: 包含测试数据(image)和标签(label)的python字典"""data_creator = data_creatordata_image = []data_label = []for item in data_creator():data_image.append((item[0],))data_label.append(item[1])result = {"image": data_image,"label": data_label}return result

def network_config():"""配置网络结构和设置参数Return:image: 输入层，DATADIM维稠密向量y_predict: 输出层，Sigmoid作为激活函数y_label: 标签数据，1维稠密向量cost: 损失函数parameters: 模型参数optimizer: 优化器feeding: 数据映射，python字典"""# 输入层，paddle.layer.data表示数据层,name=’image’：名称为image,# type=paddle.data_type.dense_vector(DATA_DIM)：数据类型为DATA_DIM维稠密向量，每个样本的特征维度，即(2,1)中的2行均为特征值image = paddle.layer.data(name='image', type=paddle.data_type.dense_vector(DATA_DIM))# 隐藏层，paddle.layer.fc表示全连接层，input=image: 该层输入数据为image# size=4：神经元个数，act=paddle.activation.Tanh()：激活函数为Tanh()hidden_layer_1 = paddle.layer.fc(input=image, size=4, act=paddle.activation.Tanh())# 输出层，paddle.layer.fc表示全连接层，input=h1: 该层输入数据为h1# size=1：神经元个数，act=paddle.activation.Sigmoid()：激活函数为Sigmoid()y_predict = paddle.layer.fc(input=hidden_layer_1, size=1, act=paddle.activation.Sigmoid())# 标签数据，paddle.layer.data表示数据层，name=’label’：名称为label# type=paddle.data_type.dense_vector(1)：数据类型为1维稠密向量，每个样本的标签维度，即(1,1)中的1行为标签值y_label = paddle.layer.data(name='label', type=paddle.data_type.dense_vector(1))# 定义成本函数为交叉熵损失函数multi_binary_label_cross_entropy_costcost = paddle.layer.multi_binary_label_cross_entropy_cost(input=y_predict, label=y_label)# 利用cost创建parametersparameters = paddle.parameters.create(cost)# 创建optimizer，并初始化momentum和learning_rate# 加入动量项Momentum，可以加速更新过程，比如当接近局部最小时，通过震荡作用，跳出局部最小继续下降到全局最小。# 训练过程在更新权重时采用动量优化器 Momentum ，比如momentum=0.9 代表动量优化每次保持前一次速度的0.9倍。  optimizer = paddle.optimizer.Momentum(momentum=0, learning_rate=0.0005)# 数据层和数组索引映射，用于trainer训练时喂数据feeding = {'image': 0,'label': 1}result = [image, y_predict, y_label, cost, parameters, optimizer, feeding]return result

def main():"""定义神经网络结构，训练、预测、检验准确率并打印学习曲线"""global DATA_DIM# 初始化，设置是否使用gpu，trainer数量表示仅使用一个线程进行训练paddle.init(use_gpu=False, trainer_count=1)# 载入数据load_data()# 配置网络结构和设置参数image, y_predict, y_label, cost, parameters, optimizer, feeding = network_config()# 记录成本costcosts = []# 处理事件def event_handler(event):"""事件处理器，可以根据训练过程的信息作相应操作Args: event: 事件对象，包含event.pass_id, event.batch_id, event.cost等信息"""if isinstance(event, paddle.event.EndIteration):if event.pass_id % 100 == 0:print("Pass %d, Batch %d, Cost %f" %(event.pass_id, event.batch_id, event.cost))costs.append(event.cost)# with open('params_pass_%d.tar' % event.pass_id, 'w') as f:#     parameters.to_tar(f)# 构造trainer，SGD定义一个随机梯度下降，配置三个参数cost、parameters、update_equation，它们分别表示成本函数、参数和更新公式。trainer = paddle.trainer.SGD(cost=cost, parameters=parameters, update_equation=optimizer)"""模型训练paddle.reader.shuffle(train(), buf_size=5000)：表示trainer从train()这个reader中读取了buf_size=5000大小的数据并打乱顺序paddle.batch(reader(), batch_size=256)：表示从打乱的数据中再取出batch_size=256大小的数据进行一次迭代训练feeding：用到了之前定义的feeding索引，将数据层image和label输入trainerevent_handler：事件管理机制，可以自定义event_handler，根据事件信息作相应的操作num_passes：定义训练的迭代次数"""trainer.train(reader=paddle.batch(paddle.reader.shuffle(train(), buf_size=5000),batch_size=256),feeding=feeding,event_handler=event_handler,num_passes=10000)# 预测infer(y_predict, parameters)# 展示学习曲线plot_costs(costs)if __name__ == '__main__':main()

def calc_accuracy(probs, data):"""根据数据集来计算准确度accuracyArgs:probs: 数据集的预测结果，调用paddle.infer()来获取data: 数据集Return:calc_accuracy: 训练准确度"""right = 0total = len(data['label'])for i in range(len(probs)):if float(probs[i][0]) > 0.5 and data['label'][i] == 1:right += 1elif float(probs[i][0]) < 0.5 and data['label'][i] == 0:right += 1accuracy = (float(right) / float(total)) * 100return accuracy

def infer(y_predict, parameters):"""预测并输出模型准确率Args:y_predict: 输出层，DATADIM维稠密向量parameters: 训练完成的模型参数"""# 获取测试数据和训练数据，用来验证模型准确度train_data = get_data(train())test_data = get_data(test())# 根据train_data和test_data预测结果，output_layer表示输出层，parameters表示模型参数，input表示输入的测试数据probs_train = paddle.infer(output_layer=y_predict,parameters=parameters,input=train_data['image'])probs_test = paddle.infer(output_layer=y_predict,parameters=parameters,input=test_data['image'])# 计算train_accuracy和test_accuracyprint "train_accuracy: {} %".format(calc_accuracy(probs_train, train_data))print "test_accuracy: {} %".format(calc_accuracy(probs_test, test_data))

def plot_costs(costs):"""利用costs展示模型的训练曲线Args: costs: 记录了训练过程的cost变化的list，每一百次迭代记录一次"""costs = np.squeeze(costs)plt.plot(costs)plt.ylabel('cost')plt.xlabel('iterations (per hundreds)')plt.title("Learning rate = 0.0005")plt.show()plt.savefig('costs.png')

Jupyter文件中的内容

Numpy实现浅层神经网络实践部分将搭建神经网络，包含一个隐藏层，实验将会展现出与Logistic回归的不同之处。实验将使用两层神经网络实现对“花”型图案的分类，如图所示，图中的点包含红点（y=0）和蓝点（y=1）还有点的坐标信息，实验将通过以下步骤完成对两种点的分类，使用Numpy实现。输入样本；搭建神经网络；初始化参数；训练，包括前向传播与后向传播（即BP算法）；得出训练后的参数；根据训练所得参数，绘制两类点边界曲线。该实验将使用Python原生库实现两层神经网络的搭建，完成分类。

"""
用于载入数据
load_planar_dataset()函数返回训练集和测试集
"""
import matplotlib.pyplot as plt
import numpy as np
import random
import sklearn
import sklearn.datasets
import sklearn.linear_model#绘制分类结果边界
def plot_decision_boundary(model, X, y):"""绘制分类边界model: 模型X: 输入值y: 真实值"""# Set min and max values and give it some paddingx_min, x_max = X[0, : ].min() - 1, X[0, : ].max() + 1y_min, y_max = X[1, : ].min() - 1, X[1, : ].max() + 1h = 0.01# Generate a grid of points with distance h between themxx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))# Predict the function value for the whole gridZ = model(np.c_[xx.ravel(), yy.ravel()])Z = Z.reshape(xx.shape)# Plot the contour and training examplesplt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)plt.ylabel('x2')plt.xlabel('x1')plt.scatter(X[0, : ], X[1, : ], c=y, cmap=plt.cm.Spectral)#定义Sigmoid函数
def sigmoid(x):"""Compute the sigmoid of xArguments:x -- A scalar or numpy array of any size.Return:s -- sigmoid(x)"""# Sigmoid计算s = 1 / (1 + np.exp(-x))return s#加载数据
def load_planar_dataset():"""加载数据返回值：train_x:训练集的输入train_y:训练集的真实值X:测试集的输入Y:测试集的真实值"""np.random.seed(1) #设置随机种子m = 400 # number of examplesN = int(m / 2) # number of points per classD = 2 # dimensionalityX = np.zeros((m, D)) # data matrix where each row is a single exampleY = np.zeros((m, 1), dtype='uint8') # labels vector (0 for red, 1 for blue)a = 4 # maximum ray of the flowerfor j in range(2):ix = range(N * j, N * (j + 1))t = np.linspace(j * 3.12, (j + 1) * 3.12, N) + np.random.randn(N) * 0.2 # thetar = a * np.sin(4 * t) + np.random.randn(N) * 0.2 # radiusX[ix] = np.c_[r * np.sin(t), r * np.cos(t)]Y[ix] = j#测试集，取全部数据X = X.TY = Y.T#训练集train_num = random.sample(range(400),320)#共400组数据，训练集取其中80%，即320组train_x = X[: , train_num]train_y = Y[: , train_num]dataset = [train_x, train_y, X, Y]return dataset#加载其他数据
def load_extra_datasets():"""加载其它数据return:result:包含5种不同类型数据的集合"""N = 200noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3)noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2)blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6)gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2, n_classes=2, shuffle=True, random_state=None)no_structure = np.random.rand(N, 2), np.random.rand(N, 2)result = [noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure]return result

1.引用库首先，载入几个需要用到的库，它们分别是：numpy：一个python的基本库，用于科学计算planar_utils：定义了一些工具函数matplotlib.pyplot：用于生成图，在验证模型准确率和展示成本变化趋势时会使用到sklearn：用于数据挖掘和数据分析import numpy as npimport sklearnfrom planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasetsimport matplotlib.pyplot as plt%matplotlib inlinenp.random.seed(1) 2.载入数据并观察纬度载入数据后，输出维度#载入数据train_x, train_y, test_x, test_y = load_planar_dataset()#输出维度shape_X = train_x.shapeshape_Y = train_y.shapeprint ('The shape of X is: ' + str(shape_X))print ('The shape of Y is: ' + str(shape_Y))#The shape of X is: (2, 320)#The shape of Y is: (1, 320)由输出可知每组输入坐标X包含两个值，Y包含一个值，共320组数据（测试集在训练集基础上增加80组数据，共400组）。3.简单逻辑回归实验使用逻辑回归处理该数据，观察分类结果#训练逻辑回归分类器clf = sklearn.linear_model.LogisticRegressionCV();clf.fit(train_x.T, train_y.T);#绘制逻辑回归分类边界plot_decision_boundary(lambda x: clf.predict(x), train_x, train_y)plt.title("Logistic Regression")#输出训练集的预测值LR_predictions = clf.predict(train_x.T)#输出准确率print ('Accuracy of logistic regression:%d ' % float((np.dot(train_y, LR_predictions) + np.dot(1-train_y, 1-LR_predictions)) / float(train_y.size)*100) +'% ' + "(percentage of correctly labelled datapoints)")#Accuracy of logistic regression:57 % (percentage of correctly labelled datapoints)可以看出逻辑回归效果并不好，这是因为逻辑回归网络结构只包含输入层和输出层，无法拟合更为复杂的模型，下面尝试神经网络模型。

4.神经网络模型下面开始搭建神经网络模型，我们采用两层神经网络实验，隐藏层包含4个节点，使用tanh激活函数；输出层包含一个节点，使用Sigmoid激活函数，结果小于0.5即认为是0，否则认为是1。1.神经网络结构下面用代码实现神经网络结构，首先确定神经网络的结构，即获取相关数据维度，并设置隐藏层节点个数（本实验设置4个隐藏层节点），用以初始化参数。#定义各层规模函数def layer_sizes(X, Y):"""参数含义:X -- 输入的数据Y -- 输出值返回值:n_x -- 输入层节点数n_h -- 隐藏层节点数n_y -- 输出层节点数"""n_x = X.shape[0] #输入层大小（节点数）n_h = 4n_y = Y.shape[0] #输出层大小（节点数）return (n_x, n_h, n_y)2.初始化模型参数获取相关维度信息后，开始初始化参数，定义相关函数。# 定义函数：初始化参数def initialize_parameters(n_x, n_h, n_y):"""参数:n_x -- 输入层大小n_h -- 隐藏层大小n_y -- 输出层大小返回值:params -- 一个包含所有参数的python字典:W1 -- （隐藏层）权重，维度是 (n_h, n_x)b1 -- （隐藏层）偏移量，维度是 (n_h, 1)W2 -- （输出层）权重，维度是 (n_y, n_h)b2 -- （输出层）偏移量，维度是 (n_y, 1)"""np.random.seed(2) # 设置随机种子#随机初始化参数W1 = np.random.randn(n_h, n_x) * 0.01b1 = np.zeros((n_h, 1))W2 = np.random.randn(n_y, n_h) * 0.01b2 = np.zeros((n_y, 1))assert (W1.shape == (n_h, n_x))assert (b1.shape == (n_h, 1))assert (W2.shape == (n_y, n_h))assert (b2.shape == (n_y, 1))parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2}return parameters3.前向传播与后向传播获取输入数据，参数初始化完成后，可以开始前向传播的计算。# 定义函数：前向传播def forward_propagation(X, parameters):"""参数:X -- 输入值 parameters -- 一个python字典，包含计算所需全部参数（是initialize_parameters函数的输出）    返回值:A2 -- 模型输出值cache -- 一个字典，包含 "Z1", "A1", "Z2" and "A2""""W1 = parameters["W1"]b1 = parameters["b1"]W2 = parameters["W2"]b2 = parameters["b2"]#计算中间量和节点值    Z1 = np.dot(W1, X) + b1A1 = np.tanh(Z1)Z2 = np.dot(W2, A1) + b2A2 = 1/(1+np.exp(-Z2))assert(A2.shape == (1, X.shape[1]))cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}return A2, cache4.前向传播最后可得出模型输出值（即代码中的A2），即可计算成本函数cost。# 定义函数：成本函数def compute_cost(A2, Y, parameters):"""根据第三章给出的公式计算成本参数:A2 -- 模型输出值    Y -- 真实值parameters -- 一个python字典包含参数 W1, b1, W2和b2返回值: cost -- 成本函数"""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 = np.squeeze(cost)                            assert(isinstance(cost, float))return cost5.计算了成本函数，可以开始后向传播的计算。# 定义函数：后向传播def backward_propagation(parameters, cache, X, Y):"""参数:parameters -- 一个python字典，包含所有参数 cache -- 一个python字典包含"Z1", "A1", "Z2"和"A2".X -- 输入值Y -- 真实值返回值: grads -- 一个python字典包含所有参数的梯度"""m = X.shape[1]#首先从"parameters" 获取 W1,W2W1 = parameters["W1"]W2 = parameters["W2"]# 从"cache"中获取A1,A2A1 = cache["A1"]A2 = cache["A2"]#后向传播: 计算dW1, db1, dW2, db2. dZ2 = A2 - YdW2 = 1. / m * np.dot(dZ2, A1.T)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)grads = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2}return grads6.通过后向传播获取梯度后，可以根据梯度下降公式更新参数。def update_parameters(parameters, grads, learning_rate = 1.2):"""使用梯度更新参数参数:parameters -- 包含所有参数的python字典 grads -- 包含所有参数梯度的python字典 返回值:parameters -- 包含更新后参数的python """#从"parameters"中读取全部参数W1 = parameters["W1"]b1 = parameters["b1"]W2 = parameters["W2"]b2 = parameters["b2"]# 从"grads"中读取全部梯度dW1 = grads["dW1"]db1 = grads["db1"]dW2 = grads["dW2"]db2 = grads["db2"]#更新参数W1 = W1 - learning_rate * dW1b1 = b1 - learning_rate * db1W2 = W2 - learning_rate * dW2b2 = b2 - learning_rate * db2parameters = {"W1": W1,  "b1": b1, "W2": W2, "b2": b2}return parameters7.神经网络模型前向传播、成本函数计算和后向传播构成一个完整的神经网络，将上述函数组合，构建一个神经网络模型。#定义函数：神经网络模型def nn_model(X, Y, n_h, num_iterations = 10000, print_cost=False):"""参数:X -- 输入值Y -- 真实值n_h -- 隐藏层大小/节点数num_iterations -- 训练次数print_cost -- 设置为True，则每1000次训练打印一次成本函数值返回值: parameters -- 训练结束，更新后的参数值    """np.random.seed(3)n_x = layer_sizes(X, Y)[0]n_y = layer_sizes(X, Y)[2]#根据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".A2, cache = forward_propagation(X, parameters)#成本计算. 输入: "A2, Y, parameters". 输出: "cost".cost = compute_cost(A2, Y, parameters)#后向传播， 输入: "parameters, cache, X, Y". 输出: "grads".grads = backward_propagation(parameters, cache, X, Y)#参数更新. 输入: "parameters, grads". 输出: "parameters".parameters = update_parameters(parameters, grads)#每1000次训练打印一次成本函数值if print_cost and i % 1000 == 0:print ("Cost after iteration %i: %f" %(i, cost))return parameters8.预测通过上述模型可以训练得出最后的参数，此时需检测其准确率，用训练后的参数预测训练的输出，大于0.5的值视作1，否则视作0。#定义函数：预测def predict(parameters, X):"""使用训练所得参数，对每个训练样本进行预测参数:parameters -- 保安所有参数的python字典 X -- 输入值返回值：predictions -- 模型预测值向量(红色: 0 / 蓝色: 1)"""#使用训练所得参数进行前向传播计算，并将模型输出值转化为预测值（大于0.5视作1，即True）A2, cache = forward_propagation(X, parameters)predictions = A2 > 0.5return predictions9.下面对获取的数据进行训练，并输出准确率# 建立神经网络模型parameters = nn_model(train_x, train_y, n_h = 4, num_iterations = 10000, print_cost=True)# 绘制分类边界plot_decision_boundary(lambda x: predict(parameters, x.T), train_x, train_y)plt.title("Decision Boundary for hidden layer size " + str(4))# 预测训练集predictions = predict(parameters, train_x)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) + '%')对比逻辑回归47%的准确率和分类结果图，神经网络分类的结果提高了不少，这是因为神经网络增加的隐藏层，为模型训练提供了更多选择，使得神经网络能拟合更加复杂的模型，对于更加复杂的图案分类更加准确。#Cost after iteration 0: 0.693049#Cost after iteration 1000: 0.272304#Cost after iteration 2000: 0.261430#Cost after iteration 3000: 0.260627#Cost after iteration 4000: 0.257842#Cost after iteration 5000: 0.255809#Cost after iteration 6000: 0.254249#Cost after iteration 7000: 0.253019#Cost after iteration 8000: 0.252028#Cost after iteration 9000: 0.251208#Train Accuracy: 90%#Test Accuracy: 89%

Paddlepaddle实现浅层神经网络实践部分将搭建神经网络，包含一个隐藏层，实验将会展现出与Logistic回归的不同之处。实验将使用两层神经网络实现对“花”型图案的分类，如图所示，图中的点包含红点（y=0）和蓝点（y=1）还有点的坐标信息，实验将通过以下步骤完成对两种点的分类，使用PaddlePaddle实现。输入样本；搭建神经网络；初始化参数；训练，包括前向传播与后向传播（即BP算法）；得出训练后的参数；根据训练所得参数，绘制两类点边界曲线。

import numpy as np
import h5pydef load_dataset():train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set featurestrain_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labelstest_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set featurestest_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labelsclasses = np.array(test_dataset["list_classes"][:]) # the list of classestrain_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes"""
用于载入数据
load_planar_dataset()函数返回训练集和测试集
"""
import matplotlib.pyplot as plt
import numpy as np
import random
import sklearn
import sklearn.datasets
import sklearn.linear_model#绘制分类结果边界
def plot_decision_boundary(model, X, y):"""绘制分类边界model: 模型X: 输入值y: 真实值"""# Set min and max values and give it some paddingx_min, x_max = X[0, : ].min() - 1, X[0, : ].max() + 1y_min, y_max = X[1, : ].min() - 1, X[1, : ].max() + 1h = 0.01# Generate a grid of points with distance h between themxx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))# Predict the function value for the whole gridZ = model(np.c_[xx.ravel(), yy.ravel()])Z = Z.reshape(xx.shape)# Plot the contour and training examplesplt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)plt.ylabel('x2')plt.xlabel('x1')plt.scatter(X[0, : ], X[1, : ], c=y, cmap=plt.cm.Spectral)#定义Sigmoid函数
def sigmoid(x):"""Compute the sigmoid of xArguments:x -- A scalar or numpy array of any size.Return:s -- sigmoid(x)"""# Sigmoid计算s = 1 / (1 + np.exp(-x))return s#加载数据
def load_planar_dataset():"""加载数据返回值：train_x:训练集的输入train_y:训练集的真实值X:测试集的输入Y:测试集的真实值"""np.random.seed(1) #设置随机种子m = 400 # number of examplesN = int(m / 2) # number of points per classD = 2 # dimensionalityX = np.zeros((m, D)) # data matrix where each row is a single exampleY = np.zeros((m, 1), dtype='uint8') # labels vector (0 for red, 1 for blue)a = 4 # maximum ray of the flowerfor j in range(2):ix = range(N * j, N * (j + 1))t = np.linspace(j * 3.12, (j + 1) * 3.12, N) + np.random.randn(N) * 0.2 # thetar = a * np.sin(4 * t) + np.random.randn(N) * 0.2 # radiusX[ix] = np.c_[r * np.sin(t), r * np.cos(t)]Y[ix] = j#测试集，取全部数据X = X.TY = Y.T#训练集train_num = random.sample(range(400),320)#共400组数据，训练集取其中80%，即320组train_x = X[: , train_num]train_y = Y[: , train_num]dataset = [train_x, train_y, X, Y]return dataset#加载其他数据
def load_extra_datasets():"""加载其它数据return:result:包含5种不同类型数据的集合"""N = 200noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3)noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2)blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6)gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2, n_classes=2, shuffle=True, random_state=None)no_structure = np.random.rand(N, 2), np.random.rand(N, 2)result = [noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure]return result

在该实验中，我们将使用PaddlePaddle实现浅层神经网络，解决识别猫的问题，使用的数据与“Paddlepaddle实现Logistic回归”中一致。
本章节代码与“PaddlePaddle实现Logistic回归”基本一致，重复内容不再赘述，区别在于增加了一层隐藏层。1.引用库首先，载入几个需要用到的库，它们分别是：numpy：一个python的基本库，用于科学计算planar_utils：定义了一些工具函数paddle.v2：paddle深度学习平台matplotlib.pyplot：用于生成图，在验证模型准确率和展示成本变化趋势时会使用到import matplotlibimport numpy as npimport paddle.v2 as paddleimport matplotlib.pyplot as pltimport planar_utilsTRAINING_SET = NoneTEST_SET = NoneDATADIM = None2. 数据预处理定义load_data()用于载入数据# 载入数据def load_data():global TRAINING_SET, TEST_SET, DATADIMtrain_set_x, train_set_y, test_set_x, test_set_y = planar_utils.load_planar_dataset()# 定义纬度，即一个样本的特征维度DATADIM = 2TRAINING_SET = np.hstack((train_set_x.T, train_set_y.T))TEST_SET = np.hstack((test_set_x.T, test_set_y.T))3.构造reader构造reader()函数来读取训练数据集TRAINING_SET和测试数据集TEST_SET，需要注意的是，yield关键字的作用类似return关键字，但不同指出在于yield关键字让reader()变成一个生成器（Generator），生成器不会创建完整的数据集列表，而是在每次循环时计算下一个值，这样不仅节省内存空间，而且符合reader的定义，也即一个真正的读取器。# 读取训练数据或测试数据，服务于train()和test()def read_data(data_set):"""一个readerArgs: data_set -- 要获取的数据集Return: reader -- 用于获取训练数据集及其标签的生成器generator"""def reader():"""一个readerReturn: data[:-1], data[-1:] -- 使用yield返回生成器(generator)，data[:-1]表示前n-1个元素，也就是训练数据，data[-1:]表示最后一个元素，也就是对应的标签"""for data in data_set:yield data[:-1], data[-1:]return reader# 获取训练数据集def train():"""定义一个reader来获取训练数据集及其标签Return: read_data -- 用于获取训练数据集及其标签的reader"""global TRAINING_SETreturn read_data(TRAINING_SET)# 获取测试数据集def test():"""定义一个reader来获取测试数据集及其标签Return: read_data -- 用于获取测试数据集及其标签的reader"""global TEST_SETreturn read_data(TEST_SET)4.配置网络结构和设置参数开始配置网络结构，这是本章与Logistic回归的不同之处，本章节实现双层神经网络，增加了一层隐藏层，隐藏层设置7个节点，激活函数使用Relu，其余不变。1.损失函数在这里使用PaddlePaddle提供的交叉熵损失函数，cost = paddle.layer.multi_binary_label_cross_entropy_cost(input=y_predict, label=y_label) 定义了成本函数，并使用y_predict与label计算成本。定义了成本函数之后，使用PaddlePaddle提供的简单接口parameters=paddle.parameters.create(cost)来创建和初始化参数。2.optimizer参数创建完成后，定义参数优化器optimizer= paddle.optimizer.Momentum(momentum=0, learning_rate=0.00002)，使用Momentum作为优化器，并设置动量momentum为零，学习率为0.00002。注意，读者暂时无需了解Momentum的含义，只需要学会使用即可。3.其它配置 feeding={‘image’:0, ‘label’:1}是数据层名称和数组索引的映射，用于在训练时输入数据。# 配置网络结构和设置参数def netconfig():"""配置网络结构和设置参数Return:image -- 输入层，DATADIM维稠密向量，每个样本的特征维度y_predict -- 输出层，Sigmoid作为激活函数y_label -- 标签数据，1维稠密向量cost -- 损失函数parameters -- 模型参数optimizer -- 优化器feeding -- 数据映射，python字典"""# 输入层，paddle.layer.data表示数据层,name=’image’：名称为image,# type=paddle.data_type.dense_vector(DATADIM)：数据类型为DATADIM维稠密向量，每个样本的特征维度image = paddle.layer.data(name='image', type=paddle.data_type.dense_vector(DATADIM))# 隐藏层，paddle.layer.fc表示全连接层，input=image: 该层输入数据为image# size=4：神经元个数，act=paddle.activation.Tanh()：激活函数为Tanh()h1 = paddle.layer.fc(input=image, size=4, act=paddle.activation.Tanh())# 输出层，paddle.layer.fc表示全连接层，input=h1: 该层输入数据为h1# size=1：神经元个数，act=paddle.activation.Sigmoid()：激活函数为Sigmoid()y_predict = paddle.layer.fc(input=h1, size=1, act=paddle.activation.Sigmoid())# 标签数据，paddle.layer.data表示数据层，name=’label’：名称为label# type=paddle.data_type.dense_vector(1)：数据类型为1维稠密向量，每个样本的标签维度y_label = paddle.layer.data(name='label', type=paddle.data_type.dense_vector(1))# 定义成本函数为 交叉熵损失函数multi_binary_label_cross_entropy_costcost = paddle.layer.multi_binary_label_cross_entropy_cost(input=y_predict, label=y_label)# 利用cost创建parametersparameters = paddle.parameters.create(cost)# 创建optimizer，并初始化momentum和learning_rate# 加入动量项Momentum，可以加速更新过程，比如当接近局部最小时，通过震荡作用，跳出局部最小继续下降到全局最小。# 训练过程在更新权重时采用动量优化器 Momentum ，比如momentum=0.9 代表动量优化每次保持前一次速度的0.9倍。optimizer = paddle.optimizer.Momentum(momentum=0, learning_rate=0.0075)# 数据层和数组索引映射，用于trainer训练时喂数据feeding = {'image': 0,'label': 1}data = [image, y_predict, y_label, cost, parameters, optimizer, feeding]return data5.训练过程接下来进入训练过程。1.初始化首先进行最基本的初始化操作，paddle.init(use_gpu=False, trainer_count=1)表示不使用gpu进行训练并且仅使用一个trainer进行训练，load_data()用于获取并预处理数据。# 初始化paddle.init(use_gpu=False, trainer_count=1)# 获取数据并预处理load_data()# 配置网络结构和设置参数image, y_predict, y_label, cost, parameters, optimizer, feeding = netconfig()# 记录成本costcosts = []2.模型训练上述内容进行了初始化并配置了网络结构，接下来利用上述配置进行模型训练。首先定义一个随机梯度下降trainer，配置三个参数cost、parameters、update_equation，它们分别表示成本函数、参数和更新公式。再利用trainer.train()即可开始真正的模型训练：paddle.reader.shuffle(train(), buf_size=5000)表示trainer从train()这个reader中读取了buf_size=5000大小的数据并打乱顺序paddle.batch(reader(), batch_size=256)表示从打乱的数据中再取出batch_size=256大小的数据进行一次迭代训练参数feeding用到了之前定义的feeding索引，将数据层image和label输入trainer，也就是训练数据的来源。参数event_handler是事件管理机制，读者可以自定义event_handler，根据事件信息作相应的操作。参数num_passes=5000表示迭代训练5000次后停止训练。def event_handler(event):"""事件处理器，可以根据训练过程的信息作相应操作Args: event -- 事件对象，包含event.pass_id, event.batch_id, event.cost等信息"""if isinstance(event, paddle.event.EndIteration):if event.pass_id % 100 == 0:print("Pass %d, Batch %d, Cost %f" % (event.pass_id, event.batch_id, event.cost))costs.append(event.cost)#with open('params_pass_%d.tar' % event.pass_id, 'w') as f:#  parameters.to_tar(f)# 构造trainer，SGD定义随机梯度下降，配置三个参数cost、parameters、update_equation，它们分别表示成本函数、参数和更新公式。trainer = paddle.trainer.SGD(cost=cost, parameters=parameters, update_equation=optimizer)"""模型训练paddle.reader.shuffle(train(), buf_size=5000)：表示trainer从train()这个reader中读取了buf_size=5000大小的数据并打乱顺序paddle.batch(reader(), batch_size=256)：表示从打乱的数据中再取出batch_size=256大小的数据进行一次迭代训练feeding：用到了之前定义的feeding索引，将数据层image和label输入trainerevent_handler：事件管理机制，可以自定义event_handler，根据事件信息作相应的操作num_passes：定义训练的迭代次数"""trainer.train(reader=paddle.batch(paddle.reader.shuffle(train(), buf_size=5000),batch_size=256),feeding=feeding,event_handler=event_handler,num_passes=10000)Pass 0, Batch 0, Cost 0.772777Pass 0, Batch 1, Cost 0.684858Pass 100, Batch 0, Cost 0.299152Pass 100, Batch 1, Cost 0.335288Pass 200, Batch 0, Cost 0.320332Pass 200, Batch 1, Cost 0.187563Pass 300, Batch 0, Cost 0.306633。。。。。。。Pass 9900, Batch 0, Cost 0.212364Pass 9900, Batch 1, Cost 0.2021013.模型检验1.模型训练完成后，接下来检验模型的准确率。首先定义get_data()函数来帮助我们读取训练数据和测试数据。# 获取datadef get_data(data_creator):"""使用参数data_creator来获取测试数据Args: data_creator -- 数据来源,可以是train()或者test()Return: result -- 包含测试数据(image)和标签(label)的python字典"""data_creator = data_creatordata_image = []data_label = []for item in data_creator():data_image.append((item[0],))data_label.append(item[1])result = {"image": data_image,"label": data_label}return result2.获得数据之后，我们就可以开始利用paddle.infer()来进行预测，参数output_layer表示输出层，参数parameters表示模型参数，参数input表示输入的测试数据。# 获取测试数据和训练数据，用来验证模型准确度train_data = get_data(train())test_data = get_data(test())# 根据train_data和test_data预测结果，output_layer表示输出层，parameters表示模型参数，input表示输入的测试数据probs_train = paddle.infer(output_layer=y_predict, parameters=parameters, input=train_data['image'])probs_test = paddle.infer(output_layer=y_predict, parameters=parameters, input=test_data['image'])3.获得检测结果probs_train和probs_test之后，我们将结果转化为二分类结果并计算预测正确的结果数量，定义calc_accuracy()分别计算训练准确度和测试准确度。# 计算准确度def calc_accuracy(probs, data):"""根据数据集来计算准确度accuracyArgs:probs -- 数据集的预测结果，调用paddle.infer()来获取data -- 数据集Return: calc_accuracy -- 训练准确度"""right = 0total = len(data['label'])for i in range(len(probs)):if float(probs[i][0]) > 0.5 and data['label'][i] == 1:right += 1elif float(probs[i][0]) < 0.5 and data['label'][i] == 0:right += 1accuracy = (float(right) / float(total)) * 100return accuracy4.调用上述两个函数并输出# 计算train_accuracy和test_accuracyprint("train_accuracy: {} %".format(calc_accuracy(probs_train, train_data)))print("test_accuracy: {} %".format(calc_accuracy(probs_test, test_data)))#train_accuracy: 90.625 %#test_accuracy: 90.75 %5.学习曲线可以输出成本的变化情况，利用学习曲线对模型进行分析。读者可以看到图中成本在刚开始收敛较快，随着迭代次数变多，收敛速度变慢，最终收敛到一个较小值。costs = np.squeeze(costs)plt.plot(costs)plt.ylabel('cost')plt.xlabel('iterations (per hundreds)')plt.title("Learning rate = 0.0075")plt.show()

PaddlePaddle 深度学习实战（第三部分）相关推荐

人工智能AI：TensorFlow Keras PyTorch MXNet PaddlePaddle 深度学习实战 part1
日萌社人工智能AI:TensorFlow Keras PyTorch MXNet PaddlePaddle 深度学习实战 part1 人工智能AI:TensorFlow Keras PyTorch ...
飞桨PaddlePaddle深度学习实战
作者:刘祥龙,杨晴虹,胡晓光,于佃海著出版社:机械工业出版社品牌:机工出版出版时间:2020-09-01 飞桨PaddlePaddle深度学习实战
PaddlePaddle深度学习实战——英法文翻译机
51CTO技术栈 " 自然语言处理[1]是计算机科学领域与人工智能领域中的另一个重要方向,其中很重要的一点就是语音识别(speech recognition).机器翻译.智能机器人. 与语言 ...
深度学习实战笔记三：编码器、解码器+mnist+kears
对matplotlib的解释 import matplotlib.pyplot as plt import numpy as np a = [[1,2]] a = np.array(a) c = a[ ...
百度官方文档Plus版，PaddlePaddle深度学习框架介绍
作者:木羊同学来源:华章计算机(hzbook_jsj) 现在深度学习框架不但内卷严重,而且头部效应明显.一提起深度学习框架,首先想到的肯定是Google家的TensorFlow,和Facebook家 ...
国产首款——飞桨PaddlePaddle深度学习框架介绍
现在深度学习框架不但内卷严重,而且头部效应明显.一提起深度学习框架,首先想到的肯定是Google家的TensorFlow,和Facebook家的PyTorch.究竟排名谁先谁后,还要看你是工业界还是学 ...
Tensorflow深度学习实战之(七)--MP神经元与BP神经网络模型
本文是在GPU版本的Tensorflow = 2.6.2 , 英伟达显卡驱动CUDA版本 =11.6,Python版本 = 3.6, 显卡为3060的环境下进行验证实验的!!! 文章目录一.M-P神 ...
CSIG AI前沿技术培训首期开讲，携手百度飞桨走进北科大开启深度学习实战
点击左上方蓝字关注我们人工智能正进入规模化落地阶段,AI人才培养需求成为重中之重.为积极推进校企人才共育,产教深度融合,6月23日,由中国图象图形学学会(CSIG)主办的「AI前沿技术培训系列」活动 ...
Keras深度学习实战（2）——使用Keras构建神经网络
Keras深度学习实战(2)--使用Keras构建神经网络 0 前言 1. Keras 简介与安装 2. Keras 构建神经网络初体验 3. 训练香草神经网络 3.1 香草神经网络与 MNIST 数 ...

PaddlePaddle 深度学习实战（第三部分）

PaddlePaddle 深度学习实战（第一部分）

PaddlePaddle 深度学习实战（第二部分）

PaddlePaddle 深度学习实战（第三部分）

PaddlePaddle 深度学习实战（第四部分）

PaddlePaddle 深度学习实战（第五部分）

浅层神经网络、BP算法(反向传播)

浅层神经网络的结构、前向传播、反向传播(BP算法)、梯度下降、激活函数(非线性函数/非线性映射)

Jupyter文件中的内容

PaddlePaddle 深度学习实战（第三部分）相关推荐

最新文章

热门文章