多层神经网络预测电池SOH值

一、原理解读及公式推导
- 1．神经网络训练运行步骤：
- 2．神经网络模型
- 3．公式推导
二、代码解读及公式对应
- 1.概述：
- 2.代码解读及公式对应：
三、结果分析及心得体会
- 1.结果分析：
- 2.心得体会：
四、完整代码及参考
- 1.完整代码
- 2.参考文章

电动汽车最近几年比较火热，不少大厂纷纷加入造车的行业，而电动汽车的电池问题是一个备受关注的问题，本文主要探讨锂离子电池的健康状况预测问题。
锂离子电池的寿命受到多方面因素的影响，比如电压电流等一些特征，那我们可以通过这些特征来估计电池的健康状况（SOH值）。
本文是采用的是多层神经网络/多层感知机的方式预测电池SOH值，构建一个四层神经网络（三个隐藏层，一个输出层），通过前向传播和反向传播，最小化代价函数，从而训练出比较契合数据集的神经网络。本文所采用数据集(点击下载)，提取码：6psc，完整代码见文末。
数据来自CLACE，数据集中给出了几组电池老化实验数据，从电压、电流中提取出来了一些健康因子（特征），模型可采用的输入特征有cc_duration，cv_duration，timeInterval ，ica_max，数据标签为SOH值。数据集中一共用到了两种电池，其中CS2电池的标称容量为1100mAh,CX2电池的标称容量为1350mAh。关于数据集可看这里。

一、原理解读及公式推导

1．神经网络训练运行步骤：

① 初始化网络参数
② 前向传播（线性部分、激活函数部分）
③ 计算代价函数
④ 反向传播（激活函数部分、线性部分）
⑤ 更新参数
⑥ 循环执行步骤②-⑤ num_iteration次（num_iteration代表迭代次数）

2．神经网络模型

假设神经网络模型有L层，则前L-1层激活函数采用tanh，最后一层采用relu或Y‘ = Z（此处Z是输出层的前向传播线性部分的结果）的直接输出激活函数（命名为direct函数）。
因为电池SOH值都是0~1的值，所以：
①当预测输出Z>=0时两种激活函数都是Y’ = Z；
②当Z<0范围时，relu：Y’=0，直接输出direct：Y’=Z<0，显然relu的输出误差更小。（但是实际上Z<0的时候很少，所以直接输出影响不大）
本文神经网络模型采用四层神经网络（即前三层隐藏层采用tanh，输出层采用relu/direct）
前向传播：

反向传播：

3．公式推导

① 前向传播：
线性部分： Zl=WlAl−1+blZ^{l}=W^{l}A^{l-1}+b^{l}Zl=WlAl−1+bl
激活函数部分：tanh:Al=tanh(Zl)tanh:A^{l}=tanh(Z^{l})tanh:Al=tanh(Zl)
relu:Al=relu(Zl)relu:A^{l}=relu(Z^{l})relu:Al=relu(Zl)
direct:Al=direct(Zl)direct:A^{l}=direct(Z^{l})direct:Al=direct(Zl)

② 代价函数：cost=(Y−Y′)2cost= (Y-Y')^{2}cost=(Y−Y′)2，差值的平方作为代价函数
③ 反向传播：

二、代码解读及公式对应

1.概述：

代码分为四部分，分别是clase_battery,MLPregression,data_dispose,dnn_utils：
clase_battery：相当于main，用训练集训练模型，然后预测训练集和测试集，可视化训练效果，此处使用了我自己实现的方法和sklearn.MLPRegression方法，用于对比效果；
MLPregression：多层神经网络训练模型，调用其中函数训练和预测；
data_dispose：数据处理部分，从文件导入数据并处理，划分训练集、测试集；
dnn_utils：包含四种激活函数的前向传播和反向传播的处理，输出前向、反向激活函数的结果;

2.代码解读及公式对应：

① clase_battery：包含两种方法：自行实现的MLPregression和sklearn.MLPRegression，
自行实现的MLPregression需要先对数据集特征X进行标准化，因为X范围很大，不适合神经网络训练，而sklearn.MLPRegression会自行标准化，只需调用。
两种方式都是先训练，然后使用训练后的模型预测训练集和测试集，然后使用mse和r2s两种方法，检验预测结果的拟合效果，然后将测试集的Y和Y’画出，通过可视化的方式检验。

② MLPregression：包含模型训练和预测两部分
模型训练：
1）参数初始化（函数initialize_parameters），根据模型的结构初始化W，b；W采用随机以正态分布方式生成矩阵，b直接设置为0

2）前向传播（函数model_forward、linear_activation_forward），根据已有的参数W，b和输入X，完成一次前向传播；
函数解读：
a．linear_activation_forward：实现一层的前向传播, 包含线性部分和激活函数部分

由图可知，线性部分是对应的是Zl=WlAl−1+blZ^{l}=W^{l}A^{l-1}+b^{l}Zl=WlAl−1+bl
而激活函数部分，根据输入的每层的激活函数不同，可以选择不同的激活函数：tanh:Al=tanh(Zl)tanh:A^{l}=tanh(Z^{l})tanh:Al=tanh(Zl)，relu:Al=relu(Zl)relu:A^{l}=relu(Z^{l})relu:Al=relu(Zl)，direct:Al=direct(Zl)direct:A^{l}=direct(Z^{l})direct:Al=direct(Zl)
计算完成之后，将A_prev、W、b、Z保存到缓存并返回
b．model_forward：

前向传播分为隐藏层和输出层的前向传播，两部分都是调用函数linear_activation_forward，不同的是隐藏层激活函数是tanh，输出层是relu。
同时将每层前向传播返回保存到缓存之中，用于反向传播时计算。

3）代价函数计算

对应的是cost = （Y-Y’）^2

4）反向传播（linear_activation_backward、model_backward），完成一次反向传播
函数解读：
a．linear_activation_backward：实现一层的反向传播，包含激活函数部分和线性部分；

由图可知，激活函数部分反向传播是计算dZ的值，根据激活函数的不同，选取对应的方式反向传播；
线性部分是计算dA_prev(前一层的输出)，dW，db
最终计算得出的结果dA_prev，dW，db作为参数返回，便于后续参数W，b的更新

b．model_backward：实现一次反向传播，分为两部分：输出层、隐藏层的反向传播；

由于输出层的输出是作为预测结果，所以使用代价函数对AL(也就是预测值Y’)求导，即dAL=2(AL-Y)，然后将dAL作为输入计算输出层的反向求导；使用relu作为反向求导激活函数；
隐藏层的dA在前向传播时已经保存在缓存中，所以直接调用即可，隐藏层激活函数求导使用的是tanh，所以反向求导也需要与之对应。
将每一层反向求导的结果保存在grads中，用于后续参数W，b更新。

5）参数更新（update_parameters）
使用梯度下降算法，反向传播时保存的grads，对W，b进行更新。

6）训练模型（L_layer_model）：整合上述五个部分的函数，根据迭代次数、学习速率迭代训练模型，直到达到迭代次数。

7）预测（predict）：根据特征X、参数完成前向传播，得到的结果作为预测结果。

③ data_dispose：将数据集中数据读取并划分训练测试集，分为data_in和dataset_in两个函数；

④ dnn_utils：包含四种激活函数的前向传播和反向传播的处理

三、结果分析及心得体会

1.结果分析：

本报告中我采用两种方法：自己实现MLPregression方法和sklearn.MLPRegression方法，然后对比预测效果。
两种方法都构建一个四层神经网络，每层神经元数分别为20，10，5，1，迭代次数为301次，学习速率为0.075，结果如下：
自行实现方法：

Sklearn库:

由于神经网络参数W一开始是随机生成的，所以每次得到的结果都会有少许差异，但大体上都是不变的。
除此之外，模型训练效果还与神经网络深度、神经元数量、迭代次数、学习速率有关，本文实现的方法这几个参数并没有进一步优化，如果进一步调整可能会得到更好的结果。

2.心得体会：

1）一开始我使用的代价函数是logistic回归的代价函数，即cost = -np.sum(np.multiply(np.log(AL),Y) + np.multiply(np.log(1 - AL), 1 - Y)) / m ，结果输出很多nan。原因是输出的结果是0~1，所以log取对数会产生很小的数，使得代码运行出错，而且logictic一般用来做分类，回归问题可以使用方差的计算公式（和最小二乘法类似）。

2）最初我并没有对输入X进行预处理，结果代价函数输出一直很大，代价函数下降到一定程度后就到达瓶颈，结果预测结果很糟糕。后来我查找了一些资料，发现是数据预处理的问题，将数据集标准化，变成正态分布的方式，结果好了很多。

四、完整代码及参考

1.完整代码

①clase_battery.py

import numpy as np
import matplotlib.pyplot as plt
from data_dispose import dataset_in
from MLPregression import *
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.neural_network import MLPRegressordef clase_regression(method):if method == 'regression_self':'''一、使用自行编写MLPRgression包，训练并预测''''''数据集导入'''X_train, X_test, Y_train, Y_test = dataset_in()'''数据集标准化'''scaler = StandardScaler()X_train = scaler.fit_transform(X_train)X_test = scaler.fit_transform(X_test)  # 只用将X标准化,X的范围很大，而Y本身就在0~1之间,不必# 将X_train, X_test, Y_train, Y_test转置,变成（4，m)、(1,m)X_train, X_test, Y_train, Y_test = X_train.T, X_test.T, Y_train.T, Y_test.T'''训练'''layers_dims = [4, 20, 10, 5, 1]  # 神经网络结构初始化, 4-layer model,layer1输入层parameters = L_layer_model(X_train, Y_train, layers_dims, learning_rate=0.075,  num_iterations=301, print_cost=True, isPlot=True)'''使用训练完成的参数预测训练集和测试集'''pred_train = predict(X_train, Y_train, parameters).reshape(Y_train.shape)  # 训练集pred_test = predict(X_test, Y_test, parameters).reshape(Y_test.shape)  # 测试集'''结果检验,使用mse和r2s方法'''# 训练集检验mse_1 = mean_squared_error(pred_train, Y_train)print("Train ERROR = ", mse_1)pred_train = np.squeeze(pred_train)Y_train = np.squeeze(Y_train)r2s_1 = r2_score(pred_train, Y_train)print("Train_r2score:", r2s_1)# print("训练集:", Y_train)# print("训练集预测:", pred_train)# 测试集检验mse_2 = mean_squared_error(pred_test, Y_test)print("Test ERROR = ", mse_2)pred_test = np.squeeze(pred_test)Y_test = np.squeeze(Y_test)r2s_2 = r2_score(pred_test, Y_test)print("Test_r2score:", r2s_2)'''结果可视化'''xx = range(0, len(Y_test.T))  # 产生范围为(0, len(Y_test.T))的range作为横轴plt.figure(figsize=(8,6))plt.scatter(xx,Y_test.T,color="red",label="Sample Point",linewidth=3)plt.plot(xx,pred_test.T,color="orange",label="Fitting Line",linewidth=2)plt.legend()plt.show()elif method == 'regression_sklearn':'''二、调用sklearn的MLPRegression包，训练并预测''''''数据集导入'''X_train, X_test, Y_train, Y_test = dataset_in()'''训练'''fit1 = MLPRegressor(hidden_layer_sizes=(20, 10, 5), activation='tanh',solver='adam',alpha=0.075,max_iter=301)print ("fitting model right now")fit1.fit(X_train,Y_train)'''预测'''pred1_train = fit1.predict(X_train)pred1_test = fit1.predict(X_test)'''计算训练集 MSE'''mse_1 = mean_squared_error(pred1_train,Y_train)print("Train ERROR = ", mse_1)r2s_1 = r2_score(pred1_train, Y_train)print("train_r2score:", r2s_1)'''计算测试集mse'''mse_2 = mean_squared_error(pred1_test,Y_test)print ("Test ERROR = ", mse_2)r2s_2 = r2_score(pred1_test, Y_test)print("train_r2score:", r2s_2)'''结果可视化'''xx = range(0, len(Y_test))# print("shape:", xx, Y_test.shape, pred1_test.shape)plt.figure(figsize=(8,6))plt.scatter(xx,Y_test,color="red",label="Sample Point",linewidth=3)plt.plot(xx,pred1_test,color="orange",label="Fitting Line",linewidth=2)plt.legend()plt.show()clase_regression('regression_self')  # 参数为regression_self(方法一)或regression_sklearn(方法二:sklearn库)

②MLPregression.py

import numpy as np
import matplotlib.pyplot as plt
from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward, tanh, tanh_backward, direct, direct_backwarddef initialize_parameters(layers):"""实现神经网络W,b的初始化参数: layers:包含输入X,每个隐藏层神经元数,输出层神经元数的列表返回: parameters:包含W1,b1,W2,b2,...的字典"""parameters = {}L = len(layers)for i in range(1,L):parameters['W'+str(i)] = np.random.randn(layers[i], layers[i-1]) / np.sqrt(layers[i-1])# 随机以正态分布方式生成矩阵,并除以该数（避免w过大导致梯度消失）parameters['b'+str(i)] = np.zeros((layers[i], 1))  # w已经随机产生(正态),b可以为0,不必随机产生导致失去对称性# 确保我要的数据的格式是正确的assert (parameters["W" + str(i)].shape == (layers[i], layers[i - 1]))assert (parameters["b" + str(i)].shape == (layers[i], 1))return parametersdef linear_activation_forward(A_prev, W, b, activation):"""实现一层的前向传播,包含线性部分和激活函数部分参数:   A_prev:本层的输入,上一层的输出,维度为(上一层的节点数量，示例的数量）W:该层到下一层的权重矩阵W,维度为（本层神经元数，前一层神经元数）b:偏向量,维度为（当前图层节点数量，1）activation:激活函数,sigmoid或tanh或relu返回:    A:本层的输出，下一层的输入cache:包含linear_cache,Z两个参数的缓存,用于反向传播"""# 线性部分，输出ZZ = np.dot(W, A_prev) + blinear_cache = (A_prev, W, b)# 激活函数部分，输出Aif activation == 'sigmoid':A, Z = sigmoid(Z)elif activation == 'tanh':A, Z = tanh(Z)elif activation == 'relu':A, Z = relu(Z)elif activation == 'direct':A, Z = direct(Z)cache = (linear_cache, Z)return A, cachedef model_forward(X, parameters):"""实现前向传播参数: X:输入  parameters:初始化的输出(W,b)返回: AL:最后的输出  caches: 包含两部分缓存列表:前L-1个cache(隐藏层） 最后一个cache(输出层)"""caches = []A = XL = len(parameters) // 2  # 只求整数的商for i in range(1,L):  # 隐藏层前向传播A_prev = AA, cache = linear_activation_forward(A_prev, parameters['W'+str(i)], parameters['b'+str(i)], 'tanh')caches.append(cache)# 输出层前向传播AL, cache = linear_activation_forward(A, parameters['W'+str(L)], parameters['b'+str(L)], 'relu')caches.append(cache)assert (AL.shape == (1, X.shape[1]))return AL, cachesdef cost_function(AL, Y):"""计算cost function参数:  AL: 预测值  Y: 真实值返回:  cost"""m = Y.shape[1]# cost = -np.sum(np.multiply(np.log(AL),Y) + np.multiply(np.log(1 - AL), 1 - Y)) / mcost = np.sum((Y - AL)**2)  # 差的平方的cost functioncost = np.squeeze(cost)assert (cost.shape == ())return costdef linear_activation_backward(dA, cache, activation="tanh"):"""一层反向传播的线性和激活函数部分参数: dA:本层的  cache:已存储的缓存,包含两部分(linear_cache:(A_prev, W, b),Z)  activation:激活函数返回:"""linear_cache, Z = cacheA_prev, W, b = linear_cache# 激活函数部分反向传播if activation == 'sigmoid':dZ = sigmoid_backward(dA, Z)elif activation == 'tanh':dZ = tanh_backward(dA, Z)elif activation == 'relu':dZ = relu_backward(dA, Z)elif activation == 'direct':dZ = direct_backward(dA, Z)# 线性部分反向传播m = A_prev.shape[1]dA_prev = np.dot(W.T, dZ)dW = np.dot(dZ, A_prev.T) / mdb = np.sum(dZ, axis=1, keepdims=True) / mreturn dA_prev, dW, dbdef model_backward(AL, Y, caches):"""实现反向传播参数: AL:输出层输出  Y  caches:包含linear_caches,Z的缓存返回: grads包含dA,dW,db的字典"""grads = {}L = len(caches)m = AL.shape[1]Y = Y.reshape(AL.shape)# 输出层反向传播# dAL = -np.divide(Y, AL) + np.divide(1-Y, 1-AL)  # np.divide对应元素相除dAL = 2*(AL - Y)  # 差的平方的cost_function导数dA_prev, dW, db = linear_activation_backward(dAL, caches[L-1], "relu")grads['dA'+str(L)], grads['dW'+str(L)], grads['db'+str(L)] = dA_prev, dW, db  # 存入grads字典# 隐藏层反向传播for i in reversed(range(L-1)):  # reversed反转其内列表/元组dA_prev, dW, db = linear_activation_backward(grads['dA'+str(i+2)], caches[i], "tanh")grads['dA'+str(i+1)], grads['dW'+str(i+1)], grads['db'+str(i+1)] = dA_prev, dW, dbreturn gradsdef update_parameters(parameters, grads, learning_rate):"""使用梯度下降算法更新参数参数: parameters: 包含W,b参数的字典  grads: 包含dA,dW,db的字典 learning_rate: 学习速率返回:"""L = len(parameters) // 2for i in range(L):parameters['W' + str(i + 1)] = parameters['W' + str(i + 1)] - learning_rate * grads['dW' + str(i + 1)]parameters['b' + str(i + 1)] = parameters['b' + str(i + 1)] - learning_rate * grads['db' + str(i + 1)]return parametersdef L_layer_model(X, Y, layers, learning_rate=0.075, num_iterations=3000, print_cost=False, isPlot=True):"""实现一个L层神经网络：[LINEAR-> tanh] *（L-1） - > LINEAR-> relu。参数： X: 输入的数据，维度为(n_x，例子数)   Y: 标签，向量，0为非猫，1为猫，维度为(1,数量)layers - 层数的向量，维度为(n_y,n_h,···,n_h,n_y)   learning_rate - 学习率num_iterations - 迭代的次数    print_cost - 是否打印成本值，每100次打印一次isPlot - 是否绘制出误差值的图谱返回：  parameters - 模型学习的参数。 然后他们可以用来预测。"""costs = []parameters = initialize_parameters(layers)for i in range(0, num_iterations):AL, caches = model_forward(X, parameters)cost = cost_function(AL, Y)grads = model_backward(AL, Y, caches)parameters = update_parameters(parameters, grads, learning_rate)# 打印成本值，如果print_cost=False则忽略if i % 100 == 0:# 记录成本costs.append(cost)# 是否打印成本值if print_cost:print("第", i, "次迭代，代价函数值为：", np.squeeze(cost))# 迭代完成，根据条件绘制图if isPlot:plt.plot(np.squeeze(costs))plt.ylabel('cost')plt.xlabel('iterations (per tens)')plt.title("Learning rate =" + str(learning_rate))plt.show()return parametersdef predict(X, y, parameters):"""预测参数： X: 测试集  y: 标签  parameters: 训练模型的参数返回： p: 给定数据集X的预测"""m = X.shape[1]n = len(parameters) // 2  # 神经网络的层数# 根据参数前向传播probas, caches = model_forward(X, parameters)return probas

③data_dispose.py

import numpy as np
import openpyxl
from sklearn.model_selection import train_test_splitdef data_in(file_path):  # 从指定路径读取文件并返回wb = openpyxl.load_workbook(file_path)sheets = wb.sheetnames# print(sheets, type(sheets))ws = wb.activex, y = [[], [], [], []], []for line in ws:x[0].append(line[1].value)x[1].append(line[2].value)x[2].append(line[3].value)x[3].append(line[4].value)y.append(line[5].value)x = np.asarray(x).Ty = np.asarray(y).reshape(ws.max_row, 1)x, y = x[1:], y[1:]return (x,y)def dataset_in():  # 从文件读取数据并整理成数组形式，并分割训练集,测试集path = 'dataset/CS2_33.xlsx'x1, y1 = data_in(path)path = 'dataset/CS2_34.xlsx'x2, y2 = data_in(path)path = 'dataset/CS2_35.xlsx'x3, y3 = data_in(path)path = 'dataset/CS2_36.xlsx'x4, y4 = data_in(path)path = 'dataset/CS2_37.xlsx'x5, y5 = data_in(path)path = 'dataset/CS2_38.xlsx'x6, y6 = data_in(path)path = 'dataset/CX2_34.xlsx'x7, y7 = data_in(path)path = 'dataset/CX2_36.xlsx'x8, y8 = data_in(path)X_CS = np.vstack((x1, x2, x3, x4, x5, x6))Y_CS = np.vstack((y1, y2, y3, y4, y5, y6))X_CX = np.vstack((x7, x8))Y_CX = np.vstack((y7, y8))# 分割训练集、测试集X_CS_train, X_CS_test, Y_CS_train, Y_CS_test = train_test_split(X_CS, Y_CS, test_size=0.2, random_state=666)X_CX_train, X_CX_test, Y_CX_train, Y_CX_test = train_test_split(X_CX, Y_CX, test_size=0.2, random_state=666)# 将CS、CX两种类别电池数据合并X_train = np.vstack((X_CS_train, X_CX_train))X_test = np.vstack((X_CS_test, X_CX_test))Y_train = np.vstack((Y_CS_train, Y_CX_train))Y_test = np.vstack((Y_CS_test, Y_CX_test))X_train, X_test, Y_train, Y_test = X_train.astype(np.float64), X_test.astype(np.float64), Y_train.astype(np.float64), Y_test.astype(np.float64)# print(X_train.shape, X_test.shape, Y_train.shape, Y_test.shape)return X_train, X_test, Y_train, Y_test

④dnn_utils.py

import numpy as npdef sigmoid(Z):"""sigmoid正向"""A = 1/(1+np.exp(-Z))cache = Zreturn A, cachedef sigmoid_backward(dA, cache):"""sigmoid反向传播"""Z = caches = 1/(1+np.exp(-Z))dZ = dA * s * (1-s)assert (dZ.shape == Z.shape)return dZdef relu(Z):"""relu正向"""A = np.maximum(0,Z)assert(A.shape == Z.shape)cache = Z return A, cachedef relu_backward(dA, cache):"""relu反向传播"""Z = cachedZ = np.array(dA, copy=True) # just converting dz to a correct object.# When z <= 0, you should set dz to 0 as well. dZ[Z <= 0] = 0assert (dZ.shape == Z.shape)return dZdef tanh(Z):""":param Z:return: A:计算结果  cache:返回Z,便于保存到缓存中,用于反向传播"""A = (np.exp(Z) - np.exp(-Z))/(np.exp(Z) + np.exp(-Z))cache = Zreturn A, cachedef tanh_backward(dA, cache):"""tanh反向传播"""Z = cachetanh = (np.exp(Z) - np.exp(-Z))/(np.exp(Z) + np.exp(-Z))dZ = dA * (1 - tanh**2)return dZdef direct(Z):"""直接返回Z 即A = Z"""A = Zcache = Zreturn A, cachedef direct_backward(dA, cache):"""反向dZ = dA"""Z = cachedZ = dAreturn dZ

2.参考文章

本文主要参考了吴恩达老师深度学习第四周作业 .

多层感知机预测电池SOH值相关推荐

多层感知机深度神经网络_使用深度神经网络和合同感知损失的能源产量预测...
多层感知机深度神经网络 in collaboration with Hsu Chung Chuan, Lin Min Htoo, and Quah Jia Yong. 与许忠传,林敏涛和华佳勇合作. ...
【ML】基于机器学习的心脏病预测研究(附代码和数据集，多层感知机模型)
写在前面: 首先感谢兄弟们的订阅,让我有创作的动力,在创作过程我会尽最大努力,保证作品的质量,如果有问题,可以私信我,让我们携手共进,共创辉煌. 之前创作过心脏病预测研究文章如下: [ML]基于机器学 ...
TensorFlow实现多层感知机函数逼近
TensorFlow实现多层感知机函数逼近准备工作对于函数逼近,这里的损失函数是 MSE.输入应该归一化,隐藏层是 ReLU,输出层最好是 Sigmoid. 下面是如何使用 MLP 进行函数逼近的 ...
python 底层实现_用Python从底层实现一个多层感知机
在上一篇文章中,我们从数学理论对多层感知机的反向传播进行了推导.南柯一梦宁沉沦:神经网络中反向传播算法数学推导zhuanlan.zhihu.com 这一篇文章中我们将基于上一篇文章最后给出的算法使用 ...
DL之Perceptron：Perceptron感知器(感知机/多层感知机/人工神经元)的简介、原理、案例应用(相关配图)之详细攻略
DL之Perceptron:Perceptron感知器(感知机/多层感知机/人工神经元)的简介.原理.案例应用(相关配图)之详细攻略目录 Perceptron的简介.原理多层感知机实现代码案例 ...
TensorFlow HOWTO 4.2 多层感知机回归（时间序列）
4.2 多层感知机回归(时间序列) 这篇教程中,我们使用多层感知机来预测时间序列,这是回归问题. 操作步骤导入所需的包. import tensorflow as tf import numpy a ...
TensorFlow HOWTO 4.1 多层感知机（分类）
4.1 多层感知机(分类) 这篇文章开始就是深度学习了.多层感知机的架构是这样: 输入层除了提供数据之外,不干任何事情.隐层和输出层的每个节点都计算一次线性变换,并应用非线性激活函数.隐层的激活函数是 ...
花书+吴恩达深度学习（一）前馈神经网络（多层感知机 MLP）
目录 0. 前言 1. 每一个神经元的组成 2. 梯度下降改善线性参数 3. 非线性激活函数 4. 输出单元 4.1. 线性单元 4.2. sigmoid 单元 4.3. softmax 单元 5. ...
TensorFlow实现多层感知机
一.感知机的简介在前面我们实现了一个softmax regression,也可以说是一个多分类问题的logistic regression.它和传统意义上的神经网络最大的区别就是没有隐藏层.在一个神 ...

多层感知机预测电池SOH值