精华内容
下载资源
问答
  • 针对采样数据的自相关性, 提出一种基于自回归(AR) 模型动态过程建模方法. 首先, 利用正交信号校正(OSC) 消除用于AR模型回归的两数据集间的正交不相关信号; 然后, 在处理过的数据上进行偏最小二乘(PLS) 回归建模. ...
  • 为了获取超细颗粒动态散射光模拟信号, 在分析超细颗粒动态散射光信号特性的基础上, 通过建立动态光散射随机过程的自回归(AR)模型, 利用Levison-Durbin递推算法确定模型参数, 并给出了单峰、双峰分布颗粒信号模拟的...
  • 采用链路质量指示均值、信噪比均值和分组接收率构建基于组合协方差函数的高斯过程回归模型预测链路质量。稳定场景与不稳定场景下的实验结果表明,与动态贝叶斯网络预测模型相比,所提模型具有更好的预测精确度。
  • 文章目录线性高斯时间序列模型基于高斯过程的非线性自回归模型状态转移函数基于高斯过程的状态空间模型观测函数基于高斯过程的状态空间模型状态转移函数和观测函数都基于高斯过程的状态空间模型状态转移函数基于高斯...

    线性高斯时间序列模型

    在这里插入图片描述

    基于高斯过程的非线性自回归模型

    在这里插入图片描述

    状态转移函数基于高斯过程的状态空间模型

    在这里插入图片描述

    观测函数基于高斯过程的状态空间模型

    在这里插入图片描述

    状态转移函数和观测函数都基于高斯过程的状态空间模型

    在这里插入图片描述

    状态转移函数基于高斯过程的非1阶马尔科夫状态空间模型

    在这里插入图片描述

    隐变量基于高斯过程的高斯隐变量模型

    在这里插入图片描述

    展开全文
  • 上一篇博文中我们学习和回归了一下感知器分类模型,今天还是在上文的基础上做了一点扩展,上文中的感知器分类一方面是分类的效果有时候不太好,另一方面是没有实现分类过程动态可视化,我们都知道感知器分类模型...

         上一篇博文中我们学习和回归了一下感知器分类模型,今天还是在上文的基础上做了一点扩展,上文中的感知器分类一方面是分类的效果有时候不太好,另一方面是没有实现分类过程的动态可视化,我们都知道感知器分类模型本质上就是在每一次迭代过程中进行权重动态调整的过程,今天我们基于这个出发点来实现每一轮迭代权重更新值得输出与分类的结果的动态绘制,内容很简单,具体如下:

    #!usr/bin/env python
    #encoding:utf-8
    
    '''
    __Author__:沂水寒城
    功能:  感知器分类模型实践demo
    '''
    
    
    import os
    import sys
    import xlrd
    import xlwt
    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.colors import ListedColormap
    
    aaa=(np.array([0, 0, 1.1])).T 
    
    
    if sys.version_info<(3,0):
        #python2版本使用
        reload(sys)
        sys.setdefaultencoding("utf-8") 
        
    
    
    def write2Excel(data_list,targetfile='res.xls'):
        '''
        将txt中的内容转置后写到Excel中
        '''
        j=0
        book=xlwt.Workbook(encoding='utf-8')
        table=book.add_sheet('w_b')
        for one_list in data_list:
            for i in range(len(one_list)):
                table.write(i,j,one_list[i])
            j+=1
        book.save(targetfile)
    
    
    def readOneExcelData(data='data/Homework4.xlsx',row=1,col=1):
        '''
        row: 起始行索引
        col: 起始列索引
        '''
        workbook=xlrd.open_workbook(data,encoding_override="utf-8")
        table=workbook.sheets()[0]
        row_num,col_num=table.nrows,table.ncols
        data_list=[]
        for i in range(row,row_num):
            one_list=[]
            for j in range(col,col_num):
                one_list.append(table.cell_value(i,j)) 
            data_list.append(one_list)
        return np.array(data_list),[np.array(one) for one in data_list]
    
    
    def inputNetCal(X,W):
        '''
        计算
        '''
        print('W====>  ',W.tolist())
        res=np.dot(X,W)
        return res
    
    
    def netWadjust(W,n,X,flag):
        '''
        网络权重自适应调整
        '''
        return W+((n*X)*flag)
    
    
    def biasCal(label,output,n):
        '''
        计算偏置项
        '''
        bias=label-output
        bias+=n*bias
        return bias
    
    
    def demoModel(datasets,x_total,W,n,iters,pic_path='demo_res.png'):
        '''
        感知器分类模型
        '''
        x1,x2,t=datasets[:, 1], datasets[:, 2], datasets[:, 3]
        label_list=[x_total[i][-1] for i in range(len(x_total))]
        print 'label_list: ',label_list
        right=0
        for i in range(iters):
            if i%5==0:
                right=0
            node=inputNetCal(x_total[i%5][:3],W)
            bias=biasCal(label_list[i%5],node,1)
            if x_total[i%5][-1]==1 and node<=0:   
                W=netWadjust(W,n,x_total[i%5][:3],1)
            elif x_total[i%5][-1]==0 and node>=0:
                W=netWadjust(W,n,x_total[i%5][:3],-1)
            elif x_total[i%5][-1]==1 and node>0:
                right+=1
            elif x_total[i%5][-1]==0 and node<0:
                right+=1
            else:
                pass
            plt.cla()
            for h in range(len(x1)):
                if t[h]==1:
                    plt.plot(x1[h],x2[h],'ro')
                else:
                    plt.plot(x1[h],x2[h],'bo')
            plt.xlim(-1,1)  
            plt.ylim(-3,3)
            plt.title('Perceptron Model Dynamic Ploter')
            plt.grid(False)
            x_list=np.arange(-1,1,0.1)
            plt.plot(x_list,-((W[1]/W[2])*x_list)-(W[0]/W[2]))
            plt.pause(0.2)
            if right==5:
                plt.savefig(pic_path)
                print 'Best W: ',W
                print 'label_list: ',label_list
                print 'i: ',i
                break
        return W.tolist(),bias
    
    
    
    if __name__=='__main__':
        n=1 
        w=(np.array([0, 0, 1.1])).T 
        datasets,x_total=readOneExcelData(data='data/Homework4.xlsx',row=1,col=0)
        w,b=demoModel(datasets,x_total,w,n,50)
        w.append(b)
        data_list=[['W1','W2','W3','Bias'],w]
        write2Excel(data_list,targetfile='res.xls')

            结果如下:

                                                    

          我们顺便保存了最终的分类结果、权重、偏置系数等数据,如下:

                                        

           权重、偏置系数结果如下:  
                                                                               

           本文的实现中,初始的权重与学习率都是固定的,当然也可以固定偏置系数,这样结果就会是唯一的了,简单的实践。 

    展开全文
  • 偏最小二乘(Partial least square,PLS)是一种基于数据驱动可以处理多个因变量对多个自变量的回归建模方法,因其具有提取质量相关信息的特性,在质量相关复杂工业过程监控中得到广泛的应用,成为近几十年复杂工业过程...
  • C2C(consumer to consumer)电子商务市场...最后利用从某电子商务网站收集的观测信息,运用多元线性回归分析方法验证购买风险动态评估模型的可行性.借助本模型,可以帮助消费者在网购商品过程中较好地认知商品购买的风险.
  • 非线性带外输入自回归模型(NARX)在进行预测估计时依赖于主导变量的实时测量,因此在实际工业过程中存在一定的实施难度.针对该问题,利用神经网络构造一种新型NARX动态软测量模型,当工业过程无法及时提供上时刻主导变量...
  • 结果表明该定价模型在单边市的情形下,能够比传统B-S公式更好的体现中国股市动态资产价格的运动过程.此外,还给出了基于带均值回归项的跳跃扩散模型的各种类型权证(美式、欧式和百慕大式)的模拟定价方法,并给出此模拟...
  • 为了实现准确可靠的瓦斯浓度...将动态聚类算法和高斯回归模型结合,实现了瓦斯浓度的区间预测模型。通过实验对比分析,结果表明该方法能够有效地预测出瓦斯浓度变化趋势,较高斯过程预测模型提高了瓦斯浓度的预测精度。
  • 基于朗格缪尔模型、菲克第二扩散定律和达西定律,综合考虑重力和气体压缩效应的影响,推导...因此在煤层气藏开采过程中,应根据气井的产气动态调整井底流压,建立合理的储层压力系统,以降低渗透率回归效应带来的不利影响。
  • 分析了采煤过程中覆岩变化规律的研究现状,以相似材料模拟实验为基础,采用工业测量系统观测并对数据进行坐标转换、匹配、模型改正等处理,得到覆岩弯曲带的动态下沉曲线和水平移动曲线,并进行非线性回归分析,得出概率...
  • 过程回归(AGMM-GPR)的多模型动态校正软测量建模方法.首先,通过贝叶斯信息准则 构建自适应高斯混合模型(AGMM),得到优化的子模型个数;然后,利用GPR方法建立各局 部模型,当新的数据到来时,...
  • 动态风险度量VaR和CVaR的预测值的获取过程被规范化为一个多步骤算法。 该算法包括以下步骤:自回归预测,创新突出显示,获得模型残差的静态风险度量的评估,使用建议的公式形成最终预测,结果质量分析。 将该方法...
  • 论文研究-我国不同行业企业债信用价差的动态过程研究.pdf, 选取上海证券交易所2007年6月至2012年6月的企业债和国债月度交易数据,利用遗传算法对利率期限结构SV参数模型...
  • 想理解神经网络的训练动态过程,不妨从「神经正切核」入手。那么什么是神经正切核,核机制如何运行?就读于印度理工学院马德拉斯分校电气工程系的 Rajat Vadiraj Dwaraknath 撰文介绍了这一概念。选自Rajat's Blog,...
    想理解神经网络的训练动态过程,不妨从「神经正切核」入手。那么什么是神经正切核,核机制如何运行?就读于印度理工学院马德拉斯分校电气工程系的 Rajat Vadiraj Dwaraknath 撰文介绍了这一概念。

    选自Rajat's Blog,作者:Rajat Vadiraj Dwaraknath,机器之心编译,参与:魔王。

    • 博客地址:https://rajatvd.github.io/NTK/
    • 文章动图地址:https://github.com/rajatvd/NTK
    • 神经正切核相关论文地址:https://arxiv.org/abs/1806.07572

    d123111a150a49a45ab6c34f5ed0892a.gif
    这张动图展示了神经网络的训练动态过程。阅读本文,你将了解其背后原理。

    近期大量理论深度学习论文从无限宽度极限(infinite-width limit)入手分析神经网络。首先,无限宽度极限可能看起来不切实际,甚至没有研究意义。但是,无限宽度极限下的神经网络可以简化为具备神经正切核(neural tangent kernel,NTK)的线性模型。这样我们就可以很容易地研究梯度下降了。起初它看起来很有前景,但是实验结果证明,无限宽度极限下的神经网络效果不如实际的超参数网络。不过,这仍然为神经网络训练的某些方面提供了理论视角,值得我们继续探索。

    此外,神经正切核可在更宽泛的标准下出现(这取决于模型的规模),且无需无限宽度极限条件。本文简单直观地介绍了该理论,它可作为梯度下降收敛性证明。为方便可视化,本文使用简单的一维示例,帮助读者更轻松地理解该理论。

    设置

    我们首先来看以下一个非常简单的例子,理解该示例之后再将其泛化。我们看到一个一维输入和一维输出网络。这个简单的 relu 网络有两个隐藏层,宽度为 m。

    3b156ee59494c53241716deb03c20547.png
    我们将使用这个简单的一维模型进行初始试验。

    我们将该网络函数寻求随机初始化的过程画出来:

    46da8b7b6ca286a54e02ecefac89a99b.png
    100 个经过随机初始化的 relu 网络,该网络有两个隐藏层,宽度为 100。

    我们会发现这些函数等价于无限宽度极限下的高斯过程。

    我们先来了解一些符号:

    该神经网络函数为 f(x,w),其中 x 为输入,w 为权重组合向量(大小为 p)。

    在这个一维示例中,数据集为点 (x,y) 的集合。假设我们有 N 个数据点,则数据集为:

    7e3670308f5460fe59989723f9df1b46.png

    为了学习该网络,我们再使用一个简单的方法:基于最小二乘损失执行* *full-batch 梯度下降。损失函数为:

    cd92d04c8d241d96ecd79e74b1933a65.png

    我们可以用一些向量符号简化该公式。

    首先,将所有输出数据集的值 y¯_i 堆叠为一个大小为 N 的向量 y¯;

    类似地,将模型对每个输入的输出 f(x¯_i,w) 堆叠为一个预测向量 y(w)∈R^N,于是就有了 y(w)_i=f(x¯_i,w)。这相当于将神经网络函数 f(⋅,w) 看作函数空间中的一个向量。

    因此,上述损失函数可简化为:

    5515d356034defab30c96c62557a192a.png

    现在,我们不用改变数据集的大小 N,它在损失函数公式中是一个不必要的常量。因此,我们可以在不影响任何结果的前提下删除它,这样上述公式会看起来更加简洁(为方便求导,公式保留了 1/2)。

    d4db64b7822e2f17ca5cd205b6ce4348.png

    dd8adbdddc473a98e77e0fa9ce64bba0.png
    该图可以帮助读者厘清向量符号表示。我们对整个数据集高效执行向量化,在这个简单示例中数据集的大小为 2(即图中的两个蓝色点)。

    现在,训练网络即利用梯度下降最小化损失函数。

    ab6ea6aac432683c23950e9cceb5bd43.gif
    基于平方损失利用梯度下降训练 100 个 ReLU 网络。

    将训练过程中两个隐藏层之间的权重(m×m 矩阵)做成动图,我们将看到一些有趣的事:

    c31037116cb5eb7af8cdbcd72079f5de.gif

    22c662f38db6342230a0dc7063db5184.gif

    582b0d30b8fc222f0d10e0233c241f89.gif
    训练过程中权重矩阵的动图。你可能发现了,有些变化只发生在宽度小于 10 的情况,而宽度大于 10 时权重看起来是完全静止的。

    上面三幅图都是动图,但宽度较大时,权重竟然没有变化!看起来这些模型太「懒惰」了!我们来定量地看一下,权重向量与初始化权重之间的相对变化:

    5c5aa3cc6115eb0bf0ef850d608ffeea.png

    当权重值翻倍时,该相对变化与隐藏层大小的关系也远了一倍。现在,我们再来绘制训练得到的网络:

    e92d28748bae240a0adfb2c683752862.png
    损失曲线以及训练过程中权重的变化幅度。权重范数(weight norm)是将模型所有参数堆叠为一个向量而计算得到的。此外,所有其他超参数(如学习率)均保持不变。

    当隐藏层宽度较大时,权重的变化幅度并不大。

    泰勒展开

    对网络函数及其初始化周围的权重执行泰勒展开:

    2e5f871a4ae88b58128e6e3ee615db20.png

    我们将这个非线性网络函数转化成了简单的权重线性函数。使用更准确的向量符号表示,我们可以将其重写为:

    fb1650842858453c65868c8639b11c73.png

    矩阵大小也很清晰:

    ff708a17ba9904201672ca22aa2d0e07.png
    该图清晰地展示了所有向量和矩阵的大小。

    这里很多项(如初始输出 y(w_0) 和模型雅可比矩阵 ∇_w y(w_0))都是常量。我们主要来看 w 的依赖关系,即该近似是权重的线性模型,因此最小化最小二乘损失被简化为线性回归!不过需要注意的是,模型函数仍然是非线性的,因为寻找模型梯度绝非线性运算。事实上,这只是一个使用特征图 ϕ(x) 的线性模型,其在初始化时的梯度向量为:

    e9200b5c79e8e897be126eecb7c6ba52.png

    该特征图自然而然地导出输入上的核,即神经正切核。之后在介绍梯度流时我们会深入探讨神经正切核,现在先从理论角度证明该线性近似的合理性。

    什么时候该近似是准确的?

    该线性化模型非常适合分析,但这只出现在它确实是非线性模型的准确近似的情况下。在该近似运行良好时,我们尝试推导出其定量标准。这基于 Chizat 和 Bach 的论文《On Lazy Training in Differentiable Programming》(「懒惰」模式是线性近似的别称)进行。我要做的推导非常直观,包含少量 handwaving 以及矩阵和算子范数。

    首先,我们利用梯度下降优化模型,使之变为线性模型:

    30581b39670e6c32ab4e7f9a7538f2e4.png

    使用足够小的学习率 η,我们知道在运行梯度下降时,损失通常会下降。因此,模型输出 y(w_n) 通常接近真值标签 y¯。基于此,我们将网络变化的边界设定为:

    7d262bee1fbd2cd4f56c7b03ac602c2f.png

    现在,我们可以利用一阶近似量化网络在参数空间中移动的「距离」:

    b52f0451e1b4065302d859e56dbca177.png

    雅可比矩阵的范数 ‖∇_w y(w_0)‖ 是算子范数。如果你不熟悉算子范数,可以把它想像成衡量矩阵在向量上的最大伸展的指标(或者更简单些,将它作为衡量矩阵「大小」的指标)。

    为了得到雅可比矩阵的变化,我们可以利用距离 d 和模型输出与权重的海森矩阵 ∇_w^2 y(w_0)。此处,海森矩阵是一个秩为 3 的张量(仍是线性算子),你可以将它看作将每个输出的海森矩阵堆叠在一起获得三维海森「立方体」。将其范数作为衡量海森矩阵大小或雅可比矩阵变化率的指标。

    2d36bdbb5559bb10e669b969a1e4302d.png

    当我们想让模型成为线性时,我们在意的不只是雅可比矩阵的变化,还有相对变化。具体来说,我们想让雅可比矩阵的相对变化尽可能小(≪1):

    我们将蓝色项叫做 κ(w_0),条件 κ(w_0)≪1 可被直观地总结为:

    为得到 y 的变化 ‖(y(w_0)−y¯)‖,w 需要变化的量将导致雅可比矩阵∇_w y(w) 的细微变化。

    这意味着该模型非常接近其线性近似。

    现在,我们需要了解神经网络隐藏层宽度 m 对 κ(w_0) 变化的影响。我们发现随着 m 趋向无穷大,k 趋向于 0。这里我们需要谨慎一些,由于初始化权重 w_0 是随机的,κ(w_0) 也是随机变量。也就是说,当 k 趋向于 0 时,其期望值也趋向于 0。这仅适用于权重得到恰当初始化的情况。具体来说,它们必须是独立的零均值高斯随机变量,方差与输入层大小成反比(这叫做 LeCun initialization)。该结果解释了,神经网络宽度越大权重变化越小的原因。

    为什么这一结果是通用的?理解这一点比较复杂,因此我将在仅具备一个隐藏层的更简单示例中,展示推导过程。

    直观解释是:较大的网络宽度意味着影响输出的神经元很多。这些神经元权重发生一点细微变化都可能导致输出出现非常大的改变,因此这些神经元需要移动非常小的距离来拟合数据。如果权重移动幅度较小,则线性近似更加准确。随着网络宽度增加,神经元变化幅度降低,模型越来越接近其线性近似。如果你理解了这一直观解释,你可以跳过接下来的证明部分,直接看下一章节。

    1d524b1383ebf72c9a0c9138dde6ff5c.png
    在原文中点击左侧三角图标,即可查看相关证明,此处不再赘述。

    缩放输出

    我们再来看一下 κ(w_0) 的公式:

    e0343828d8582d7aa0ce092f57edad5c.png

    我将模型输出乘以因子 α:

    94dbc9c1518b4c07ad841d84c784cd19.png

    这就是模型重缩放。‖(y(w_0)−y¯)‖ 项很繁琐,我们可以假设模型在初始化时的输出总是为 0,即 y(w_0)=0,从而去除该项。(我们可以在初始化时减去输出的副本,使模型在初始化时的输出总是为 0。)

    873cad2a0ddf0509c2ed114283edf80c.png

    我们令 α→∞,使模型成为线性(即 κ(w_0)→0)。因此,《On Lazy Training in Differentiable Programming》的作者将 κ(w_0) 称为模型的逆相对缩放(inverse relative scale)。

    有一件重要的事需要注意:这适用于任意非线性模型,且并不特定于神经网络(尽管需要两次微分)。因此,为了方便可视化,我制作了一个一维示例模型。该模型有一个权重 w,初始化权重为 w_0=0.4。

    207606b803c31923b010ea2a1c01bb10.png

    它满足初始化处输出为 0 的要求。要想看 α 对模型线性情况的影响,我们只需查看函数在特定值 x 处的值(假设 x=1.5)。通过不断改变 α 的值,我们可以得到如下可视化图:

    bc3ac751f955c577d96cdaeb7e201f6c.gif
    在特定 x 值处评估该示例模型,不断更改 α 值。随着缩放越来越大,线性(即该案例中的切线)逐渐接近真实函数。

    我们还可以查看单个数据点在这两个模型上的损失表面。线性化损失是一条漂亮的抛物线,我们希望随着 α 值的增加,实际损失逐渐接近这条抛物线。

    c7df7bb18e0acf4bd0de8db4a68d548b.gif

    6e2a30f02d9e595648d21ac58d6d9595.gif
    归一化损失。只需除以α^2 即可完成归一化,这样实际损失不会随着 α 发生变化。这两幅图展示的是同一件事,只不过下方的图在 w=0.4 周围进行了放大,以便我们更清楚地查看微小的差异。

    从中,我们可以得到一些重要的观察结果:

    线性化损失不会像我们期待的那样接近实际损失;两个损失表面的极小值逐渐接近,更重要的是,它们逐渐靠近初始化值。这与上文中的观察「模型训练过程中权重很少发生改变」相符。

    梯度流

    我们解决了神经网络和更通用的非线性模型何时被其线性模型准确逼近的问题。现在,我们来看看梯度下降过程中的训练动态。

    9dc4912f33de88861e4880cb1a4ed0f5.png

    重写该公式,得到:

    9eb670a9ac57d559651861453e4792a3.png

    左侧的项看起来像是导数的有限差分近似。这个公式就变成了对微分方程进行差分方程近似。令学习率无限小,我们可以看到权重向量随着时间的变化,微分方程如下:

    288a79904e46de51d28dd038bb94dcf2.png

    这就是梯度流(gradient flow)。本质上,它是标准梯度下降的连续时间变化。重点在于,梯度流在参数空间中的轨迹近似学习率足够小时该微分方程的解的轨迹。为了简化符号表示,本文用点标注时间导数:

    d75a4529dafffe8d17e0e8d6b032ed90.png

    此外,由于时间变量可以从语境中推断出来,我们去掉该变量。使用梯度替代损失,得到:

    0148131a49e0c0b12388e71fb51426ab.png

    现在,我们可以利用链式法则基于该梯度流推导出模型输出 y(w) 的动态过程(这基本上就是函数空间中的动态变化):

    ad7d791456505ce437143efc0ad01bac.png

    红色项 ∇y(w)^T∇y(w) 就是神经正切核(NTK),我们用符号 H(w) 表示它。

    回到泰勒展开那一节,我们看到线性化模型的特征图 ϕ(x)=∇_w f(x,w_0)。该特征图对应的核矩阵是通过对所有数据点的特征图取成对内积得到的。这就是 H(w_0)!

    0148d08333af4b177b87855ebb1a777b.png
    初始化处的神经正切核包含数据点特征图之间的成对内积。注意,这也可以解释为数据点的外积(x¯_i 是数据集中的输入)。

    如果模型接近其线性近似(κ(w_0)≪1),则模型输出的雅可比矩阵不会随着训练过程发生变化。也就是说:

    08b06c524d81e1f309110759660fa679.png

    这就是核机制(kernel regime),因为正切核在训练过程中始终为常量。现在,训练动态过程被简化为简单的线性常微分方程(ODE):

    3d9b74300d5701fd5e999126998d5141.png

    很明显,y(w)=y¯ 是该常微分方程的平衡点,它对应于训练损失为 0 的情况,这正是我们想要的。我们可以定义 u=y(w)−y¯,来改变状态变量,从而去除 y¯。则梯度流公式被简化为:

    8acc8982fba26e77dae916bbd7220616.png

    该 ODE 的解由矩阵指数运算得出:

    89921f65b12795db8fdb8d41a7e4d5d2.png

    由于模型过参数化(p>n),则 NTK ∇y(w_0)^T∇y(w_0) 总是正定的(忽略导致∇y(w_0) 不具备满列秩的任意数据集退化)。对正定 NTK 执行谱分解后,我们将梯度流的轨迹分解为独立的一维组件(特征向量),它以正比于对应特征值的速率衰减。其关键在于,它们全都衰减(因为所有特征值均为正),这意味着梯度流总是收敛至训练损失为 0 的平衡点。

    通过这一系列论证,我们证明了,对于任意非线性模型,只要它接近其线性近似,其梯度下降就能收敛至 0 训练损失。这是近期证明梯度下降达到 0 训练损失的大多数论文中大部分证明的本质。

    核机制

    梯度流的数学原理有点难懂,现在我们回到数据集中有两个样本的示例。对于两个数据点,NTK 是 2x2 正定矩阵。我们可以将该矩阵可视化为二维平面中的椭圆,其中长轴和短轴是特征值,其长度与特征值成反比。基于此,我们可以在此二维平面中看到梯度下降(逼近梯度流)导致的 y(w(t)) 的轨迹。如下所示:

    d123111a150a49a45ab6c34f5ed0892a.gif

    78da76ad9fc92ad92291ca1460af7243.gif

    不同模型大小在训练过程中的神经正切核(从不同初始化开始)。我对不同 α 的梯度流执行了归一化,以使时间尺度和正切核规模相匹配。我们可以清晰地看到 α 越大(粉色线),NTK 的变化幅度越小,而 α 较小时(红色线),NTK 在模型训练过程中的变化很大。下侧图展示了模型函数在训练过程中的变化。

    • 我特意将椭圆的中心设置为目标数据 y¯,以使其轨迹接近中心。这样,你可以看到椭圆短轴(较大特征值)对应的组件比长轴(较小特征值)收敛得更快;
    • α 的较小值也会收敛至 0 训练损失,不过我们对此没有任何理论依据。我们的证明仅对 α 足够大能使椭圆在训练过程中保持不变时有效(核机制);
    • 最小的 α 值收敛得很快,快到动图中几乎看不出来;
    • 我在模型运行中使用的是两层网络,其宽度为 100。我还在初始化处减去了其副本,使网络输出为 0(正因如此,所有轨迹均从原点开始)。尽管我们无法看到该网络有 10000 个权重时,权重在训练过程中的变化,但是我们可以看到网络输出,如上图所示。

    重点在于:对于较大的 α 值,存在核机制,而对于较小 α 值的行为则缺乏理论依据。

    此外,还有一点需要注意:

    这些图中的 NTK 机制仅适用于较大的 α 值。我们还可以将宽度扩展到无限大来使用该机制,而不仅是缩放输出。但是,该案例提供了一个特别的收获。注意,初始化处的 NTK 是不同的,因为初始化是随机的。但是,随着我们将隐藏层宽度扩展至无限,初始化处的 NTK 变得确定了!也就是说,对于给定深度和激活函数,存在一个固定的 NTK。实际上,该 NTK 可以得到确切计算,高效模拟无限宽度神经网络(参见论文《On Exact Computation in an Infinitely Wide Net》,此处不再赘述)。

    泛化

    目前,我们仅探讨了训练数据的情况。那么测试集呢?

    首先,在核机制中训练模型等价于解决线性系统。过参数化(p>n)意味着该线性系统是欠定的(under-determined),因此它具备无限个解。由于我们使用梯度下降来解决该系统,那么它隐性地偏向于极小范数解。即,梯度下降选择具备极小 ‖w‖_2 的解(前提是,我们从具备低范数的初始化开始)。

    我们现在考虑将 y 空间扩展为无限维度的函数空间,则 w 空间中的极小 ℓ2 范数被转换为选择一个函数,使特定函数范数最小化。决定该范数的是什么呢?描述该线性问题的核,即 NTK。这可以解读为一种正则化形式,你可以使用它谈论泛化。本文不再赘述。

    结论

    NTK 理论很伟大,而上述可视化图证明了神经网络不止 NTK 机制。实验证明,实际成功的神经网络并非在 NTK 机制中运行。实际上,即使最优秀的线性化神经网络在标准基准数据集(如 MNIST 和 CIFAR)上的性能也比实际成功的神经网络差了大约 7%(不过近期发展或许弥补了这一差距,参见论文《Enhanced Convolutional Neural Tangent Kernels》)。

    但是,NTK 理论不是理解神经网络训练动态过程的唯一理论。还有一系列工作利用最优传输和平均场理论描述训练动态过程,这些案例中通过非线性 PDE 实现的模型缩放并不大(κ∼1),但是据我所知,这些理论都无法扩展至具备一个隐藏层的网络。

    不过,这些 NTK 结果仍然非常有趣,它们提供了探索神经网络学习的新思路。尝试理解核在训练过程中的变化对于寻找更好的神经网络理论大有裨益。

    展开全文
  • 针对MIMO非线性系统的模型预测控制(MPC),建立了一种新型的带有外部输入的反向传播自回归(BP-ARX)组合模型,可以得到输入与输出之间的稳态关系。 BP神经网络代表稳态关系,ARX模型代表非线性系统输入和输出之间...
  • 本节第二部分介绍pytorch最大的特性——动态图机制,动态图机制是pytorch与tensorflow最大的区别,该部分首先介绍计算图的概念,并通过演示动态图与静态图的搭建过程来理解动态图与静态图的差异。 1. 张量的操作:...

    目录

    一、张量的操作

    1. 拼接、切分

    1.1 torch.cat()

    1.2 torch.stack()

    1.3 torch.chunk()

    1.4 torch.split()

    2. 索引

    2.1 torch.index_select()

    2.2 torch.make_select()

    3. 变换

    3.1 torch.reshape()

    3.2 torch.transpose()和torch.t()

    3.3 torch.squeeze()和torch.unsqueeze()

    二、张量数学运算

    1. 加法运算torch.add()

    三、线性回归


    任务简介

    学习张量的基本操作与线性回归模型的实现。

    详细说明

    本节介绍张量的基本操作,如张量拼接切分、索引和变换,同时学习张量的数学运算,并基于所学习的知识,实现线性回归模型的训练,以加深知识点的认识。

    一、张量的操作

    1. 拼接、切分

    1.1 torch.cat()

     测试代码

    # ======================================= example 1 =======================================
    # torch.cat
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.ones((2, 3))
    
        t_0 = torch.cat([t, t], dim=0)
        t_1 = torch.cat([t, t, t], dim=1)
    
        print("t_0:{} shape:{}\nt_1:{} shape:{}".format(t_0, t_0.shape, t_1, t_1.shape))
    

    输出

    t_0:tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]]) shape:torch.Size([4, 3])
    t_1:tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
            [1., 1., 1., 1., 1., 1., 1., 1., 1.]]) shape:torch.Size([2, 9])
    

    1.2 torch.stack()

    测试代码

    # ======================================= example 2 =======================================
    # torch.stack
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.ones((2, 3))
    
        t_stack = torch.stack([t, t, t], dim=0) # 如果第0维有数据则原来第0、1...维的向后顺延一位
    
        print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))
    
    

    输出

    t_stack:tensor([[[1., 1., 1.],
             [1., 1., 1.]],
    
            [[1., 1., 1.],
             [1., 1., 1.]],
    
            [[1., 1., 1.],
             [1., 1., 1.]]]) shape:torch.Size([3, 2, 3])
    

    1.3 torch.chunk()

    测试代码 

    # ======================================= example 3 =======================================
    # torch.chunk
    
    flag = True
    #flag = False
    
    if flag:
        a = torch.ones((2, 7))  # 7
        list_of_tensors = torch.chunk(a, dim=1, chunks=3)   # 3
    
        for idx, t in enumerate(list_of_tensors):
            print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
    

     输出

    第1个张量:tensor([[1., 1., 1.],
            [1., 1., 1.]]), shape is torch.Size([2, 3])
    第2个张量:tensor([[1., 1., 1.],
            [1., 1., 1.]]), shape is torch.Size([2, 3])
    第3个张量:tensor([[1.],
            [1.]]), shape is torch.Size([2, 1])
    

    1.4 torch.split()

    list元素的和必须等于指定维度上张量的长度。 

    测试代码 

    # ======================================= example 4 =======================================
    # torch.split
    
    # flag = True
    flag = True
    
    if flag:
        t = torch.ones((2, 5))
        t1 = torch.ones((2, 5))
        list_of_tensors = torch.split(t, 2, dim=1)  # [2 , 1, 2]
        for idx, t in enumerate(list_of_tensors):
            print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
    
        list_of_tensors = torch.split(t1, [2, 1, 2], dim=1)
        for idx, t in enumerate(list_of_tensors):
            print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
    

    输出

    第1个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    第2个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    第3个张量:tensor([[1.],
            [1.]]), shape is torch.Size([2, 1])
    
    
    第1个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    第2个张量:tensor([[1.],
            [1.]]), shape is torch.Size([2, 1])
    第3个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    

    2. 索引

    2.1 torch.index_select()

    测试代码 

    # ======================================= example 5 =======================================
    # torch.index_select
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.randint(0, 9, size=(3, 3))
        idx = torch.tensor([0, 2], dtype=torch.long)    # float
        t_select = torch.index_select(t, dim=0, index=idx)
        print("t:\n{}\nt_select:\n{}".format(t, t_select))
    

    输出

    t:
    tensor([[4, 5, 0],
            [5, 7, 1],
            [2, 5, 8]])
    t_select:
    tensor([[4, 5, 0],
            [2, 5, 8]])
    

    2.2 torch.make_select()

    测试代码

    # ======================================= example 6 =======================================
    # torch.masked_select
    
    flag = True
    #flag = False
    
    if flag:
    
        t = torch.randint(0, 9, size=(3, 3))
        mask = t.le(5)  # ge is mean greater than or equal/   gt: greater than  le  lt
        t_select = torch.masked_select(t, mask)
        print("t:\n{}\nmask:\n{}\nt_select:\n{} ".format(t, mask, t_select))
    

     输出

    t:
    tensor([[4, 5, 0],
            [5, 7, 1],
            [2, 5, 8]])
    mask:
    tensor([[ True,  True,  True],
            [ True, False,  True],
            [ True,  True, False]])
    t_select:
    tensor([4, 5, 0, 5, 1, 2, 5]) 
    

    3. 变换

    3.1 torch.reshape()

     测试代码

    # ======================================= example 7 =======================================
    # torch.reshape
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.randperm(8)
        t_reshape = torch.reshape(t, (-1, 2, 2))    # -1代表第0维度数值为8/2/2=2
        print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
    
        t[0] = 1024
        print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
        print("t.data 内存地址:{}".format(id(t.data)))
        print("t_reshape.data 内存地址:{}".format(id(t_reshape.data)))
    

    输出

    t:tensor([5, 4, 2, 6, 7, 3, 1, 0])
    t_reshape:
    tensor([[[5, 4],
             [2, 6]],
    
            [[7, 3],
             [1, 0]]])
    t:tensor([1024,    4,    2,    6,    7,    3,    1,    0])
    t_reshape:
    tensor([[[1024,    4],
             [   2,    6]],
    
            [[   7,    3],
             [   1,    0]]])
    t.data 内存地址:1169043563128
    t_reshape.data 内存地址:1169043563128
    

    3.2 torch.transpose()和torch.t()

    测试代码

    # ======================================= example 8 =======================================
    # torch.transpose
    
    flag = True
    #flag = False
    
    if flag:
        # torch.transpose
        t = torch.rand((2, 3, 4))
        t_transpose = torch.transpose(t, dim0=1, dim1=2)    # c*h*w     h*w*c
        print("t shape:{}\nt_transpose shape: {}".format(t.shape, t_transpose.shape))
    

    输出

    t shape:torch.Size([2, 3, 4])
    t_transpose shape: torch.Size([2, 4, 3])
    

    3.3 torch.squeeze()和torch.unsqueeze()

    测试代码

    # ======================================= example 9 =======================================
    # torch.squeeze
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.rand((1, 2, 3, 1))
        t_sq = torch.squeeze(t)
        t_0 = torch.squeeze(t, dim=0)
        t_1 = torch.squeeze(t, dim=1)
        print(t.shape)
        print(t_sq.shape)
        print(t_0.shape)
        print(t_1.shape)
    

     输出

    torch.Size([1, 2, 3, 1])
    torch.Size([2, 3])
    torch.Size([2, 3, 1])
    torch.Size([1, 2, 3, 1])
    

    二、张量数学运算

    1. 加法运算torch.add()

    测试代码

    # ======================================= example 8 =======================================
    # torch.add
    
    flag = True
    #flag = False
    
    if flag:
        t_0 = torch.randn((3, 3))
        t_1 = torch.ones_like(t_0)
        t_add = torch.add(t_0, 10, t_1)
    
        print("t_0:\n{}\nt_1:\n{}\nt_add_10:\n{}".format(t_0, t_1, t_add))
    

     输出

    t_0:
    tensor([[ 0.6614,  0.2669,  0.0617],
            [ 0.6213, -0.4519, -0.1661],
            [-1.5228,  0.3817, -1.0276]])
    t_1:
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])
    t_add_10:
    tensor([[10.6614, 10.2669, 10.0617],
            [10.6213,  9.5481,  9.8339],
            [ 8.4772, 10.3817,  8.9724]])
    

    三、线性回归

    测试代码

    import torch
    import matplotlib.pyplot as plt
    torch.manual_seed(10)
    
    lr = 0.05  # 学习率    20191015修改
    
    # 创建训练数据
    x = torch.rand(20, 1) * 10  # x data (tensor), shape=(20, 1)
    y = 2*x + (5 + torch.randn(20, 1))  # y data (tensor), shape=(20, 1)
    
    # 构建线性回归参数
    w = torch.randn((1), requires_grad=True)
    b = torch.zeros((1), requires_grad=True)
    
    for iteration in range(1000):
    
        # 前向传播
        wx = torch.mul(w, x)
        y_pred = torch.add(wx, b)
    
        # 计算 MSE loss
        loss = (0.5 * (y - y_pred) ** 2).mean()
    
        # 反向传播
        loss.backward()
    
        # 更新参数
        b.data.sub_(lr * b.grad)
        w.data.sub_(lr * w.grad)
    
        # 清零张量的梯度  
        w.grad.zero_()
        b.grad.zero_()
    
        # 绘图
        if iteration % 20 == 0:
    
            plt.scatter(x.data.numpy(), y.data.numpy())
            plt.plot(x.data.numpy(), y_pred.data.numpy(), 'r-', lw=5)
            plt.text(2, 20, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
            plt.xlim(1.5, 10)
            plt.ylim(8, 28)
            plt.title("Iteration: {}\nw: {} b: {}".format(iteration, w.data.numpy(), b.data.numpy()))
            plt.pause(0.5)
    
            if loss.data.numpy() < 1:
                break
    

     输出

    当迭代100次时,损失值小于1

    展开全文
  • 商品价格问题的线性回归模型 商品最优价格的数学模型 韶关学院课堂教学时间调整方案 生产的销售与存贮的数学模型(0) 生产规模的优化模型 生产过程调度的数学模型 生产销售存贮问题的数学模型 生产与存储的...
  • 通过量化查询负载执行过程中对系统资源(CPU 与磁盘)的消耗,将资源消耗产生的时间代价和功耗代价转化为时间代价预测模型和功率代价预测模型,在单站点数据库服务器上实现了为数据库系统构建资源单位代价统一的...
  • tesorflow007-线性回归

    2019-04-22 12:57:56
    一,线性回归模型: y = w*x +b 二,训练原理 训练其实就是传入x 的值 和 对应的y值,通过训练w和b的值,使通过线性函数计算的y_值趋近y 三,训练步骤 1,定义参数 定义x特征值 占位符类型 x的值在运行的过程中...
  • 为实现对煤矿采掘工作面瓦斯的动态涌出过程进行精确预测,以煤矿瓦斯涌出时间序列为基础,首先建立了灰色模型GM(1,1)和自回归积分移动平均模型(ARIMA)分别对瓦斯涌出浓度进行预测,然后再利用由方差倒数法得到的ARIMA-...
  • GA-LR参数优化与城市用地动态模拟,刘明皓,尚尉,为更好的理解城市扩张过程,如何提高基于地理元胞自动机的城市模型的精度一直是学者们不懈努力的方向。针对常规logistic回归模型的�
  • 任务简介:学习张量的基本操作与线性回归模型的实现;学习计算图概念,理解动态图和静态图的差异。 详细说明: 本节将介绍张量的基本操作,如张量拼接切分、索引和变换,同时学习张量的数学运算,并基于所学习的...
  • 他们的故事基于模型,例如回归模型,时间序列模型和ANOVA模型。 为什么需要数值评分指标? 这些模型在现实世界中有很多影响,从投资组合经理的决策到一天、一周和一年不同时间的电价。为了达到以下目的,需要数值...
  • 剩余过程由经典的Cramér-Lunderg模型描述,金融市场包含市场指数,无风险资产和一对定价错误的股票,其中预期的股票收益率和定价错误遵循均值回归过程,考虑流动性约束。 特别是,保险费和再保险费都被假定为通过...
  • 利用简单的线性模型很难描述发酵这类复杂的非线性动态过程,因此需要利用非线性方法对该类过程进行建模。为此,提出了利用基于Marquardt算法的非线性回归方法和基于四阶Runge-Kutta算法的非线性微分方程求解方法对...
  • 一、引言(一)研究背景本文所涉及的黄金...国内外学者对黄金价格趋势研究所使用的方法很多但具有一定的局限性,如供需法、美元法、成本法、回归模型法等。本文将利用时间序列相关理论对伦敦黄金交易市场的黄金价格建...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 180
精华内容 72
关键字:

动态回归模型过程