精华内容
下载资源
问答
  • 神经网络拟合二次曲面,涉及到神经网络结构定义、前向传播、后向传播等,代码实现完整,一键运行,供大家学习使用,有问题可以联系博主。
  • 对于一个二元非线性函数z=f(x,y),构建神经网络并对其进行训练,使其在定义域内对此二元函数进行拟合。主函数是bp2.py,配好环境解压后直接打开运行即可,现在是迭代20次,如果需要换函数,修改21行的z[j][i]
  • 神经网络拟合二元函数曲面实践

    千次阅读 2020-11-03 17:33:05
    Andrew Ng 深度学习课程的第一周第三次作业是实现一个浅层神经网络,课程方给的框架很有意思,但该作业的输出是类别,我想实践一下该网络能否改造用来解决回归问题,具体而言是拟合一个函数z = x2+y2 ,尝试之后发现...

    简介

    Andrew Ng 深度学习课程的第一周第三次作业是实现一个浅层神经网络,课程方给的框架很有意思,但该作业的输出是类别,我想实践一下该网络能否改造用来解决回归问题,具体而言是拟合一个函数z = x2+y2 ,尝试之后发现效果不是很稳定,容易收敛到局部极小值,但拟合效果大体上还能接受,简要分享,后续准备改用随机梯度下降方法来跳出局部极小值。

    神经网络结构

    因为是二元函数,所以输入层维度固定为2,输出层维度为1,输出层未采用激活函数,隐藏层只用了一层,设置了20个神经元,激活函数为tanh。误差函数使用均方误差函数,学习率设置为0.2。

    拟合效果

    绿色点是原始曲面,红色点是拟合曲面。
    在这里插入图片描述
    这样看可能看不出拟合的效果,放一张单独只有拟合曲面的图。

    展开全文
  • 采用神经网络拟合一个简单的二元函数,作为一个入门程序。希望能有些帮助。 import numpy as np import matplotlib.pyplot as plt import random import torch from torch.nn import functional as F class Neuro_...

    采用神经网络拟合一个简单的二元函数,作为一个入门程序。希望能有些帮助。

    如果感觉算力不够用了,或者心疼自己电脑了!
    可以用我实验室的算力,试试呢!
    害,谁叫我的算力都用不完呢!
    支持所有框架!实际上框架都配置好了!
    傻瓜式云计算!
    Tesla v100 1卡,2卡,4卡,8卡
    内存16-128G
    cpu:8-24核
    想要?加个微信:15615634293
    或者点这里,找我!
    欢迎打扰!
    import numpy as np
    import matplotlib.pyplot as plt
    import random
    import torch
    from torch.nn import functional as F
    
    class Neuro_net(torch.nn.Module):
        """搭建神经网络"""
        def __init__(self):
            super(Neuro_net, self).__init__()   # 继承__init__功能
            self.hidden_layer1 = torch.nn.Linear(2, 100)
            self.hidden_layer2 = torch.nn.Linear(100, 100)
            self.output_layer = torch.nn.Linear(100, 1)
    
        def forward(self, x):
            x = self.hidden_layer1(x)
            x = F.relu(x)
            c = x
            for i in range(3):
                x = self.hidden_layer2(x)
                x = F.relu(x)
    
            pridect_y = self.output_layer(x)
            return pridect_y
    
    train_data = np.zeros((10000,3))
    for i in range(10000):
        train_data[i][0] = random.uniform(-1, 1)
        train_data[i][1] = random.uniform(-1, 1)
        train_data[i][2] = train_data[i][0]**2 + train_data[i][1]**2
    x_data = train_data[:, 0:2]
    y_data = train_data[:, 2].reshape(10000, 1)
    print(x_data.shape, y_data.shape)
    
    net = Neuro_net()
    # optimizer 优化
    optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
    # loss funaction
    loss_funaction = torch.nn.MSELoss()
    epoch = 500
    x_data = torch.tensor(x_data, dtype=torch.float32)
    y_data = torch.tensor(y_data, dtype=torch.float32)
    
    
    plt.ion()
    for step in range(epoch):
        pridect_y = net(x_data)  # 喂入训练数据 得到预测的y值
        loss = loss_funaction(pridect_y, y_data)  # 计算损失
    
        optimizer.zero_grad()    # 为下一次训练清除上一步残余更新参数
        loss.backward()          # 误差反向传播,计算梯度
        optimizer.step()         # 将参数更新值施加到 net 的 parameters 上
    
        if step % 100 == 0:
            print("已训练{}步 | loss:{}.".format(step, loss))
            plt.cla()
            ax = plt.subplot(111, projection='3d')
            ax.scatter(x_data[:, 0], x_data[:, 1], y_data, c='g')
            ax.scatter(x_data[:, 0], x_data[:, 1], pridect_y.data.numpy(), c='r')
            plt.pause(0.1)
    
    
    plt.ioff()
    plt.show()
    
    test_data = np.zeros((2000, 4))
    for i in range(2000):
        test_data[i][0] = random.uniform(-1, 1)
        test_data[i][1] = random.uniform(-1, 1)
        test_data[i][2] = test_data[i][0]**2 + test_data[i][1]**2
        
    x_test = test_data[:, 0:2]
    x_test = torch.tensor(x_test, dtype=torch.float32)
    y_test = net(x_data)
    
    ax = plt.subplot(111, projection='3d')
    ax.scatter(x_data[:, 0].data.numpy(), x_data[:, 1].data.numpy(), y_test[:, 0].data.numpy(), c='r')
    plt.show()
    

    程序运行过程

    在这里插入图片描述
    图片截的不好,凑合着看吧。

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 从实践看神经网络拟合任何函数

    万次阅读 2019-04-18 16:09:12
    1 理论 理论部分看 Multilayer...总的来说就是,多层神经网络在任意的的隐层节点和专属压缩函数(看做非线性激活函数),能够逼近任意Borel 测量函数. 2 实践 import numpy as np import matplotlib.pyplot as p...

    1. 理论

    理论部分看 Multilayer Feedforward Networks are
    Universal Approximators
    , 公式比较繁琐,英文看起来晦涩。

    总的来说就是,多层神经网络在任意的的隐层节点和专属压缩函数(看做非线性激活函数),能够逼近任意Borel 测量函数.

    2. 实践

    首先实现一个有多层线性层组成的神经网络:

    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import keras
    from keras.models import Sequential
    from keras.layers import Dense,Dropout
    from keras.optimizers import RMSprop
    
    np.random.seed(1)
    x1 = 2*np.random.normal(size = (1000))
    np.random.seed(10)
    x2 = np.random.normal(size = (1000))
    x = np.array((x1,x2)).T
    y = x1**2 + 2*x2**2 -0.2*np.cos(3*np.pi*x1) -0.4*np.cos(4*np.pi*x2)
    y = y.reshape(y.shape[0], 1)
    
    def standard(data):
        mu = np.mean(data)
        std = np.std(data)
        return (data - mu)/std
    x_scale = standard(x)
    
    model = Sequential()
    model.add(Dense(100, activation = 'linear', input_shape = (2,)))
    model.add(Dense(50, activation = 'linear'))
    model.add(Dense(50, activation = 'linear'))
    model.add(Dense(10, activation = 'linear'))
    model.add(Dense(1, activation = 'linear'))
    model.summary()
    
    model.compile(loss = 'mse', optimizer = RMSprop(),)
    model.fit(x_scale, y, batch_size = 64, epochs = 1000, verbose =0 )
    y_hap = model.predict(x_scale)
    print(np.sum(np.square(y-y_hap)))
    plt.plot(np.arange(len(y)),y,'r')
    plt.plot(np.arange(len(y_hap)),y_hap,'g')
    plt.legend(loc = 'best')
    plt.show()
    

    结果: MSE:40648。
    在这里插入图片描述

    结果很差。

    结论

    如果激活函数是线性的,模型没有拟合任意函数的能力。

    如果采用 sigmoid 作为压缩函数:

    model = Sequential()
    model.add(Dense(20, activation = 'sigmoid', input_shape = (2,)))
    #model.add(Dropout(0.2))
    model.add(Dense(20, activation = 'sigmoid'))
    #model.add(Dropout(0.2))
    model.add(Dense(1, activation = 'linear'))
    model.summary()
    

    结果:
    mse:188
    在这里插入图片描述

    即使只使用一个非线性激活函数 relu,也有不错效果:

    model = Sequential()
    model.add(Dense(100, activation = 'linear', input_shape = (2,)))
    model.add(Dense(50, activation = 'linear'))
    model.add(Dense(50, activation = 'linear'))
    model.add(Dense(10, activation = 'relu'))
    model.add(Dense(1, activation = 'linear'))
    model.summary()
    

    结果:
    mse:468
    在这里插入图片描述

    结论:

    神经网络的激活函数至少需要一个是压缩函数,才能具有较好的拟合能力。


    参考:

    1. 知乎问题 神经网络为什么可以(理论上)拟合任何函数?
    2. 知乎 神经网络的激活函数都采用非线性函数,如阈值型或S型,为何不采用线性激活函数呢?
    展开全文
  • python 神经网络拟合二输入函数

    千次阅读 2020-10-31 22:14:40
    自选二元非线性函数,例如z=f(x,y)z=f(x,y)z=f(x,y),构建神经网络并对其进行训练,使其在定义域内对此二元函数进行拟合。 \section{问题分析} 选定二元非线性函数为: z=sin⁡x+0.01eyz= \sin x+0.01e^y z=sinx+0.01...

    问题

    自选二元非线性函数,例如 z = f ( x , y ) z=f(x,y) z=f(x,y),构建神经网络并对其进行训练,使其在定义域内对此二元函数进行拟合。
    \section{问题分析}
    选定二元非线性函数为:
    z = sin ⁡ x + 0.01 e y z= \sin x+0.01e^y z=sinx+0.01ey x ∈ [ 0 , 6 ] , y ∈ [ 0 , 6 ] x\in [0,6],y\in [0,6] x[0,6],y[0,6]

    本题是神经网络类题目,虽然 M A T L A B MATLAB MATLAB有专为神经网络设计的库和工具箱,也有很多前辈在使用,但是大多是由于前期 p y t h o n python python的库还不健全所以使用的 M A T L A B MATLAB MATLAB。近年来随着 p y t h o n python python的发展,越来越多的库被添加进来, p y t h o n python python的生态已经非常完备。加之 p y t h o n python python开源,无需担心可能由政治原因带来的 M A T L A B MATLAB MATLAB版权问题。所以本次作业尝试选择使用 p y t h o n python python完成。

    整个作业完成的流程是:

    提出问题、问题分析、基础学习、问题再次分析、解决问题。

    基础学习

    先从基础的单输入单输出 ( S I S O ) (SISO) (SISO)神经网络来解决,若基础问题解决了再深入研究多输入神经网络,继而解决题目中的非线性函数拟合问题。

    为了获得较强的非线性特征,选取了函数 y = sin ⁡ x + 0.01 e x y=\sin x+0.01e^x y=sinx+0.01ex进行拟合。函数图像如图
    在这里插入图片描述

    神经网络设置

    由题意,神经网络的输入层设置一个单输入、5输出的神经元,输入与输出相等,即权重为1,阈值为0,使用 s i g n sign sign函数进行激发。中间层设置5个神经元,网络构成如图\ref{单输入拓扑}所示的结构。由图示可以分析出中间层神经元输入有5个权重,即 w 11 ( 1 ) , w 12 ( 1 ) , w 13 ( 1 ) , w 14 ( 1 ) , w 15 ( 1 ) w_{11}^{(1)},w_{12}^{(1)},w_{13}^{(1)},w_{14}^{(1)},w_{15}^{(1)} w11(1),w12(1),w13(1),w14(1),w15(1)。阈值定义为 B 1 B1 B1,是一个数组,维数为5。输出层为一个5输入单输出的神经元,输入有5个权重,即 w 1 ( 2 ) , w 2 ( 2 ) , w 3 ( 2 ) , w 4 ( 2 ) , w 5 ( 2 ) w_{1}^{(2)},w_{2}^{(2)},w_{3}^{(2)},w_{4}^{(2)},w_{5}^{(2)} w1(2),w2(2),w3(2),w4(2),w5(2),阈值定义为 B 2 B2 B2,是一个数组,维数为5。

    对于输入层,输入即为输出。

    对于隐层,输入 h i d e _ i n = x ⋅ w − b hide\_in=x\cdot w-b hide_in=xwb,输出 h i d e _ o u t = f ( h i d e _ i n ) hide\_out=f(hide\_in) hide_out=f(hide_in)其中 f f f为激发函数,在选择上具有一定的随机性,选择S型函数 S i g m o i d Sigmoid Sigmoid作为激发函数,因为S型函数具有输出范围有限、易于求导等特点,计算量小,结果不易发散,且编程简单。所以:
    在这里插入图片描述

    $$	sighide\_out&=sigmoid(hide\_in) \notag\\=\frac{1}{1+e^{-(hide\_in)}}$$
    

    对于输出层,只有一个5输入、单输出的神经元,将权重表示为向量形式 W 2 ( 5 × 1 ) W2_{(5\times 1)} W2(5×1),则 y _ o u t = h i d e _ o u t ( 1 × 5 ) ⋅ W 2 ( 5 × 1 ) − B 2 ( 1 × 1 ) y\_out = hide\_out_{(1\times 5)}\cdot W2_{(5\times 1)}- B2_{(1\times 1)} y_out=hide_out(1×5)W2(5×1)B2(1×1)

    误差

    误差计算公式为: e = y _ o u t − y [ i ] e = y\_out - y[i] e=y_outy[i],其中 y [ i ] y[i] y[i]为每个训练样本的实际值。

    反向修正

    神经网络的一大特点即为可以反复修正,通过误差的大小自动调整拟合模型,最终无限接近于样本。
    训练的目标为各个输入的权重和神经元的阈值。首先按照式 d B 2 = − t h r e s h o l d ⋅ e d W 2 = e ⋅ t h r e s h o l d ⋅ h i d e _ o u t dB2 = -threshold \cdot e \\ dW2 = e \cdot threshold \cdot hide\_out dB2=thresholdedW2=ethresholdhide_out

    最后修正中间层(输入层没有可改变的权重与阈值,所以不需要修正),如式\ref{单输入中间层修正}。其中, s i g m o i d ( h i d e _ i n ) ⋅ ( 1 − s i g m o i d ( h i d e _ i n ) ) sigmoid(hide\_in)\cdot (1 - sigmoid(hide\_in)) sigmoid(hide_in)(1sigmoid(hide_in)) s i g m o i d ( h i d e _ i n ) sigmoid(hide\_in) sigmoid(hide_in)的导数。
    d B 1 = W 2 ⋅ s i g m o i d ( h i d e _ i n ) ⋅ ( 1 − s i g m o i d ( h i d e _ i n ) ) ⋅ − e ⋅ t h r e s h o l d W 1 = W 2 ⋅ s i g m o i d ( h i d e _ i n ) ⋅ ( 1 − s i g m o i d ( h i d e _ i n ) ) ⋅ x ⋅ e ⋅ t h r e s h o l d dB1 = W2 \cdot sigmoid(hide\_in)\cdot (1 - sigmoid(hide\_in)) \cdot -e \cdot threshold \\ W1 = W2 \cdot sigmoid(hide\_in)\cdot (1 - sigmoid(hide\_in)) \cdot x \cdot e \cdot threshold dB1=W2sigmoid(hide_in)(1sigmoid(hide_in))ethresholdW1=W2sigmoid(hide_in)(1sigmoid(hide_in))xethreshold

    最后将用W和B减去对应的改变值dW和dB,即可得到新的权值和阈值,由循环语句进行循环迭代即可,如式\ref{四个式子}。
    W 1 = W 1 − d W 1 B 1 = B 1 − d B 1 W 2 = W 2 − d W 2 B 2 = B 2 − d B 2 W1 = W1 - dW1\\ B1 = B1 - dB1\\ W2 = W2 - dW2\\ B2 = B2 - dB2\\ W1=W1dW1B1=B1dB1W2=W2dW2B2=B2dB2

    程序编写与结果输出

    编写如下程序:

    # edit by JBR,2020年10月31日
    import numpy as np
    import math
    import matplotlib.pyplot as plt
    x = np.linspace(0, 6, 30)
    x_size = x.size
    y = np.zeros((x_size, 1))
    for i in range(x_size):
        y[i] = math.sin(x[i])+0.01*math.e**x[i]  # 被拟合函数
    hidesize = 5  # 隐层数量
    W1 = np.random.random((hidesize, 1))  # 输入层与隐层之间的权重
    B1 = np.random.random((hidesize, 1))  # 隐含层神经元的阈值
    W2 = np.random.random((1, hidesize))  # 隐含层与输出层之间的权重
    B2 = np.random.random((1, 1))  # 输出层神经元的阈值
    threshold = 0.005  # 迭代速度
    max_steps = 5000  # 迭代最高次数,超过此次数即会退出
    def sigmoid(x_):
        y_ = 1 / (1 + math.exp(-x_))
        return y_
    E = np.zeros((max_steps, 1))  # 误差随迭代次数的变化
    Y = np.zeros((x_size, 1))  # 模型的输出结果
    for k in range(max_steps):   # k是会自加的,傻了傻了,找了半天的k=k+1
        temp = 0
        for i in range(x_size):
            hide_in = np.dot(x[i], W1) - B1  # 隐含层输入数据,W1,hidesize行,1列
            # print(x[i])
            hide_out = np.zeros((hidesize, 1))  # hide_out是隐含层的输出数据,这里初始化
            for j in range(hidesize):
                hide_out[j] = sigmoid(hide_in[j])  # 计算hide_out
            y_out = np.dot(W2, hide_out) - B2  # 模型输出
            Y[i] = y_out
            # print(i,Y[i])
            e = y_out - y[i]  # 模型输出减去实际结果。得出误差
            ##反馈,修改参数
            dB2 = -1 * threshold * e
            dW2 = e * threshold * np.transpose(hide_out)
            dB1 = np.zeros((hidesize, 1))
            for j in range(hidesize):
                dB1[j] = np.dot(np.dot(W2[0][j], sigmoid(hide_in[j])), (1 - sigmoid(hide_in[j])) * (-1) * e * threshold)
                # np.dot((sigmoid(hide_in[j])), (1 - sigmoid(hide_in[j])))为sigmoid(hide_in[j])的导数
            dW1 = np.zeros((hidesize, 1))
            for j in range(hidesize):
                dW1[j] = np.dot(np.dot(W2[0][j], sigmoid(hide_in[j])), (1 - sigmoid(hide_in[j])) * x[i] * e * threshold)
            W1 = W1 - dW1
            B1 = B1 - dB1
            W2 = W2 - dW2
            B2 = B2 - dB2
            temp = temp + abs(e)
        E[k] = temp
        if k % 50 == 0:
            print(k)
    plt.figure()
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    plt.xlabel("x")
    plt.ylabel("y,Y")
    plt.title('y=sinx+0.01e^x')
    plt.plot(x, y)
    plt.plot(x, Y, color='red', linestyle='--')
    plt.show()
    

    程序运行结果如图
    在这里插入图片描述

    可以看出来一定的拟合效果,但是效果不佳,将迭代次数由5000次加至20000次(即第15行 m a x s t e p s = 5000 max_steps = 5000 maxsteps=5000改成 m a x s t e p s = 5000 max_steps = 5000 maxsteps=5000),效果如图\ref{y图像拟合20000次}。已经可以很好地拟合原函数,实验成功。

    问题再次分析

    至此,单输入单输出系统已经成功拟合,但是如果需要修改成针对多输入系统的拟合程序,在维度方面需要仔细改动。

    多输入单输入函数即使用题目中定义的二元非线性函数。

    神经网络设置

    由题意,神经网络的输入层设置2个单输入、5输出的神经元组,输入与输出相等,即权重为1,阈值为0,使用 s i g n sign sign函数进行激发。中间层设置7个神经元,输出层为一个7输入单输出的神经元,网络构成如图\ref{2输入拓扑}所示的结构。由图示可以分析出中间层神经元输入有7个权重,即:

    w 11 ( 1 ) , w 12 ( 1 ) , w 13 ( 1 ) , w 14 ( 1 ) , w 15 ( 1 ) , w 16 ( 1 ) , w 17 ( 1 ) ; w 21 ( 1 ) , w 22 ( 1 ) , w 23 ( 1 ) , w 24 ( 1 ) , w 25 ( 1 ) , w 26 ( 1 ) , w 27 ( 1 ) w_{11}^{(1)},w_{12}^{(1)},w_{13}^{(1)},w_{14}^{(1)},w_{15}^{(1)},w_{16}^{(1)},w_{17}^{(1)};w_{21}^{(1)},w_{22}^{(1)},w_{23}^{(1)},w_{24}^{(1)},w_{25}^{(1)},w_{26}^{(1)},w_{27}^{(1)} w11(1),w12(1),w13(1),w14(1),w15(1),w16(1),w17(1);w21(1),w22(1),w23(1),w24(1),w25(1),w26(1),w27(1)

    阈值定义为 B 1 B1 B1,是一个数组,维数为5。输出层为一个5输入单输出的神经元,输入有5个权重,即 w 1 ( 2 ) , w 2 ( 2 ) , w 3 ( 2 ) , w 4 ( 2 ) , w 5 ( 2 ) , w 6 ( 2 ) , w 7 ( 2 ) w_{1}^{(2)},w_{2}^{(2)},w_{3}^{(2)},w_{4}^{(2)},w_{5}^{(2)},w_{6}^{(2)},w_{7}^{(2)} w1(2),w2(2),w3(2),w4(2),w5(2),w6(2),w7(2),阈值定义为 B 2 B2 B2,是一个数组,维数为7。
    \begin{figure}[!htbp]\centering\includegraphics[width=0.8\textwidth]{tope2.pdf}\caption{2输入单输出神经网络示意图}\label{2输入拓扑}\end{figure}\subsubsection{正向网络}

    对于输入层,输入即为输出。

    对于隐层,输入 h i d e _ i n = ( x , y ) × w − b hide\_in=(x,y)\times w-b hide_in=(x,y)×wb,输出 h i d e o u t = f ( h i d e i n ) hide_out=f(hide_in) hideout=f(hidein)其中 f f f为激发函数,在选择上具有一定的随机性,依然选择S型函数 S i g m o i d Sigmoid Sigmoid作为激发函数。

    对于输出层,只有一个5输入、单输出的神经元,将权重表示为向量形式 W 2 ( 7 × 1 ) W2_{(7\times 1)} W2(7×1),则 y _ o u t = h i d e _ o u t ( 1 × 7 ) ⋅ W 2 ( 7 × 1 ) − B 2 ( 1 × 1 ) y\_out = hide\_out_{(1\times 7)}\cdot W2_{(7\times 1)}- B2_{(1\times 1)} y_out=hide_out(1×7)W2(7×1)B2(1×1)
    \subsubsection{误差}
    误差计算公式为: e = z _ o u t − z [ j ] [ i ] e = z\_out - z[j][i] e=z_outz[j][i],其中 z [ j ] [ i ] z[j][i] z[j][i] y [ j ] 和 x [ i ] 下 z = sin ⁡ x + 0.01 e y y[j]\text{和}x[i]\text{下}z=\sin x+0.01e^y y[j]x[i]z=sinx+0.01ey对应的每个训练样本的实际值。

    反向修正

    按照式\ref{2输入最后一层修正}从输出层开始修正,其中:
    d B 2 = − t h r e s h o l d ⋅ e d W 2 = e ⋅ t h r e s h o l d ⋅ h i d e _ o u t dB2 = -threshold \cdot e \\ dW2 = e \cdot threshold \cdot hide\_out dB2=thresholdedW2=ethresholdhide_out

    再修正中间层,如式\ref{2输入中间层修正}。
    d B 1 = W 2 , s i g m o i d ( h i d e i n ) ⋅ ( 1 − s i g m o i d ( h i d e i n [ m ] ) ) − e ⋅ t h r e s h o l d ) d W 1 y = ( W 2 ⋅ s i g m o i d ( h i d e i n ) ⋅ ( 1 − s i g m o i d ( h i d e i n ) ⋅ y ⋅ e ⋅ t h r e s h o l d W 1 y = W 1 y − d W 1 y d W 1 x = W 2 ⋅ s i g m o i d ( h i d e i n ) ⋅ ( 1 − s i g m o i d ( h i d e i n ) ⋅ x ⋅ e ⋅ t h r e s h o l d W 1 x = W 1 x − d W 1 x dB1= W2, sigmoid(hide_in)\cdot (1 - sigmoid(hide_in[m]))- e \cdot threshold)\\ dW1y = (W2\cdot sigmoid(hide_in)\cdot (1 - sigmoid(hide_in)\cdot y\cdot e \cdot threshold \\ W1y = W1y - dW1y \\ dW1x = W2 \cdot sigmoid(hide_in) \cdot (1 - sigmoid(hide_in)\cdot x \cdot e \cdot threshold \\ W1x = W1x - dW1x \\ dB1=W2,sigmoid(hidein)(1sigmoid(hidein[m]))ethreshold)dW1y=(W2sigmoid(hidein)(1sigmoid(hidein)yethresholdW1y=W1ydW1ydW1x=W2sigmoid(hidein)(1sigmoid(hidein)xethresholdW1x=W1xdW1x

    式\ref{2输入中间层修正}和式\ref{单输入中间层修正},区别在于因为维度不同所以在修正时需要添加语句,对x输入和y输入带来的权重单独修正。

    程序编写与结果输出

    # edit by JBR,2020年10月31日
    import numpy as np
    import math
    import matplotlib.pyplot as plt
    import pylab as pl
    import mpl_toolkits.mplot3d
    x = np.linspace(0, 6, 13)
    y = np.linspace(0, 6, 13)
    [X, Y] = np.meshgrid(x, y)
    x_size = x.size
    y_size = y.size
    z = np.zeros((y_size, x_size))
    for i in range(x_size):
        for j in range(y_size):
            z[j][i] = math.sin(x[i]) + 0.01 * math.e ** y[j]
            # z[i][j] = math.sin(x[i]) + 0.01
    hidesize = 7  # 隐层数量
    W1x = np.random.random((hidesize, 1))  # 输入层与隐层之间的权重
    W1y = np.random.random((hidesize, 1))  # 输入层与隐层之间的权重
    B1 = np.random.random((hidesize, 1))  # 隐含层神经元的阈值
    W2 = np.random.random((1, hidesize))  # 隐含层与输出层之间的权重
    B2 = np.random.random((1, 1))  # 输出层神经元的阈值
    threshold = 0.007  # 迭代速度
    max_steps = 20  # 迭代最高次数,超过此次数即会退出
    def sigmoid(x_):  # 这里x_和y_在函数里面,不需要改
        y_ = 1 / (1 + math.exp(-x_))
        return y_
    E = np.zeros((max_steps, 1))  # 误差随迭代次数的变化
    Z = np.zeros((x_size, y_size))  # 模型的输出结果
    for k in range(max_steps):
        temp = 0
        for i in range(x_size):
            for j in range(y_size):
                hide_in = np.dot(x[i], W1x) + np.dot(y[j], W1y) - B1  # 隐含层输入数据
                # print(x[i])
                hide_out = np.zeros((hidesize, 1))  # 隐含层的输出数据
                for m in range(hidesize):
                    hide_out[m] = sigmoid(hide_in[m])  # 计算hide_out
                    z_out = np.dot(W2, hide_out) - B2  # 模型输出
                Z[j][i] = z_out
                e = z_out - z[j][i]  # 模型输出减去实际结果。得出误差
                # 反馈,修改参数
                dB2 = -1 * threshold * e
                dW2 = e * threshold * np.transpose(hide_out)
                dB1 = np.zeros((hidesize, 1))
                for m in range(hidesize):
                    dB1[m] = np.dot(np.dot(W2[0][m], sigmoid(hide_in[m])), (1 - sigmoid(hide_in[m])) * (-1) * e * threshold)
                dW1x = np.zeros((hidesize, 1))
                dW1y = np.zeros((hidesize, 1))
                for m in range(hidesize):
                    dW1y[m] = np.dot(np.dot(W2[0][m], sigmoid(hide_in[m])), (1 - sigmoid(hide_in[m])) * y[j] * e * threshold)
                W1y = W1y - dW1y
                for m in range(hidesize):
                    dW1x[m] = np.dot(np.dot(W2[0][m], sigmoid(hide_in[m])), (1 - sigmoid(hide_in[m])) * x[i] * e * threshold)
                W1x = W1x - dW1x
                B1 = B1 - dB1
                W2 = W2 - dW2
                B2 = B2 - dB2
                temp = temp + abs(e)
        E[k] = temp
        if k % 2 == 0:
            print(k)
    # new a figure and set it into 3d
    fig = plt.figure()
    # set figure information
    ax = plt.axes(projection='3d')
    ax.set_title("z=sinx+0.01e^y")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_zlabel("z")
    ax.plot_surface(X, Y, z, cmap='rainbow')
    plt.figure()
    ax = plt.axes(projection='3d')
    ax.set_title("fitting z=sin x+0.01e^y")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_zlabel("z")
    print(x)
    print(z)
    print(Z)
    ax.plot_surface(X, Y, Z, cmap='rainbow')
    plt.show()
    

    运行程序,结果如图

    在这里插入图片描述

    ,对比可以看出来一定的拟合效果,但是效果不佳。分析原因,可能是样本数量,神经元数量过少,双输入单输出的情况下输出结果不依靠某一个输入数据,所以需要更为复杂的隐层结构。

    将迭代次数由20次加至200次,效果如图\ref{z拟合200次},拟合结果已经非常优秀,但是在程序运行时,耗时过长,且对计算机的运算速度和内存容量有较大要求,所以将迭代次数适当减少,同时增加中间神经元数量——将中间层神经元数量修改为15个(即第17行 m a x s t e p s = 7 max_steps = 7 maxsteps=7改成 m a x s t e p s = 15 max_steps = 15 maxsteps=15),迭代次数调整为100次。效果如图\ref{z拟合50神经元}。可以很好地拟合原函数,实验成功。

    在这里插入图片描述

    识依然不足,一直在使用最小二乘法进行校正,如果换用其他方法,同时调整校正速度,有可能会获取更好的拟合效果与耗时。

    如果要更好的训练深度学习,网络深度,模型设计,还有数据集的制作,这些都需要仔细学习。

    展开全文
  • BP神经网络拟合非线性函数 转载于:https://www.cnblogs.com/liuys635/p/11181290.html
  • RBF神经网络用于函数拟合与模式识别的Matlab示例程序%文中出现的所有归一化函数,都以被抛弃(obselete),使用方法也彻底改变了。Matlab7.8提供的归一化函数有fixunknowns, mapminmax, processpca,mapstd四个,具体...
  • 自己做的神经网络逼近函数的小例子,非常适合初学者理论与编程对照学习!!
  • 神经网络含有输入层,隐藏层,输出层,在拟合过程中,通常使用非线性激活函数,如logsig,tansig。 其中logsig具体为: ![logsig](https://img-blog.csdnimg.cn/20200705154735989.png#pic_center) tansig具体为...
  • 调用Nndl实现的神经网络code,用ANN拟合二次方程。 ref: https://github.com/mnielsen/neural-networks-and-deep-learning 准备训练数据 #np.shape(x) x=np.array(xrange(0,100))/100.0 f=x*x # train=np.array([[xi...
  • 单层的神经网络几乎等价于N元一次方程 多层的神经网络有什么意义?能拟合所有函数吗? 如果能,能介绍一下相关的证明过程/研究成果吗?(证明它能拟合所有函数) 如果不能,是不是说神经网络是基本上没用的
  • 深度学习 神经网络 BP 多层感知机 非线性函数 拟合 matlab
  • 代码: t=[ 0 3.9 4.1 7.3 8.4 13.1 14.8 16.4 17.7 19 19.7 20.3 21.2 24.5 26.3 27.8 28.9 29 29.8 31.1 ...'神经网络拟合' ); 可视化结果:
  • 神经网络拟合曲面(tensorflow)

    千次阅读 热门讨论 2019-06-09 15:54:57
    神经网络拟合曲面(tensorflow) 神经网络有拟合高维度向量空间的曲面的强大能力,在本文中利用深度学习对不可知二元函数进行拟合,可以自拟函数关系式,改一下y_data输入就行了,话不多说直接上代码。 import ...
  • b_L2 = tf.matmul(L1, Weights_L2) + biases_L2 # 激活函数私有tanh L2 = tf.nn.tanh(Wx_plus_b_L2) # 定义神经网络输出层 Weights_L3 = tf.Variable(tf.random_normal([128, 1])) biases_L3 = tf.Variable(tf.zeros...
  • Matlab神经网络拟合工具箱

    千次阅读 2019-07-09 13:54:12
    神经网络拟合工具箱 Neural Net Fitting 示例1:一元函数 y=x²-1 拟合 1.输入数据 %输入x,y x=-3:0.2:5; y=x.^2-1; 2.在Matlab的APPS菜单下找到Neural Net Fitting工具并打开,点击Next ...
  • Matlab神经网络拟合使用 nftool 点next 选择输入数据、目标值 调整比例,点next 选择隐含层节点个数,点next 点Train 一路点next,最后保存网络到工作区 要测试 y=sim(net,x) x是测试的输入,格式是列向量,...
  • 以一个简单实例,介绍在TensorFlow中以双层人工神经网络进行函数拟合的过程。
  • 以一个简单实例,介绍在TensorFlow中以单层人工神经网络进行函数拟合的过程。
  • 采用遗传算法优化的BP神经网络-非线性函数拟合,各种代码齐全
  • 基于Matlab的BP神经网络在非线性函数拟合中的应用

    万次阅读 多人点赞 2017-01-14 11:13:51
    本图文详细介绍了如何利用Matlab神经网络工具箱实现BP神经网络对非线性函数拟合
  • 深度学习-神经网络函数拟合

    千次阅读 2020-02-01 17:28:34
    理论上神经网络可以拟合任意的函数(应该用逼近更贴切一些)。 定义好神经网,送进去x和y,模型就学完了。但实际上,远没有这么简单。 不信,我们来看个简单例子。拟合一个y=cos(x),这样一个简单的函数。 这似乎...
  • %隐含层神经元的阈值 W2 = rand(1,20);%隐含层与输出层之间的权重 B2 = rand();%输出层神经元的阈值 yita = 0.0005; loop = 5000; E = zeros(1,loop);%误差随迭代次数的变化 for loopi = 1:loop tempsume = ...
  • BP神经网络非线性函数拟合应用

    千次阅读 2015-06-11 16:34:33
    %% BP神经网络的输入输出数据 % clear all % clc % x=rand(1,1500); % y=rand(1,1500); % p=[x;y]'; % z=x.^2-y.^2+3; % save x x % save y y % save p p % save z z %% clear all clc %% 训练数据预测数据提取及...
  • 本图文详细介绍了如何利用Matlab神经网络工具箱实现多层BP神经网络对非线性函数拟合
  • BP神经网络拟合数据及调优

    万次阅读 2015-12-03 00:36:34
    用BP神经网络做数据拟合,逐步调优,得到期望输出,并分析如何过渡到深度学习
  • 此处开始谈论一个学习算法,它能在给定训练集时,为神经网络拟合参数。 和我们讨论的大多数学习算法一样,我们将从拟合神经网络参数的代价函数开始讲起。 重点讲解神经网络在分类问题中的应用。 假设我们有一个与上...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,448
精华内容 1,779
关键字:

神经网络拟合多元函数