精华内容
下载资源
问答
  • 对于灰色预测模型中简单的灰色关联度模型的MATLAB应用
  • 针对中长期电力负荷同时具有增长性波动性的二重趋势,基于预测模型关联优化的电力负荷组合预测模型理论,首先对GM(1,1)模型进行改进,引入修正系数,使得原始序列与新预测值的误差在最小二乘意义下达到最小。...
  • 灰色关联模型的网络安全态势感识预测方法.pdf
  • 基于频繁模式谱聚类的课程关联分类模型和学生成绩预测算法研究.pdf
  • 基于主成分分析和灰色关联理论在克服指标的共线性、相关性对瓦斯涌出量影响,兼顾二者关联性之上,确定主要指标,建立瓦斯涌出量预测的距离模型和灰色模型,进而基于支持向量机非线性,构建非线性组合预测模型....
  • 深成份指数的灰色行业聚类关联预测模型研究.pdf
  • 针对大众化教育中存在的学生质量参差不齐、教学管理难度加大等问题,提出一种基于频繁模式谱聚类的课程关联分类模型和学生成绩预测算法研究。以通信工程专业学生的课程成绩为样本,利用Apriori和FP-growth算法对不同...
  • 提出一种基于关联挖掘技术的煤炭产量预测模型,利用灰色系统理论,建立GM(1,1)的煤炭产量预测模型。为了提高煤炭产量预测模型精度,改善传统预测模型存在的问题与不足,采用Gauss-Legendre公式对已经建立的GM(1,1)预测...
  • 2、预测模型 预测模型是在采用定量预测法进行预测时,最重要的工作是建立预测数学模型。预测模型是指用于预测的,用数学语言或公式所描述的事物间的数量关系。它在一定程度上揭示了事物间的内在规律性,预测时把它...

    1、分类模型

    2、预测模型

    预测模型是在采用定量预测法进行预测时,最重要的工作是建立预测数学模型。预测模型是指用于预测的,用数学语言或公式所描述的事物间的数量关系。它在一定程度上揭示了事物间的内在规律性,预测时把它作为计算预测值的直接依据。因此,它对预测准确度有极大的影响。任何一种具体的预测方法都是以其特定的数学模型为特征。预测方法的种类很多,各有相应的预测模型。

    3、关联分析

    预测模型是在采用定量预测法进行预测时,最重要的工作是建立预测数学模型。预测模型是指用于预测的,用数学语言或公式所描述的事物间的数量关系。它在一定程度上揭示了事物间的内在规律性,预测时把它作为计算预测值的直接依据。因此,它对预测准确度有极大的影响。任何一种具体的预测方法都是以其特定的数学模型为特征。预测方法的种类很多,各有相应的预测模型。

    4、聚类分析

    聚类分析(cluster analysis)是一组将研究对象分为相对同质的群组(clusters)的统计分析技术,无监督学习。 聚类分析区别于分类分析(classification analysis) ,后者是有监督的学习。

    5、异常值分析

    异常值(outlier)是指一组测定值中与平均值的偏差超过两倍标准差的测定值,与平均值的偏差超过三倍标准差的测定值,称为高度异常的异常值。

    6、协同过滤

    协同过滤简单来说是利用某兴趣相投、拥有共同经验之群体的喜好来推荐用户感兴趣的信息,个人通过合作的机制给予信息相当程度的回应(如评分)并记录下来以达到过滤的目的进而帮助别人筛选信息,回应不一定局限于特别感兴趣的,特别不感兴趣信息的纪录也相当重要。
    协同过滤又可分为评比(rating)或者群体过滤(social filtering)协同过滤以其出色的速度和健壮性,在全球互联网领域炙手可热。

    7、社会网络

    社会网络(social network)是一种基于“网络”(节点之间的相互连接)而非“群体”(明确的边界和秩序)的社会组织形式,也是西方社会学从 1960 年代兴起的一种分析视角。随着工业化、城市化的进行和新的通讯技术的兴起,社会呈现越来越网络化的趋势,发生“社会网络革命”(social network revolution),与移动革命(mobile revolution)、互联网革命(internet revolution)并列为新时期影响人类社会的三大革命.

    展开全文
  • 为提高煤与瓦斯突出预测指标选择评价的准确性,并确保多指标评价体系的系统完整性及预测指标的区间连续性,更准确地指导现场突出预测指标的选定,根据灰色区间数关联决策理论,建立煤与瓦斯突出预测指标评价与决策的...
  • 基于灰关联神经网络马尔可夫模型的股票价格预测.pdf
  • 模型采用灰色关联理论完成了评价指标的优化,并利用遗传算法对BP网络初始权值阈值的确定进行了优化。以重庆南桐矿区砚石台矿为例,对煤与瓦斯突出强度进行了预测,结果表明,采用本模型预测结果与矿井实际突出状况...
  • 鱼雷生产费用的灰色趋势关联预测模型,赵民全,梁庆卫,生产批次不同的同型鱼雷,其生产费用并不相同,总体上会呈下降的趋势。利用前几批次的生产费用,预测出后一批次的生产费用,可以
  • 灰色关联—集对聚类预测模型在吉林省用水量预测中的应用.pdf
  • 提出了一种基于关联规则的电力负荷预测模型智能推荐方法,解决了面对众多预测模型使决策者难以选择的问题。该方法首先建立预测模型与相关因素历史数据库,在此基础上进行关联规则挖掘,然后结合给定预测地区的相关因素...
  • KATZMDA:基于KATZ模型的miRNA疾病关联预测
  • 基于灰关联-神经网络的写作成绩预测模型.pdf
  • 基于动态灰关联的铁路短期客运量灰色预测模型,李旭升,张家诚,将灰色系统多维GM(1,N)模型引入铁路短期客运量预测中,并结合动态灰关联分析法对影响短期客运量的各因素按影响程度大小进行排序,�
  • 基于灰色关联与BP神经网络的蒸发量预测模型研究.pdf
  • 利用灰色关联熵理论分析影响因素与突出危险性的关联度,得到各影响因素的权重及关联度排序,并结合概率神经网络(PNN)原理,构建基于灰色关联熵的煤与瓦斯突出PNN预测模型。用煤与瓦斯突出样本数据,对影响因素加权...
  • 基于灰关联与少数据云推理的短时交通流预测模型,杨锦伟,肖新平,针对短时交通流所存在的不确定性即模糊性与随机性特点准周期规律,提出基于灰色关联分析少数据云推理的短时交通流预测模型
  • 转载并整理自: ...灰色关联度分析 # -*- coding: utf-8 -*- from sklearn.preprocessing import StandardScaler import pandas as pd import numpy as np import os ... '''灰色关联度分析模型''' d

    转载并整理自:
    https://www.codenong.com/p12366364/
    https://www.codenong.com/p12368419/

    灰色关联度分析

    # -*- coding: utf-8 -*-
    from sklearn.preprocessing import StandardScaler
    import pandas as pd
    import numpy as np
    import os
    
    
    class GraModel():
        '''灰色关联度分析模型'''
    
        def __init__(self, inputData, p=0.5, standard=True):
            '''
            初始化参数
            inputData:输入矩阵,纵轴为属性名,第一列为母序列
            p:分辨系数,范围0~1,一般取0.5,越小,关联系数间差异越大,区分能力越强
            standard:是否需要标准化
            '''
            self.inputData = np.array(inputData)
            self.p = p
            self.standard = standard
            # 标准化
            self.standarOpt()
            # 建模
            self.buildModel()
    
        def standarOpt(self):
            '''标准化输入数据'''
            if not self.standard:
                return None
            self.scaler = StandardScaler().fit(self.inputData)
            self.inputData = self.scaler.transform(self.inputData)
    
        def buildModel(self):
            # 第一列为母列,与其他列求绝对差
            momCol = self.inputData[:, 0]
            sonCol = self.inputData[:, 0:]
            for col in range(sonCol.shape[1]):
                sonCol[:, col] = abs(sonCol[:, col] - momCol)
            # 求两级最小差和最大差
            minMin = sonCol.min()
            maxMax = sonCol.max()
            # 计算关联系数矩阵
            cors = (minMin + self.p * maxMax) / (sonCol + self.p * maxMax)
            # 求平均综合关联度
            meanCors = cors.mean(axis=0)
            self.result = {'cors': {'value': cors, 'desc': '关联系数矩阵'}, 'meanCors': {'value': meanCors, 'desc': '平均综合关联系数'}}
    
    
    if __name__ == "__main__":
        # # 路径目录
        # curDir = os.path.dirname(os.path.abspath(__file__))  # 当前目录
        # baseDir = os.path.dirname(curDir)  # 根目录
        # staticDir = os.path.join(baseDir, 'Static')  # 静态文件目录
        # resultDir = os.path.join(baseDir, 'Result')  # 结果文件目录
        # 读数
        data = [
            [1, 1.1, 2, 2.25, 3, 4],
            [1, 1.166, 1.834, 2, 2.314, 3],
            [1, 1.125, 1.075, 1.375, 1.625, 1.75],
            [1, 1, 0.7, 0.8, 0.9, 1.2]
        ]
        data = np.array(data).T
        # 建模
        model = GraModel(data, standard=True)
        print(model.result)
    
    

    灰色预测

    # -*- coding: utf-8 -*-
    import matplotlib.pyplot as plt
    import pandas as pd
    import numpy as np
    
    
    def GM11(x, n):
        '''
        灰色预测
        x:序列,numpy对象
        n:需要往后预测的个数
        '''
        x1 = x.cumsum()  # 一次累加
        z1 = (x1[:len(x1) - 1] + x1[1:]) / 2.0  # 紧邻均值
        z1 = z1.reshape((len(z1), 1))
        B = np.append(-z1, np.ones_like(z1), axis=1)
        Y = x[1:].reshape((len(x) - 1, 1))
        # a为发展系数 b为灰色作用量
        [[a], [b]] = np.dot(np.dot(np.linalg.inv(np.dot(B.T, B)), B.T), Y)  # 计算参数
        result = (x[0] - b / a) * np.exp(-a * (n - 1)) - (x[0] - b / a) * np.exp(-a * (n - 2))
        S1_2 = x.var()  # 原序列方差
        e = list()  # 残差序列
        for index in range(1, x.shape[0] + 1):
            predict = (x[0] - b / a) * np.exp(-a * (index - 1)) - (x[0] - b / a) * np.exp(-a * (index - 2))
            e.append(x[index - 1] - predict)
        S2_2 = np.array(e).var()  # 残差方差
        C = S2_2 / S1_2  # 后验差比
        if C <= 0.35:
            assess = '后验差比<=0.35,模型精度等级为好'
        elif C <= 0.5:
            assess = '后验差比<=0.5,模型精度等级为合格'
        elif C <= 0.65:
            assess = '后验差比<=0.65,模型精度等级为勉强'
        else:
            assess = '后验差比>0.65,模型精度等级为不合格'
        # 预测数据
        predict = list()
        for index in range(x.shape[0] + 1, x.shape[0] + n + 1):
            predict.append((x[0] - b / a) * np.exp(-a * (index - 1)) - (x[0] - b / a) * np.exp(-a * (index - 2)))
        predict = np.array(predict)
        return {
            'a': {'value': a, 'desc': '发展系数'},
            'b': {'value': b, 'desc': '灰色作用量'},
            'predict': {'value': result, 'desc': '第%d个预测值' % n},
            'C': {'value': C, 'desc': assess},
            'predict': {'value': predict, 'desc': '往后预测%d个的序列' % (n)},
        }
    
    
    if __name__ == "__main__":
        data = np.array([1.2, 2.2, 3.1, 4.5, 5.6, 6.7, 7.1, 8.2, 9.6, 10.6, 11, 12.4, 13.5, 14.7, 15.2])
        x = data[0:10]  # 输入数据
        y = data[10:]  # 需要预测的数据
        result = GM11(x, len(y))
        predict = result['predict']['value']
        predict = np.round(predict, 1)
        print('真实值:', y)
        print('预测值:', predict)
        print(result)
    
    
    展开全文
  • 灰色关联模型

    千次阅读 2020-05-01 22:56:01
    与传统的多因素统计方法(回归分析、方差分析等)相比,灰色关联分析对样本量的多少样本有无明显的规律要求较低,且计算量小,通常不会出现量化结果与定性分析结果不符的情况,因此应用十分广泛。其基本思想是通过...

    一、灰色关联模型

    1.1 灰色关联分析模型概述

    灰色关联分析是一种多因素统计方法,是灰色系统理论的一个重要分支。与传统的多因素统计方法(回归分析、方差分析等)相比,灰色关联分析对样本量的多少和样本有无明显的规律要求较低,且计算量小,通常不会出现量化结果与定性分析结果不符的情况,因此应用十分广泛。其基本思想是通过计算主因子序列和每个行为因子序列之间的灰色关联度,来判断因子之间关系的强度、大小和顺序。主因子序列和行为因子序列之间的灰色关联度越大,则它们的关系越紧密,行为因子序列对主因子序列的影响越大,反之亦然。

    1.2 灰色关联分析模型的基本步骤

    第一步:确定反映系统行为特征的参考序列 X ( 0 ) X^{\left( 0 \right)} X(0)和影响系统行为的比较序列 X ( m ) X^{\left( m \right)} X(m)
    其中反映系统行为特征的数据序列为参考序列为:
    X 0 = { X 0 ( 1 ) , X 0 ( 2 ) , . . . , X 0 ( n ) } X_0=\{X_0\left( 1 \right) ,X_0\left( 2 \right) ,...,X_0\left( n \right) \} X0={X0(1),X0(2),...,X0(n)}

    影响系统行为的因素组成的数据序列为比较序列为:
    X 1 = { X 1 ( 1 ) , X 1 ( 2 ) , . . . , X 1 ( n ) } X 2 = { X 2 ( 1 ) , X 2 ( 2 ) , . . . , X 2 ( n ) } ⋮ X m = { X m ( 1 ) , X m ( 2 ) , . . . , X m ( n ) } \begin{array}{l} X_1=\{X_1\left( 1 \right) ,X_1\left( 2 \right) ,...,X_1\left( n \right) \}\\ X_2=\{X_2\left( 1 \right) ,X_2\left( 2 \right) ,...,X_2\left( n \right) \}\\ \vdots\\ X_m=\{X_m\left( 1 \right) ,X_m\left( 2 \right) ,...,X_m\left( n \right) \}\\ \end{array} X1={X1(1),X1(2),...,X1(n)}X2={X2(1),X2(2),...,X2(n)}Xm={Xm(1),Xm(2),...,Xm(n)}

    第二步:求各序列的初值像(进行无量纲化处理)。令
    X ′ = X i / X i ( 1 ) = { X i ′ ( 1 ) , X i ′ ( 2 ) , . . . , X i ′ ( n ) } X'=\text{X}_{\text{i}}/X_i\left( 1 \right) =\{X'_i\left( 1 \right) ,X'_i\left( 2 \right) ,...,X'_i\left( n \right) \} X=Xi/Xi(1)={Xi(1),Xi(2),...,Xi(n)}
    其中 i = 0 , 1 , 2 , . . . , m i=0,1,2,...,m i=0,1,2,...,m

    得到
    X 0 ′ , X 1 ′ , . . . , X m ′ X'_0,X'_1,...,X'_m X0,X1,...,Xm

    第三步:求 X 0 X_0 X0 X i X_i Xi的初值像对应分量之差的绝对值序列。

    Δ i ( k ) = ∣ X 0 ′ ( k ) − X i ′ ( k ) ∣ \Delta _i\left( k \right) =\left| X'_0\left( k \right) -X'_i\left( k \right) \right| Δi(k)=X0(k)Xi(k)
    Δ i = ( Δ i ( 1 ) , Δ i ( 2 ) , . . . , Δ i ( n ) )    i = 1 , 2 , . . . , m ; k = 1 , 2 , . . . , n \Delta _i=\left( \Delta _i\left( 1 \right) ,\Delta _i\left( 2 \right) ,...,\Delta _i\left( n \right) \right) \ \ i=1,2,...,m;\text{k}=1,2,...,n Δi=(Δi(1),Δi(2),...,Δi(n))  i=1,2,...,m;k=1,2,...,n
    第四步:求 Δ i ( k ) = ∣ X 0 ′ ( k ) − X i ′ ( k ) ∣ \Delta _i\left( k \right) =\left| X'_0\left( k \right) -X'_i\left( k \right) \right| Δi(k)=X0(k)Xi(k)的最小值与最大值。分别记为
    Δ min ⁡ = min ⁡ i min ⁡ k Δ i ( k ) \Delta _{\min}=\min _i\min _k\Delta _i\left( k \right) Δmin=iminkminΔi(k)
    Δ max ⁡ = max ⁡ i max ⁡ k Δ i ( k ) \Delta _{\max}=\max _i\max _k\Delta _i\left( k \right) Δmax=imaxkmaxΔi(k)
    第五步:求关联系数 ξ i ( k ) \xi _i\left( k \right) ξi(k)
    ξ 0 i ( k ) = Δ min ⁡ + p Δ max ⁡ Δ i ( k ) + p Δ max ⁡ \xi _{0i}\left( k \right) =\frac{\Delta _{\min}+p\Delta _{\max}}{\Delta _i\left( k \right) +p\Delta _{\max}} ξ0i(k)=Δi(k)+pΔmaxΔmin+pΔmax
    其中, p为分辨系数,0< p <1,一般取 p=0.5。

    第六步:求关联度
    γ 0 i = 1 n ∑ k = 1 n ξ 0 i ( k ) \gamma _{0i}=\frac{1}{n}\sum\limits_{k=1}^n{\xi _{0i}\left( k \right)} γ0i=n1k=1nξ0i(k)
    第七步 :按 γ 0 i \gamma _{0i} γ0i大小排序 ,区分其关联程度的大小,若 γ i \gamma _i γi值越大,说明其关联的程度越大;反之 γ i \gamma _i γi值越小,则其关联程度越小

    1.3 应用

    居民消费价格指数主要由八大商品类构成,其中包括:食品、烟酒、衣着、家庭设备用品及维修服务、医疗保健和个人用品、交通和通信、娱乐教育文化用品及服务、居住。根据这八大类,选取重庆居民消费价格指数作为参考序列 X 0 X_0 X0 ,八类消费支出指标作为与之相对应的比较序列 X i X_i Xi ,其中 i = 1,2,…,8

    在这里插入图片描述
    根据灰色关联分析模型计算步骤,将数据导入灰色系统建模软件(专门用于灰色模型的软件),得到如下结果:

    参考序列 X ( 0 ) X^{\left( 0 \right)} X(0) 和比较序列 X ( m ) X^{\left( m \right)} X(m) 的灰色关联度的计算过程如下:

    (1)序列初值像:
    1.0000 1.0203 0.9942 0.9952 0.9864 0.9816 0.9864 ====== X 0 ′ X'_0 X0
    1.0000 1.0714 0.9831 0.9775 0.9700 0.9559 0.9831 ====== X 1 ′ X'_1 X1
    1.0000 0.9942 1.0268 0.9645 0.9377 0.9501 0.9607
    1.0000 1.0295 1.0386 1.0803 1.0366 1.0447 1.0407
    1.0000 1.0200 1.0070 1.0140 1.0030 0.9980 1.0040
    1.0000 0.9951 0.9941 0.9854 0.9922 1.0010 0.9932
    1.0000 0.9960 0.9879 0.9879 1.0080 0.9849 1.0111
    1.0000 0.9630 0.9825 0.9873 0.9747 0.9854 0.9688
    1.0000 0.9839 0.9725 0.9753 0.9639 0.9602 0.9592 ====== X 8 ′ X'_8 X8

    (2)求 X 0 X_0 X0 X i X_i Xi的初值像对应分量之差的绝对值序列。

    Δ i ( k ) = ∣ X 0 ′ ( k ) − X i ′ ( k ) ∣ \Delta _i\left( k \right) =\left| X'_0\left( k \right) -X'_i\left( k \right) \right| Δi(k)=X0(k)Xi(k)

    0.0000 0.0510 0.0111 0.0177 0.0165 0.0257 0.0033 ---------- ∣ X 0 ′ ( k ) − X 1 ′ ( k ) ∣ = Δ 1 |X'_0(k)-X'_1(k)|=\Delta _1 X0(k)X1(k)=Δ1
    0.0000 0.0261 0.0327 0.0306 0.0488 0.0314 0.0257 ---------- ∣ X 0 ′ ( k ) − X 2 ′ ( k ) ∣ = Δ 2 |X'_0(k)-X'_2(k)|=\Delta _2 X0(k)X2(k)=Δ2
    0.0000 0.0091 0.0444 0.0851 0.0502 0.0631 0.0542
    0.0000 0.0004 0.0128 0.0188 0.0166 0.0164 0.0176
    0.0000 0.0252 0.0000 0.0098 0.0058 0.0194 0.0067
    0.0000 0.0244 0.0062 0.0072 0.0216 0.0033 0.0246
    0.0000 0.0573 0.0117 0.0078 0.0118 0.0038 0.0176
    0.0000 0.0365 0.0217 0.0198 0.0225 0.0214 0.0272---------- ∣ X 0 ′ ( k ) − X 8 ′ ( k ) ∣ = Δ 8 |X'_0(k)-X'_8(k)|=\Delta _8 X0(k)X8(k)=Δ8

    (3)求 Δ i ( k ) = ∣ X 0 ′ ( k ) − X i ′ ( k ) ∣ \Delta _i\left( k \right) =\left| X'_0\left( k \right) -X'_i\left( k \right) \right| Δi(k)=X0(k)Xi(k)的最小值与最大值
    Δ min ⁡ = min ⁡ i min ⁡ k Δ i ( k ) = 0.0000 \Delta _{\min}=\min _i\min _k\Delta _i\left( k \right) =0.0000 Δmin=iminkminΔi(k)=0.0000
    Δ max ⁡ = max ⁡ i max ⁡ k Δ i ( k ) = 0.0851 \Delta _{\max}=\max _i\max _k\Delta _i\left( k \right) =0.0851 Δmax=imaxkmaxΔi(k)=0.0851
    (4)关联系数 ξ i ( k ) \xi _i\left( k \right) ξi(k)
    ξ 0 i ( k ) = Δ min ⁡ + p Δ max ⁡ Δ i ( k ) + p Δ max ⁡ \xi _{0i}\left( k \right) =\frac{\Delta _{\min}+p\Delta _{\max}}{\Delta _i\left( k \right) +p\Delta _{\max}} ξ0i(k)=Δi(k)+pΔmaxΔmin+pΔmax
    其中, p为分辨系数,0< p <1,一般取 p=0.5。

    1.0000 0.4549 0.7933 0.7064 0.7209 0.6233 0.9273
    1.0000 0.6199 0.5658 0.5815 0.4661 0.5751 0.6231
    1.0000 0.8235 0.4893 0.3333 0.4591 0.4027 0.4398
    1.0000 0.9909 0.7688 0.6934 0.7199 0.7217 0.7080
    1.0000 0.6279 0.9991 0.8130 0.8808 0.6871 0.8634
    1.0000 0.6359 0.8720 0.8551 0.6633 0.9273 0.6335
    1.0000 0.4260 0.7842 0.8449 0.7837 0.9179 0.7076
    1.0000 0.5385 0.6623 0.6823 0.6543 0.6651 0.6098

    (5) X 0 X_0 X0 X i X_i Xi的邓氏关联度
    关联度
    γ 0 i = 1 n ∑ k = 1 n ξ 0 i ( k ) \gamma _{0i}=\frac{1}{n}\sum\limits_{k=1}^n{\xi _{0i}\left( k \right)} γ0i=n1k=1nξ0i(k)

    0.7466 0.6331 0.564 0.8004 0.8387 0.7982 0.7806 0.6875

    (6)按 γ 0 i \gamma _{0i} γ0i大小排序 ,区分其关联程度的大小,若 γ i \gamma _i γi值越大,说明其关联的程度越大;反之 γ i \gamma _i γi值越小,则其关联程度越小

    最后整理得到重庆市消费结构的灰色关联度及其排序

    在这里插入图片描述
    针对重庆居民价格消费指数与各消费分类指数的关联度的排序结果,可以得出结论。

    展开全文
  • 基于灰色关联熵的煤与瓦斯突出概率神经网络预测模型.pdf
  • 建模比赛中用到的GM(1
  • 基于LSTM的股票预测模型_python实现_超详细

    万次阅读 多人点赞 2019-07-05 22:25:13
    文章目录一、背景二、主要技术介绍1、RNN模型2、LSTM模型3、控制门工作原理四、代码实现五、案例分析...因此本文想利用现有的模型与算法,对股票价格进行预测,从而使自然人股民可以自己对股票进行预测。 理论上,...

    一、背景

    近年来,股票预测还处于一个很热门的阶段,因为股票市场的波动十分巨大,随时可能因为一些新的政策或者其他原因,进行大幅度的波动,导致自然人股民很难对股票进行投资盈利。因此本文想利用现有的模型与算法,对股票价格进行预测,从而使自然人股民可以自己对股票进行预测。
    理论上,股票价格是可以预测的,但是影响股票价格的因素有很多,而且目前为止,它们对股票的影响还不能清晰定义。这是因为股票预测是高度非线性的,这就要预测模型要能够处理非线性问题,并且,股票具有时间序列的特性,因此适合用循环神经网络,对股票进行预测。
    虽然循环神经网络(RNN),允许信息的持久化,然而,一般的RNN模型对具备长记忆性的时间序列数据刻画能力较弱,在时间序列过长的时候,因为存在梯度消散和梯度爆炸现象RNN训练变得非常困难。Hochreiter 和 Schmidhuber 提出的长短期记忆( Long Short-Term Memory,LSTM)模型在RNN结构的基础上进行了改造,从而解决了RNN模型无法刻画时间序列长记忆性的问题。
    综上所述,深度学习中的LSTM模型能够很好地刻画时间序列的长记忆性。

    二、主要技术介绍

    1、RNN模型

    在传统的RNN(循环神经网络)中,所有的w都是同一个w,经过同一个cell的时候,都会保留输入的记忆,再加上另外一个要预测的输入,所以预测包含了之前所有的记忆加上此次的输入。所有RNN都具有一种重复神经网络模块的链式的形式。在标准的RNN中,这个重复的模块只有一个非常简单的结构,例如一个tanh层。
    当权中大于1时,反向传播误差时,误差将会一直放大,导致梯度爆炸;当权中小于1时,误差将会一直缩小,导致梯度消失,进而导致网络权重更新缓慢,无法体现出RNN的长期记忆的效果,使得RNN太过健忘。RNN模型的结构如图:
    在这里插入图片描述

    2、LSTM模型

    长短期记忆模型(long-short term memory)是一种特殊的RNN模型,是为了解决反向传播过程中存在梯度消失和梯度爆炸现象,通过引入门(gate)机制,解决了RNN模型不具备的长记忆性问题,LSTM模型的结构如图:

    图2
    具体来说,LSTM模型的1个神经元包含了1个细胞状态(cell)和3个门(gate)机制。细胞状态(cell)是LSTM模型的关键所在,类似于存储器,是模型的记忆空间。细胞状态随着时间而变化,记录的信息由门机制决定和更新。门机制是让信息选择式通过的方法,通过sigmoid函数和点乘操作实现。sigmoid取值介于0~1之间,乘即点乘则决定了传送的信息量(每个部分有多少量可以通过),当sigmoid取0时表示舍弃信息,取1时表示完全传输(即完全记住)[2]。
    LSTM 拥有三个门,来保护和控制细胞状态:遗忘门(forget gate)、更新门(update gate)和输出门(output gate)。
    细胞状态类似于传送带。直接在整个链上运行,只有一些少量的线性交互。信息在上面流传保持不变会很容易。
    如图:
    在这里插入图片描述

    3、控制门工作原理

    遗忘门
    在这里插入图片描述
    更新门
    在这里插入图片描述
    在这里插入图片描述

    输出门
    在这里插入图片描述

    四、代码实现

    UI

    demo.py
    import tensorflow as tf
    import numpy as np
    import tkinter as tk
    from tkinter import filedialog
    import time
    import pandas as pd
    
    import stock_predict as pred
    
    
    def creat_windows():
        win = tk.Tk()  # 创建窗口
        sw = win.winfo_screenwidth()
        sh = win.winfo_screenheight()
        ww, wh = 800, 450
        x, y = (sw - ww) / 2, (sh - wh) / 2
        win.geometry("%dx%d+%d+%d" % (ww, wh, x, y - 40))  # 居中放置窗口
    
        win.title('LSTM股票预测')  # 窗口命名
    
        f_open =open('dataset_2.csv')
        canvas = tk.Label(win)
        canvas.pack()
    
        var = tk.StringVar()  # 创建变量文字
        var.set('选择数据集')
        tk.Label(win, textvariable=var, bg='#C1FFC1', font=('宋体', 21), width=20, height=2).pack()
    
        tk.Button(win, text='选择数据集', width=20, height=2, bg='#FF8C00', command=lambda: getdata(var, canvas),
                  font=('圆体', 10)).pack()
    
        canvas = tk.Label(win)
        L1 = tk.Label(win, text="选择你需要的 列(请用空格隔开,从0开始)")
        L1.pack()
        E1 = tk.Entry(win, bd=5)
        E1.pack()
        button1 = tk.Button(win, text="提交", command=lambda: getLable(E1))
        button1.pack()
        canvas.pack()
        win.mainloop()
    
    def getLable(E1):
        string = E1.get()
        print(string)
        gettraindata(string)
    
    def getdata(var, canvas):
        global file_path
        file_path = filedialog.askopenfilename()
        var.set("注,最后一个为label")
        # 读取文件第一行标签
        with open(file_path, 'r', encoding='gb2312') as f:
        # with open(file_path, 'r', encoding='utf-8') as f:
            lines = f.readlines()  # 读取所有行
            data2 = lines[0]
        print()
    
        canvas.configure(text=data2)
        canvas.text = data2
    
    def gettraindata(string):
        f_open = open(file_path)
        df = pd.read_csv(f_open)  # 读入股票数据
        list = string.split()
        print(list)
        x = len(list)
        index=[]
        # data = df.iloc[:, [1,2,3]].values  # 取第3-10列 (2:10从2开始到9)
        for i in range(x):
            q = int(list[i])
            index.append(q)
        global data
        data = df.iloc[:, index].values
        print(data)
        main(data)
    
    def main(data):
        pred.LSTMtest(data)
        var.set("预测的结果是:" + answer)
    
    if __name__ == "__main__":
        creat_windows()
    

    stock_predict.py

    import numpy as np
    import matplotlib.pyplot as plt
    import tensorflow as tf
    import pandas as pd
    import math
    
    def LSTMtest(data):
    
        n1 = len(data[0]) - 1 #因为最后一位为label
        n2 = len(data)
        print(n1, n2)
    
        # 设置常量
        input_size = n1  # 输入神经元个数
        rnn_unit = 10    # LSTM单元(一层神经网络)中的中神经元的个数
        lstm_layers = 7  # LSTM单元个数
        output_size = 1  # 输出神经元个数(预测值)
        lr = 0.0006      # 学习率
    
        train_end_index = math.floor(n2*0.9)  # 向下取整
        print('train_end_index', train_end_index)
        # 前90%数据作为训练集,后10%作为测试集
        # 获取训练集
        # time_step 时间步,batch_size 每一批次训练多少个样例
        def get_train_data(batch_size=60, time_step=20, train_begin=0, train_end=train_end_index):
            batch_index = []
            data_train = data[train_begin:train_end]
            normalized_train_data = (data_train - np.mean(data_train, axis=0)) / np.std(data_train, axis=0)  # 标准化
            train_x, train_y = [], []  # 训练集
            for i in range(len(normalized_train_data) - time_step):
                if i % batch_size == 0:
                    # 开始位置
                    batch_index.append(i)
                    # 一次取time_step行数据
                # x存储输入维度(不包括label) :X(最后一个不取)
                # 标准化(归一化)
                x = normalized_train_data[i:i + time_step, :n1]
                # y存储label
                y = normalized_train_data[i:i + time_step, n1, np.newaxis]
                # np.newaxis分别是在行或列上增加维度
                train_x.append(x.tolist())
                train_y.append(y.tolist())
            # 结束位置
            batch_index.append((len(normalized_train_data) - time_step))
            print('batch_index', batch_index)
            # print('train_x', train_x)
            # print('train_y', train_y)
            return batch_index, train_x, train_y
    
        # 获取测试集
        def get_test_data(time_step=20, test_begin=train_end_index+1):
            data_test = data[test_begin:]
            mean = np.mean(data_test, axis=0)
            std = np.std(data_test, axis=0)  # 矩阵标准差
            # 标准化(归一化)
            normalized_test_data = (data_test - np.mean(data_test, axis=0)) / np.std(data_test, axis=0)
            # " // "表示整数除法。有size个sample
            test_size = (len(normalized_test_data) + time_step - 1) // time_step
            print('test_size$$$$$$$$$$$$$$', test_size)
            test_x, test_y = [], []
            for i in range(test_size - 1):
                x = normalized_test_data[i * time_step:(i + 1) * time_step, :n1]
                y = normalized_test_data[i * time_step:(i + 1) * time_step, n1]
                test_x.append(x.tolist())
                test_y.extend(y)
            test_x.append((normalized_test_data[(i + 1) * time_step:, :n1]).tolist())
            test_y.extend((normalized_test_data[(i + 1) * time_step:, n1]).tolist())
            return mean, std, test_x, test_y
    
        # ——————————————————定义神经网络变量——————————————————
        # 输入层、输出层权重、偏置、dropout参数
        # 随机产生 w,b
        weights = {
            'in': tf.Variable(tf.random_normal([input_size, rnn_unit])),
            'out': tf.Variable(tf.random_normal([rnn_unit, 1]))
        }
        biases = {
            'in': tf.Variable(tf.constant(0.1, shape=[rnn_unit, ])),
            'out': tf.Variable(tf.constant(0.1, shape=[1, ]))
        }
        keep_prob = tf.placeholder(tf.float32, name='keep_prob')  # dropout 防止过拟合
    
        # ——————————————————定义神经网络——————————————————
        def lstmCell():
            # basicLstm单元
            # tf.nn.rnn_cell.BasicLSTMCell(self, num_units, forget_bias=1.0,
            # tate_is_tuple=True, activation=None, reuse=None, name=None) 
            # num_units:int类型,LSTM单元(一层神经网络)中的中神经元的个数,和前馈神经网络中隐含层神经元个数意思相同
            # forget_bias:float类型,偏置增加了忘记门。从CudnnLSTM训练的检查点(checkpoin)恢复时,必须手动设置为0.0。
            # state_is_tuple:如果为True,则接受和返回的状态是c_state和m_state的2-tuple;如果为False,则他们沿着列轴连接。后一种即将被弃用。
            # (LSTM会保留两个state,也就是主线的state(c_state),和分线的state(m_state),会包含在元组(tuple)里边
            # state_is_tuple=True就是判定生成的是否为一个元组)
            #   初始化的 c 和 a 都是zero_state 也就是都为list[]的zero,这是参数state_is_tuple的情况下
            #   初始state,全部为0,慢慢的累加记忆
            # activation:内部状态的激活函数。默认为tanh
            # reuse:布尔类型,描述是否在现有范围中重用变量。如果不为True,并且现有范围已经具有给定变量,则会引发错误。
            # name:String类型,层的名称。具有相同名称的层将共享权重,但为了避免错误,在这种情况下需要reuse=True.
            #
    
            basicLstm = tf.nn.rnn_cell.BasicLSTMCell(rnn_unit, forget_bias=1.0, state_is_tuple=True)
            # dropout 未使用
            drop = tf.nn.rnn_cell.DropoutWrapper(basicLstm, output_keep_prob=keep_prob)
            return basicLstm
    
       
    
        def lstm(X):  # 参数:输入网络批次数目
            batch_size = tf.shape(X)[0]
            time_step = tf.shape(X)[1]
            w_in = weights['in']
            b_in = biases['in']
    
            # 忘记门(输入门)
            # 因为要进行矩阵乘法,所以reshape
            # 需要将tensor转成2维进行计算
            input = tf.reshape(X, [-1, input_size])
            input_rnn = tf.matmul(input, w_in) + b_in
            # 将tensor转成3维,计算后的结果作为忘记门的输入
            input_rnn = tf.reshape(input_rnn, [-1, time_step, rnn_unit])
            print('input_rnn', input_rnn)
            # 更新门
            # 构建多层的lstm
            cell = tf.nn.rnn_cell.MultiRNNCell([lstmCell() for i in range(lstm_layers)])
            init_state = cell.zero_state(batch_size, dtype=tf.float32)
    
            # 输出门
            w_out = weights['out']
            b_out = biases['out']
            # output_rnn是最后一层每个step的输出,final_states是每一层的最后那个step的输出
            output_rnn, final_states = tf.nn.dynamic_rnn(cell, input_rnn, initial_state=init_state, dtype=tf.float32)
            output = tf.reshape(output_rnn, [-1, rnn_unit])
            # 输出值,同时作为下一层输入门的输入
            pred = tf.matmul(output, w_out) + b_out
            return pred, final_states
    
        # ————————————————训练模型————————————————————
    
        def train_lstm(batch_size=60, time_step=20, train_begin=0, train_end=train_end_index):
            # 于是就有了tf.placeholder,
            # 我们每次可以将 一个minibatch传入到x = tf.placeholder(tf.float32,[None,32])上,
            # 下一次传入的x都替换掉上一次传入的x,
            # 这样就对于所有传入的minibatch x就只会产生一个op,
            # 不会产生其他多余的op,进而减少了graph的开销。
    
            X = tf.placeholder(tf.float32, shape=[None, time_step, input_size])
            Y = tf.placeholder(tf.float32, shape=[None, time_step, output_size])
            batch_index, train_x, train_y = get_train_data(batch_size, time_step, train_begin, train_end)
            # 用tf.variable_scope来定义重复利用,LSTM会经常用到
            with tf.variable_scope("sec_lstm"):
                pred, state_ = lstm(X) # pred输出值,state_是每一层的最后那个step的输出
            print('pred,state_', pred, state_)
    
            # 损失函数
            # [-1]——列表从后往前数第一列,即pred为预测值,Y为真实值(Label)
            #tf.reduce_mean 函数用于计算张量tensor沿着指定的数轴(tensor的某一维度)上的的平均值
            loss = tf.reduce_mean(tf.square(tf.reshape(pred, [-1]) - tf.reshape(Y, [-1])))
            # 误差loss反向传播——均方误差损失
            # 本质上是带有动量项的RMSprop,它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。
            # Adam的优点主要在于经过偏置校正后,每一次迭代学习率都有个确定范围,使得参数比较平稳.
            train_op = tf.train.AdamOptimizer(lr).minimize(loss)
            saver = tf.train.Saver(tf.global_variables(), max_to_keep=15)
    
            with tf.Session() as sess:
                # 初始化
                sess.run(tf.global_variables_initializer())
                theloss = []
                # 迭代次数
                for i in range(200):
                    for step in range(len(batch_index) - 1):
                        # sess.run(b, feed_dict = replace_dict)
                        state_, loss_ = sess.run([train_op, loss],
                                            feed_dict={X: train_x[batch_index[step]:batch_index[step + 1]],
                                                       Y: train_y[batch_index[step]:batch_index[step + 1]],
                                                       keep_prob: 0.5})
                                            #  使用feed_dict完成矩阵乘法 处理多输入
                                            #  feed_dict的作用是给使用placeholder创建出来的tensor赋值
    
    
                                            #  [batch_index[step]: batch_index[step + 1]]这个区间的X与Y
                                            #  keep_prob的意思是:留下的神经元的概率,如果keep_prob为0的话, 就是让所有的神经元都失活。
                    print("Number of iterations:", i, " loss:", loss_)
                    theloss.append(loss_)
                print("model_save: ", saver.save(sess, 'model_save2\\modle.ckpt'))
                print("The train has finished")
            return theloss
    
        theloss = train_lstm()
    
        # ————————————————预测模型————————————————————
        def prediction(time_step=20):
    
            X = tf.placeholder(tf.float32, shape=[None, time_step, input_size])
            mean, std, test_x, test_y = get_test_data(time_step)
            # 用tf.variable_scope来定义重复利用,LSTM会经常用到
            with tf.variable_scope("sec_lstm", reuse=tf.AUTO_REUSE):
                pred, state_ = lstm(X)
            saver = tf.train.Saver(tf.global_variables())
            with tf.Session() as sess:
                # 参数恢复(读取已存在模型)
                module_file = tf.train.latest_checkpoint('model_save2')
                saver.restore(sess, module_file)
                test_predict = []
                for step in range(len(test_x) - 1):
                    predict = sess.run(pred, feed_dict={X: [test_x[step]], keep_prob: 1})
                    predict = predict.reshape((-1))
                    test_predict.extend(predict)  # 把predict的内容添加到列表
    
                # 相对误差=(测量值-计算值)/计算值×100%
                test_y = np.array(test_y) * std[n1] + mean[n1]
                test_predict = np.array(test_predict) * std[n1] + mean[n1]
                acc = np.average(np.abs(test_predict - test_y[:len(test_predict)]) / test_y[:len(test_predict)])
                print("预测的相对误差:", acc)
    
                print(theloss)
                plt.figure()
                plt.plot(list(range(len(theloss))), theloss, color='b', )
                plt.xlabel('times', fontsize=14)
                plt.ylabel('loss valuet', fontsize=14)
                plt.title('loss-----blue', fontsize=10)
                plt.show()
                # 以折线图表示预测结果
                plt.figure()
                plt.plot(list(range(len(test_predict))), test_predict, color='b', )
                plt.plot(list(range(len(test_y))), test_y, color='r')
                plt.xlabel('time value/day', fontsize=14)
                plt.ylabel('close value/point', fontsize=14)
                plt.title('predict-----blue,real-----red', fontsize=10)
                plt.show()
    
    
    
        prediction()
    

    五、案例分析

    1、数据说明
    本实验分析了两种股票种类,为某单支股票(6109个连续时间点)数据data2上证综合指数前复权日线(6230个连续时间点,1991年到2016年)数据作为data2,分别保存在两个文件中,将两个数据集的最后一列设定为label。前90%数据作为训练集,后10%作为测试集。
    Data1:
    在这里插入图片描述
    Data2:
    在这里插入图片描述
    本次实验所采用的为LSTM模型:
    输入神经元个数 input_size = 选取列数
    输出神经元个数 output_size = 1 (预测值个数)
    学习率 lr = 0.0006
    随机初始化初始化网络权重

    2、数据预处理
    零-均值规范化(z-score标准化):
    标准化值,是讲集合中单个数与集合的均值相减的结果除以集合的标准差得到的标准化的结果,该方法类似与正态分布标准化转换,转换函数公式为:
    在这里插入图片描述
    公式中x为需要被标准化的原始值,μ为均值,σ为标准差,σ不等于0。
    Z分数标准化处理后的值代表原始值和集合均值之间的举例,以标准差为单位计算。该值存在正负值,低于均值均为辅助,反之则为证书,其范围为[-∞,+∞],数据均值为0,方差为1。
    3、损失函数
    损失函数(Loss function)是用来估量网络模型的预测值X与真实值Y的不一致程度,它是一个非负实值函数,通常用 L(Y,f(x))来表示。损失函数越小,模型的鲁棒性就越好。损失函数是经验风险函数的核心部分,也是结构风险函数的重要组成部分。
    本实验采取十分常用的均方误差损失
    平方损失也可以理解为是最小二乘法,一般在回归问题中比较常见,最小二乘法的基本原理是:最优拟合直线是使各点到回归直线的距离和最小的直线,即平方和最。同时在实际应用中,均方误差也经常被用为衡量模型的标准:
    在这里插入图片描述

    4、误差标准
    相对偏差是指某一次测量的绝对偏差占平均值的百分比。
    在这里插入图片描述
    5、可视化UI
    在这里插入图片描述
    在这里插入图片描述

    六、参数设置

    1、输入维度及迭代次数
    在这里插入图片描述
    由表一可见,输入维度越多,网络训练效果越好;迭代次数在100次时,网络已经比较稳定。
    2、忘记偏置
    在这里插入图片描述
    由表二可见,在data1(单支股票)forget_bias适当减小,即忘记部分信息,网络训练效果有些许提高,但在data2(大盘)中,网络训练效果却有所下滑。个人认为,可能是因为对于单支股票来说,近2天的数据相关程度比较小,而在大盘中,因为近2天的数据相关程度比较大,毕竟有多方面因素影响股价。
    3、LSTM单元数
    在这里插入图片描述

    由表三可见,两个数据集中,LSTM单元数增加的情况下时,网络训练效果反而下降,可以看出,其实股票行情在7天内的的相关联程度比在14天内的情况高,但是有可能是因为forget_bias过大。因此,在进行一组实验,调整forget_bias值进行比较。
    在这里插入图片描述
    由表四可以看出,在相同LSTM单元数的情况下,forget_bias较小时,预测效果较好,我们可以看出,在LSTM单元数较大的情况下,forget_bias应选取比较小的,以免记忆太多无效信息。
    在这里插入图片描述
    由表五可以看出,在data1和data2两个数据集中,LSTM单元数较小的情况下,forget_bias比较大时,预测效果较好,记忆更多相关信息。因此LSTM单元数较小的情况下,forget_bias应选取比较大的,记忆更多相关信息。

    4、可视化结果
    选取数据集data1,迭代次数为200次

    (1)、忘记偏置=1.0 , LSTM单元数 = 2
    在这里插入图片描述

    (2)、忘记偏置=0.7 , LSTM单元数 = 2(表现最好)
    在这里插入图片描述
    (3)、忘记偏置=1.0 , LSTM单元数 = 7
    在这里插入图片描述
    (4)、忘记偏置=1.0 , LSTM单元数 = 14
    在这里插入图片描述

    (5)、忘记偏置=0.7, LSTM单元数 = 7
    在这里插入图片描述
    (6)、忘记偏置=0.4 , LSTM单元数 = 7
    在这里插入图片描述
    (7)、忘记偏置=0.4 , LSTM单元数 = 14
    在这里插入图片描述

    七、结论

    针对以上实验,可以得知,在LSTM模型下的对股票收盘价预测值较为准确和稳定。对LSTM模型进行参数调整,发现迭代次数在100次后,网络模型趋于稳定,说明其是一个较轻量级的网络;在LSTM单元数较大的情况下,forget_bias应选取比较小的,以免记忆太多无效信息;LSTM单元数较小的情况下,forget_bias应选取比较大的,记忆更多相关信息。当然,这和本身的数据集有关。就股票数据集来说,本实验中表现的最优秀的是,忘记偏置为0.7,LSTM神经单元数取2时,网络预测效果最好,说明,在2天内股票序列是比较有价值的,与最后预测值有一定程度的联系。

    完整程序下载

    注意,代码下载后仍需自行调试~
    积分值为5(如果有变为csdn自行修改)——完整代码其实和上面贴出的差别不大,酌情下载~

    https://download.csdn.net/download/zxm_jimin/12126063

    参考文献
    [1] 陈卫华. 基于深度学习的上证综指波动率预测效果比较研究[D].统计与信息论坛,2018.
    [2] Hochreiter & Schmidhuber. Long short-term memory[ J]. Neural Computation, 1997, 9( 8).

    参考博客
    https://blog.csdn.net/jiaoyangwm/article/details/79725445
    https://blog.csdn.net/mylove0414/article/details/56969181

    感谢各位大佬看到最后~
    本文为原创。转载请注明出处。
    注:原理部分,参考了一些文章,博客,如有侵权请联系,我附上原出处。

    展开全文
  • 考虑了关联度对预测中心动力学行为的影响,提出用关联度来定义权重的方法,建立了一个用来预测网络流量新型的加权局域线性模型。模拟试验结果表明,传统加权模型相比,当嵌入维数较高的时候,该模型能在较大程度上提高...
  • 在这项研究中,通过整合已知的人类miRNA-疾病关联,miRNA功能相似性,疾病语义相似性高斯相互作用谱对miRNA疾病的相似性,提出了基于路径的miRNA-疾病关联(PBMDA)预测模型。 该模型构建了一个由三个相互关联...
  • 简介:本篇文章简单的介绍灰色关联以及灰色预测模型,并且使用python代码进行实现。 1. 灰色系统的概论 2. 关于灰色关联度那些事 3. GM(1,1)模型简介以及相关实现 4. GM(1,N)模型简介以及相关实现、 5,模型...
  • 【数学建模】灰色预测模型(预测)

    万次阅读 多人点赞 2020-08-02 16:43:07
    灰色预测模型2.灰色系统理论3. 针对类型4. 灰色系统5. 灰色生成6. 累加生成7. GM(1,1)模型推导精度检验精度检验等级参照表二、适用问题三、算法总结1. 步骤四、应用场景举例1. 累加生成2. 建立GM(1,1)模型3. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,780
精华内容 32,312
关键字:

关联模型和预测模型