摘要：本文先从梯度下降法的理论推导开始，说明梯度下降法为什么能够求得函数的局部极小值。通过两个小例子，说明梯度下降法求解极限值实现过程。在通过分解BP神经网络，详细说明梯度下降法在神经网络的运算过程，并详细写出每一步的计算结果。该过程通俗易懂，有基本的高数和线代基础即可理解明白。最后通过tensorflow实现一个简单的线性回归，对照理解梯度下降法在神经网络中的应用。码字不易，转载请标明出处。该文中部分内容是研究生课堂论文内容，为避免课程论文被误解为抄袭，所用截图特意添加水印。

　　一.梯度下降法的理论推导：

二.求解一个简单的一元函数极小值

例：求函数y=（x+1）^2-1的极小值：

实现环境：python3.6

相关模块：numpy 、 matplotlib

import numpy as np

from matplotlib import pyplot as plt

def function_1d(x):

    '''

    目标函数：求目标函数的极小值

    x:自变量，标量

    返回：因变量，标量

    '''

    return (x+1)**2-1

##2.定义梯度函数

def grad_1d(x):

    '''

    :param x: 自变量，标量

    :return: 因变量，标量

    '''

    return 2*(x+1)

##3.定义迭代过程

def gradient_descent_1d(grad,current_x,learning_rate=0.0001,precision=0.0001,max_iters=10000):

    '''

    一维问题的梯度下降法

    :param grad: 目标函数的梯度

    :param current_x: 当前x值

    :param learning_rate: 学习率=η

    :param precision: 收敛精度

    :param max_iters: 最大迭代次数

    :return: 极小值

    '''

    ##创建一个空列表用于接收每次移动后的current_x

    cur_x_list = []

    cur_x_list.append(current_x)

    for i in range(max_iters):

        grad_current = grad(current_x)

        if abs(grad_current)<precision:

            break            ##梯度小于收敛精度时，视为收敛

        current_x = current_x-grad_current*learning_rate

        cur_x_list.append(current_x)

        print('第%s次迭代：x=%s'%(i,current_x))

    print('极小值点（%s,%s）'%(current_x,function_1d(current_x)))

    return cur_x_list

##4.运行返回极小值和x移动轨迹

if __name__ == '__main__':

    cur_x_list = gradient_descent_1d(grad_1d,learning_rate=0.9,current_x=13)  ##开始梯度下降，并且返回每次变化后的x，学习率=η=0.9

    cur_x_array = np.array(cur_x_list)

    cur_y_array = function_1d(cur_x_array)

    ##绘制曲线图

    plt.figure(figsize=(6,4))

    plt.subplot()

    x = cur_x_array

    y = function_1d(x)

    plt.plot(x, y, color='b', linewidth=1)

    ##绘制函数图

    x1 = np.arange(-15,15,1)

    y1 = np.array(function_1d(x1))

    plt.plot(x1, y1, color='y', linewidth=1)

    ##散点图

    plt.scatter(cur_x_array,cur_y_array,s=20,c="#ff1212",marker='o')

    plt.xlabel('梯度下降示例(汽车优化设计)',fontproperties = 'SimHei',fontsize = 10)

    plt.ylabel('y=（x+1）**2 -1',fontproperties = 'SimHei',fontsize = 10)

    plt.show()

###输出结果

第0次迭代：x=-12.2

第1次迭代：x=7.960000000000001

第2次迭代：x=-8.168000000000003

第3次迭代：x=4.734400000000003

第4次迭代：x=-5.587520000000003

第5次迭代：x=2.670016000000002

第6次迭代：x=-3.936012800000002

第7次迭代：x=1.3488102400000015

第8次迭代：x=-2.8790481920000017

第9次迭代：x=0.5032385536000015

第10次迭代：x=-2.202590842880001

第11次迭代：x=-0.03792732569599888

第12次迭代：x=-1.769658139443201

第13次迭代：x=-0.3842734884454393

第14次迭代：x=-1.4925812092436486

第15次迭代：x=-0.6059350326050811

第16次迭代：x=-1.3152519739159352

第17次迭代：x=-0.7477984208672518

第18次迭代：x=-1.2017612633061985

第19次迭代：x=-0.8385909893550412

第20次迭代：x=-1.1291272085159672

第21次迭代：x=-0.8966982331872263

第22次迭代：x=-1.082641413450219

第23次迭代：x=-0.9338868692398249

第24次迭代：x=-1.05289050460814

第25次迭代：x=-0.957687596313488

第26次迭代：x=-1.0338499229492095

第27次迭代：x=-0.9729200616406324

第28次迭代：x=-1.021663950687494

第29次迭代：x=-0.9826688394500047

第30次迭代：x=-1.0138649284399963

第31次迭代：x=-0.9889080572480029

第32次迭代：x=-1.0088735542015976

第33次迭代：x=-0.9929011566387219

第34次迭代：x=-1.0056790746890225

第35次迭代：x=-0.995456740248782

第36次迭代：x=-1.0036346078009744

第37次迭代：x=-0.9970923137592205

第38次迭代：x=-1.0023261489926236

第39次迭代：x=-0.9981390808059011

第40次迭代：x=-1.001488735355279

第41次迭代：x=-0.9988090117157767

第42次迭代：x=-1.0009527906273785

第43次迭代：x=-0.9992377674980972

第44次迭代：x=-1.0006097860015222

第45次迭代：x=-0.9995121711987822

第46次迭代：x=-1.0003902630409742

第47次迭代：x=-0.9996877895672206

第48次迭代：x=-1.0002497683462235

第49次迭代：x=-0.9998001853230212

第50次迭代：x=-1.000159851741583

第51次迭代：x=-0.9998721186067335

第52次迭代：x=-1.0001023051146132

第53次迭代：x=-0.9999181559083095

第54次迭代：x=-1.0000654752733524

第55次迭代：x=-0.9999476197813181

第56次迭代：x=-1.0000419041749455

极小值点（-1.0000419041749455,-0.9999999982440401）

Process finished with exit code 0

一元函数梯度下降法求解极小值

三.求解一个简单的二元函数的极小值

import numpy as np

from tqdm import tqdm

from matplotlib import pyplot as plt

from mpl_toolkits.mplot3d import  Axes3D

def plot_3d():

    fig = plt.figure(figsize=(12,8))

    ax = Axes3D(fig)

    x = np.arange(-3,3,0.1)

    y = np.arange(-3,3,0.1)

    ##对x,y数据执行网格化

    x,y = np.meshgrid(x,y)

    z = -(z1-2*z2)*0.1

    ax.plot_surface(x,y,z,

                    rstride=1,##retride(row)指定行的跨度

                    cstride=1,##retride(column)指定列的跨度

                    cmap='rainbow')  ##设置颜色映射

    ##设置z轴范围

    ax.set_zlim(-2,2)

    ##设置标题

    plt.title('汽车优化设计之梯度下降--目标函数',fontproperties = 'SimHei',fontsize = 20)

    plt.show()

# plot_3d()

'''二维梯度下降法'''

def func_2d_single(x,y):

    '''

    目标函数传入x,y

    :param x,y: 自变量，一维向量

    :return: 因变量，标量

    '''

    z1 = np.exp(-x**2-y**2)

    z2 = np.exp(-(x-1)**2-(y-1)**2)

    z = -(z1-2*z2)*0.5

    return z

def plot_3d():

    fig = plt.figure(figsize=(12,8))

    ax = Axes3D(fig)

    x = np.arange(-3,3,0.1)

    y = np.arange(-3,3,0.1)

    ##对x,y数据执行网格化

    x,y = np.meshgrid(x,y)

    z = func_2d_single(x,y)

    ax.plot_surface(x,y,z,

                    rstride=1,##retride(row)指定行的跨度

                    cstride=1,##retride(column)指定列的跨度

                    cmap='rainbow')  ##设置颜色映射

    ##设置z轴范围

    ax.set_zlim(-2,2)

    ##设置标题

    plt.title('汽车优化设计之梯度下降--目标函数3维图',fontproperties = 'SimHei',fontsize = 20)

    plt.show()

plot_3d()

def func_2d(xy):

    '''

    目标函数传入xy组成的数组，如[x1,y1]

    :param xy: 自变量，二维向量  （x，y）

    :return: 因变量，标量

    '''

    z1 = np.exp(-xy[0]**2-xy[1]**2)

    z2 = np.exp(-(xy[0]-1)**2-(xy[1]-1)**2)

    z = -(z1-2*z2)*0.5

    return z

def grad_2d(xy):

    '''

    目标函数的梯度

    :param xy: 自变量，二维向量

    :return: 因变量，二维向量  (分别求偏导数，组成数组返回)

    '''

    grad_x = 2*xy[0]*(np.exp(-(xy[0]**2+xy[1]**2)))

    grad_y = 2*xy[1]*(np.exp(-(xy[0]**2+xy[1]**2)))

    return np.array([grad_x,grad_y])

def gradient_descent_2d(grad, cur_xy=np.array([1, 1]), learning_rate=0.001, precision=0.001, max_iters=100000000):

    '''

    二维目标函数的梯度下降法

    :param grad: 目标函数的梯度

    :param cur_xy: 当前的x和y值

    :param learning_rate: 学习率

    :param precision: 收敛精度

    :param max_iters: 最大迭代次数

    :return: 返回极小值

    '''

    print(f"{cur_xy} 作为初始值开始的迭代......")

    x_cur_list = []

    y_cur_list = []

    for i in tqdm(range(max_iters)):

        grad_cur = grad(cur_xy)

        ##创建两个列表，用于接收变化的x，y

        x_cur_list.append(cur_xy[0])

        y_cur_list.append(cur_xy[1])

        if np.linalg.norm(grad_cur,ord=2)<precision:  ##求范数，ord=2 平方和开根

            break    ###当梯度接近于0时，视为收敛

        cur_xy = cur_xy-grad_cur*learning_rate

        x_cur_list.append(cur_xy[0])

        y_cur_list.append(cur_xy[1])

        print('第%s次迭代：x，y = %s'%(i,cur_xy))

    print('极小值 x，y = %s '%cur_xy)

    return (x_cur_list,y_cur_list)

if __name__=="__main__":

    current_xy_list = gradient_descent_2d(grad_2d)

    fig = plt.figure(figsize=(12,8))

    ax = Axes3D(fig)

    a = np.array(current_xy_list[0])

    b = np.array(current_xy_list[1])

    c = func_2d_single(a,b)

    ax.scatter(a,b,c,c='Black',s=10,alpha=1,marker='o')

    x = np.arange(-2,2,0.05)

    y = np.arange(-2,2,0.05)

    ##对x,y数据执行网格化

    x,y = np.meshgrid(x,y)

    z = func_2d_single(x,y)

    ax.plot_surface(x,y,z,

                    rstride=1,##retride(row)指定行的跨度

                    cstride=1,##retride(column)指定列的跨度

                    cmap='rainbow',

                    alpha=0.3

                    )  ##设置颜色映射

    # ax.plot_wireframe(x,y,z,)

    ##设置z轴范围

    ax.set_zlim(-2,2)

    ##设置标题

    plt.title('汽车优化设计之梯度下降--二元函数',fontproperties = 'SimHei',fontsize = 20)

    plt.xlabel('x',fontproperties = 'SimHei',fontsize = 20)

    plt.ylabel('y', fontproperties='SimHei', fontsize=20)

    plt.show()

二元函数梯度下降法求极小值

四.梯度下降法在BP神经网络中的实现过程（手动+Excel处理）

BP神经网络中的正向传播和反向传播过程。反向传播中的权重更新，就是通过梯度下降法实现的，损失函数最小化，实质也是一个最优化问题的求解。

以上就是BP神经网络的实现过程，手动+excel码字只是为了深刻理解神经网络，但这个并没有太大的实质性意义，因为这个已经是成熟的算法。

五.Tensorflow中实现简单的线性回归

深度学习大致分为四个步骤：

1.数据准备

2.模型搭建

3.迭代训练

4.使用模型

import tensorflow as tf

import numpy as np

import matplotlib.pyplot as plt

'''

说明：本实例来源于李金洪的《深度学习之Tensorflow入门、原理与进阶实战》机械工业出版社

'''

##一.数据准备

train_x = np.linspace(-1,1,100)

train_y = 2*train_x+np.random.randn(*train_x.shape)*0.3  ###y=2*x 但是加入了噪声

##显示模拟数据

plt.plot(train_x,train_y,'ro',label='original_data')

plt.legend()

plt.show()

5.1数据准备

通过函数y≈2x模拟输入数据。简单来说就是通过y=2x+随机数

5.2模型搭建

#占位符，状态变量

X= tf.placeholder('float')

Y = tf.placeholder('float')

##模型参数，权重和偏置

W= tf.Variable(tf.random_normal([1]),name='weight')

b = tf.Variable(tf.zeros([1]),name='bias')

##前向传播结构

z = tf.multiply(X,W)+b

5.2.1前向传播

##2.2 反向传播

cost =  tf.reduce_mean(tf.square(Y-z))   ##总误差，生成值与真实值的平方差

learning = 0.01                          ##学习率

optimizer = tf.train.GradientDescentOptimizer(learning).minimize(cost)  ##总误差最小化（封装好的梯度下降法）

5.2.2反向传播

##2.3训练模型

#2.3.1初始化所有变量

init = tf.global_variables_initializer()     ###权重和偏置等需要给原始值

#2.3.2定义参数

training_epochs = 20

display_step = 2

##2.3.3启动Session

with tf.Session() as sess:

    sess.run(init)

    plotdata={'batchsize':[],'loss':[]}   ##存放批次值和损失值

    ##向模型输入数据

    for epoch in range(training_epochs):

        for (x,y) in zip(train_x,train_y):

            sess.run(optimizer,feed_dict={X:x,Y:y})

        #显示训练的详细信息

        if epoch % display_step ==0:

            loss = sess.run(cost,feed_dict={X:train_x,Y:train_y})

            print("Epoch",epoch+1,'cost=',loss,'W=',sess.run(W),'b=',sess.run(b))

            if not (loss =="NA"):

                plotdata["batchsize"].append(epoch)

                plotdata["loss"].append(loss)

    print('Finished!')

    print("cost=",sess.run(cost,feed_dict={X:train_x,Y:train_y}),"W=",sess.run(W),"b=",sess.run(b))

###输出结果

'''

Epoch 1 cost= 1.9869132 W= [-0.0750566] b= [0.6703366]

Epoch 3 cost= 0.2619767 W= [1.4768808] b= [0.26081827]

Epoch 5 cost= 0.12644665 W= [1.8984009] b= [0.10219257]

Epoch 7 cost= 0.119223535 W= [2.0077329] b= [0.06028967]

Epoch 9 cost= 0.11925003 W= [2.0360081] b= [0.04944004]

Epoch 11 cost= 0.119383685 W= [2.0433202] b= [0.04663405]

Epoch 13 cost= 0.11942672 W= [2.0452104] b= [0.04590876]

Epoch 15 cost= 0.1194384 W= [2.045699] b= [0.04572121]

Epoch 17 cost= 0.11944149 W= [2.045826] b= [0.04567254]

Epoch 19 cost= 0.119442314 W= [2.0458593] b= [0.04565972]

Finished!

cost= 0.11944243 W= [2.045865] b= [0.04565755]

'''

5.2.3开启会话，进行训练

import tensorflow as tf

import numpy as np

import matplotlib.pyplot as plt

'''

说明：本实例来源于李金洪的《深度学习之Tensorflow入门、原理与进阶实战》机械工业出版社

'''

plotdata = {"batchsize":[],"loss":[]}

def moving_average(a,w=10):

    if len(a)<w:

        return a[:]

    return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]

##一.数据准备

train_x = np.linspace(-1,1,100)

train_y = 2*train_x+np.random.randn(*train_x.shape)*0.3  ###y=2*x 但是加入了噪声

##显示模拟数据

plt.plot(train_x,train_y,'ro',label='original_data')

plt.legend()

plt.show()

##二.模型搭建

##2.1正向传播

#占位符，状态变量

X= tf.placeholder('float')

Y = tf.placeholder('float')

##模型参数，权重和偏置

W= tf.Variable(tf.random_normal([1]),name='weight')

b = tf.Variable(tf.zeros([1]),name='bias')

##前向传播结构

z = tf.multiply(X,W)+b

##2.2 反向传播

cost =  tf.reduce_mean(tf.square(Y-z))   ##总误差，生成值与真实值的平方差

learning = 0.01                          ##学习率

optimizer = tf.train.GradientDescentOptimizer(learning).minimize(cost)  ##总误差最小化（封装好的梯度下降法）

##2.3训练模型

#2.3.1初始化所有变量

init = tf.global_variables_initializer()     ###权重和偏置等需要给原始值

#2.3.2定义参数

training_epochs = 20

display_step = 2

##2.3.3启动Session

with tf.Session() as sess:

    sess.run(init)

    plotdata={'batchsize':[],'loss':[]}   ##存放批次值和损失值

    ##向模型输入数据

    for epoch in range(training_epochs):

        for (x,y) in zip(train_x,train_y):

            sess.run(optimizer,feed_dict={X:x,Y:y})

        #显示训练的详细信息

        if epoch % display_step ==0:

            loss = sess.run(cost,feed_dict={X:train_x,Y:train_y})

            print("Epoch",epoch+1,'cost=',loss,'W=',sess.run(W),'b=',sess.run(b))

            if not (loss =="NA"):

                plotdata["batchsize"].append(epoch)

                plotdata["loss"].append(loss)

    print('Finished!')

    print("cost=",sess.run(cost,feed_dict={X:train_x,Y:train_y}),"W=",sess.run(W),"b=",sess.run(b))

    ###输出结果

    '''

    Epoch 1 cost= 1.9869132 W= [-0.0750566] b= [0.6703366]

    Epoch 3 cost= 0.2619767 W= [1.4768808] b= [0.26081827]

    Epoch 5 cost= 0.12644665 W= [1.8984009] b= [0.10219257]

    Epoch 7 cost= 0.119223535 W= [2.0077329] b= [0.06028967]

    Epoch 9 cost= 0.11925003 W= [2.0360081] b= [0.04944004]

    Epoch 11 cost= 0.119383685 W= [2.0433202] b= [0.04663405]

    Epoch 13 cost= 0.11942672 W= [2.0452104] b= [0.04590876]

    Epoch 15 cost= 0.1194384 W= [2.045699] b= [0.04572121]

    Epoch 17 cost= 0.11944149 W= [2.045826] b= [0.04567254]

    Epoch 19 cost= 0.119442314 W= [2.0458593] b= [0.04565972]

    Finished!

    cost= 0.11944243 W= [2.045865] b= [0.04565755]

    '''

    ##2.3.4训练模型可视化

    plt.plot(train_x,train_y,'ro',label='orignal_data')

    plt.plot(train_x,sess.run(W)*train_x+sess.run(b),label='Fittedline')

    plt.legend()

    plt.show()

    plotdata["avgloss"] = moving_average(plotdata["loss"])

    plt.figure(1)

    plt.subplot(211)

    plt.plot(plotdata["batchsize"],plotdata["avgloss"],'b--')

    plt.xlabel('Minibathc_number')

    plt.ylabel('Loss')

    plt.title('Minibarch run as vs.Training loss')

    plt.show()

5.2.4可视化训练过程（完整代码）

import tensorflow as tf

import numpy as np

import matplotlib.pyplot as plt

'''

说明：本实例来源于李金洪的《深度学习之Tensorflow入门、原理与进阶实战》机械工业出版社

'''

plotdata = {"batchsize":[],"loss":[]}

def moving_average(a,w=10):

    if len(a)<w:

        return a[:]

    return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]

##一.数据准备

train_x = np.linspace(-1,1,100)

train_y = 2*train_x+np.random.randn(*train_x.shape)*0.3  ###y=2*x 但是加入了噪声

##显示模拟数据

plt.plot(train_x,train_y,'ro',label='original_data')

plt.legend()

plt.show()

##二.模型搭建

##2.1正向传播

#占位符，状态变量

X= tf.placeholder('float')

Y = tf.placeholder('float')

##模型参数，权重和偏置

W= tf.Variable(tf.random_normal([1]),name='weight')

b = tf.Variable(tf.zeros([1]),name='bias')

##前向传播结构

z = tf.multiply(X,W)+b

##2.2 反向传播

cost =  tf.reduce_mean(tf.square(Y-z))   ##总误差，生成值与真实值的平方差

learning = 0.01                          ##学习率

optimizer = tf.train.GradientDescentOptimizer(learning).minimize(cost)  ##总误差最小化（封装好的梯度下降法）

##2.3训练模型

#2.3.1初始化所有变量

init = tf.global_variables_initializer()     ###权重和偏置等需要给原始值

#2.3.2定义参数

training_epochs = 20

display_step = 2

##2.3.3启动Session

with tf.Session() as sess:

    sess.run(init)

    plotdata={'batchsize':[],'loss':[]}   ##存放批次值和损失值

    ##向模型输入数据

    for epoch in range(training_epochs):

        for (x,y) in zip(train_x,train_y):

            sess.run(optimizer,feed_dict={X:x,Y:y})

        #显示训练的详细信息

        if epoch % display_step ==0:

            loss = sess.run(cost,feed_dict={X:train_x,Y:train_y})

            print("Epoch",epoch+1,'cost=',loss,'W=',sess.run(W),'b=',sess.run(b))

            if not (loss =="NA"):

                plotdata["batchsize"].append(epoch)

                plotdata["loss"].append(loss)

    print('Finished!')

    print("cost=",sess.run(cost,feed_dict={X:train_x,Y:train_y}),"W=",sess.run(W),"b=",sess.run(b))

    ###输出结果

    '''

    Epoch 1 cost= 1.9869132 W= [-0.0750566] b= [0.6703366]

    Epoch 3 cost= 0.2619767 W= [1.4768808] b= [0.26081827]

    Epoch 5 cost= 0.12644665 W= [1.8984009] b= [0.10219257]

    Epoch 7 cost= 0.119223535 W= [2.0077329] b= [0.06028967]

    Epoch 9 cost= 0.11925003 W= [2.0360081] b= [0.04944004]

    Epoch 11 cost= 0.119383685 W= [2.0433202] b= [0.04663405]

    Epoch 13 cost= 0.11942672 W= [2.0452104] b= [0.04590876]

    Epoch 15 cost= 0.1194384 W= [2.045699] b= [0.04572121]

    Epoch 17 cost= 0.11944149 W= [2.045826] b= [0.04567254]

    Epoch 19 cost= 0.119442314 W= [2.0458593] b= [0.04565972]

    Finished!

    cost= 0.11944243 W= [2.045865] b= [0.04565755]

    '''

    ##2.3.4训练模型可视化

    plt.plot(train_x,train_y,'ro',label='orignal_data')

    plt.plot(train_x,sess.run(W)*train_x+sess.run(b),label='Fittedline')

    plt.legend()

    plt.show()

    plotdata["avgloss"] = moving_average(plotdata["loss"])

    plt.figure(1)

    plt.subplot(211)

    plt.plot(plotdata["batchsize"],plotdata["avgloss"],'b--')

    plt.xlabel('Minibathc_number')

    plt.ylabel('Loss')

    plt.title('Minibarch run as vs.Training loss')

    plt.show()

    ##3.运用训练好的模型预测

    print("x = 0.2,z=",sess.run(z,feed_dict={X:0.2}))

    print("x = 2,z=", sess.run(z, feed_dict={X: 2}))

    '''

    预测结果：

    x = 0.2,z= [0.4100724]

    x = 2,z= [4.0627713]

    '''

5.3运用训练好的模型预测

BP神经网络反向传播之计算过程分解（详细版）的更多相关文章

  1. 神经网络训练中的Tricks之高效BP（反向传播算法）

    神经网络训练中的Tricks之高效BP(反向传播算法) 神经网络训练中的Tricks之高效BP(反向传播算法) zouxy09@qq.com http://blog.csdn.net/zouxy09 ...

  2. 人工神经网络反向传播算法（BP算法）证明推导

    为了搞明白这个没少在网上搜,但是结果不尽人意,最后找到了一篇很好很详细的证明过程,摘抄整理为 latex 如下. (原文:https://blog.csdn.net/weixin_41718085/a ...

  3. 神经网络反向传播算法&&卷积神经网络

    听一遍课程之后,我并不太明白这个算法的奇妙之处?? 为啥? 神经网络反向传播算法 神经网络的训练依靠反向传播算法,最开始输入层输入特征向量,网络层计算获得输出,输出层发现输出和正确的类号不一样,这时就 ...

  4. 前馈神经网络-反向传播(Back Propagation)公式推导走读

        构造:输入神经元个数等于输入向量维度,输出神经元个数等于输出向量维度.(x1=(1,2,3),则需要三个输入神经元)   一 前向后传播   隐层:

  5. 详细BP神经网络预测算法及实现过程实例

    1.具体应用实例.根据表2,预测序号15的跳高成绩. 表2 国内男子跳高运动员各项素质指标 序号 跳高成绩() 30行进跑(s) 立定三级跳远() 助跑摸高() 助跑4—6步跳高() 负重深蹲杠铃() ...

  6. [NN] 对于BackPropagation(BP, 误差反向传播)的一些理解

    本文大量参照 David E. Rumelhart, Geoffrey E. Hinton and Ronald J. Williams, Learning representation by bac ...

  7. 浅层神经网络 反向传播推导：MSE softmax

    基础:逻辑回归 Logistic 回归模型的参数估计为什么不能采用最小二乘法? logistic回归模型的参数估计问题不能“方便地”定义“误差”或者“残差”. 对单个样本: 第i层的权重W[i]维度的 ...

  8. 手写BP（反向传播）算法

    BP算法为深度学习中参数更新的重要角色,一般基于loss对参数的偏导进行更新. 一些根据均方误差,每层默认激活函数sigmoid(不同激活函数,则更新公式不一样) 假设网络如图所示: 则更新公式为: ...

  9. 关于 Softmax 回归的反向传播求导数过程

    对于 \(Softmax\) 回归的正向传播非常简单,就是对于一个输入 \(X\) 对每一个输入标量 \(x_i\) 进行加权求和得到 \(Z\) 然后对其做概率归一化. Softmax 示意图 下面 ...

随机推荐

  1. Codeforces 955 LR询问 多次幂处理

    A 模拟题 #include <bits/stdc++.h> #define PI acos(-1.0) #define mem(a,b) memset((a),b,sizeof(a)) ...

  2. shell中switch语法

    转载: https://blog.csdn.net/love__coder/article/details/7262160

  3. 什么是UAT

    基本概念 UAT,英文User Acceptance Test的简写,也就是用户验收测试,或用户可接受测试,系统开发生命周期方法论的一个阶段,这时相关的用户或独立测试人员根据测试计划和结果对系统进行测 ...

  4. Flutter-常用插件庫

    alibaba/flutter_boost:路由 install_plugin 2.0.0#app下载更新插件 audio_recorder: any #录音.播放 flutter_sound: ^1 ...

  5. java编写算法题格式(链表和二叉树)

    (1)链表 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; ...

  6. Python---面向对象---案例

    a = 5print(5/10)# 地板除(功能类似于数学模块当中floor()向下取整操作)print(5//10)print(a%10)b = 25print(b/10)print(b//10)p ...

  7. 【SaltStack官方版】—— EVENTS & REACTOR指南

    EVENTS & REACTOR Event System Event Bus Event types Salt Master Events Authentication events Sta ...

  8. webkit内核的浏览器常见7种分别是..

    Google Chrome Safari 遨游浏览器 3.x 搜狗浏览器 阿里云浏览器 QQ浏览器 360浏览器 ...

  9. SQL server 统计分组经计

    SUM(A.AREA) OVER ( PARTITION BY A.ItemNo, A.PARTS ,A.WIDTH,A.HEIGHT) allotQty, SUM(A.SL) OVER ( PART ...

  10. POJ 2229 sumset ( 完全背包 || 规律递推DP )

    题意 : 给出一个数 n ,问如果使用 2 的幂的和来组成这个数 n 有多少种不同的方案? 分析 :  完全背包解法 将问题抽象==>有重量分别为 2^0.2^1.2^2…2^k 的物品且每种物 ...