精华内容
下载资源
问答
  • 其中有相关因素的预测模型和参数估计算法和建立多元线性回归方程或ARMA模型。 预测农产品或副产品价格。如果对与大学里面数学建模的同学特别有用。在做有关价格预测问题时,可作为参考,同时也可直接使用。
  • 煤炭是我国重要的基础能源,环渤海动力煤价格是全国煤炭价格变动的风向标。通过分析影响环渤海动力煤价格变动的指标,构建出环渤海动力煤现货价格多元线性回归预测模型,并对下阶段进一步完善模型提出建议。
  • 一,基本概念 1-时间序列相关概念 时间序列的主要目的是进行预测 时间序列主要分为两大类: 平稳序列与非平稳序列 本文重点研究非平稳时间序列 时间序列的预测方法: ...2-灰色预测及分析模型 二,模型学习思考 ...

    一,基本概念与模型

    1-时间序列相关概念

    在这里插入图片描述
    时间序列的主要目的是进行预测
    时间序列主要分为两大类: 平稳序列与非平稳序列
    本文重点研究非平稳时间序列
    在这里插入图片描述
    时间序列的预测方法:
    在这里插入图片描述

    2-灰色关联分析模型

    1.2.1 灰色关联简介

    在系统发展过程中,若两个因素变化的趋势具有一致性,即同步变化程度较高,即可谓二者关联程度较高;反之,则较低。因此,灰色关联分析方法,是根据各因素之间发展趋势的相似或相异程度,亦即“灰色关联度”,作为衡量因素间关联程度的一种方法。可依此来寻找一个指标的变化趋势与各种因素关联程度的大小关系
    #### 1.2.2 灰色关联分析步骤

    1. 首先找出问题中的参考对象(该对象有m个指标),与n个实际对象(也有m个指标),目的便是根据这n个实际对象各指标与参考对象各指标间的关联度,来分析各实际对象与参考对象之间的关联程度。应用于
      ①根据与参考对象(通常为最优对象)的关联程度择优选择个体,如对6位教师工作状况进行综合分析并选拔
      ②根据关联度大的实际对象调整改变参考对象的各指标数值,如CPI变化主要受何种因素影响(即本文下面研究)
    2. 确认各指标的权重大小(可有可无)
    3. 对对象的各指标值进行无量纲处理,使指标值处于同一量度下
      常用的无量纲化方法有均值化法(见(12-3)式—将该对象的各指标求和取平均值,将各指标与指标平均值相除)、初值化法(见(12-4)式–挺怪的)和 在这里插入图片描述变换等.
      在这里插入图片描述
      4. 逐个计算每个实际对象指标序列与参考对象的指标序列对应元素的绝对差值。
      在这里插入图片描述
      5. 计算指标关联度
      分别计算每个十几对象与参考对象对应指标的关联系数。
      在这里插入图片描述
      其中 ρ为分辨系数,0<ρ<1。若ρ越小,关联系数间差异越大,区分能力越强。通常ρ取0.5。这里有遗留问题…
      6. 计算对象关联度
      对各实际对象,各指标与参考对象的各指标关联度 求和并求均值,以反映各实际对象与参考对象的关联关系,并称其为关联序,记为:
      在这里插入图片描述
      1. 如果各指标在综合评价中所起的作用不同,可对关联系数求加权平均值即在这里插入图片描述
        参考博客:灰色关联分析

    3-时间序列指数平滑 预测模型

    在讲指数平滑预测模型之前,需要对时间序列预测做下系统阐述:
    时间序列预测法是分析反映事物在历史上各个时期状况的资料,研究事物是如何从昨天演变到今天的,找出事物随时间而变化的规律,然后据此预测事物的未来发展趋势。其具体预测方法有如下几种:
    (1)简单平均法。这种方法假设事物在历史上各个时期的状况对未来的影响程度是相同的,因此在预测时,将反映事物在历史上各个时期状况的数据看得同等重要,用它们的简单算术平均值来作为下一时期的预测值。
    这种方法比较简单,但准确程度较低,特别是当时间序列呈某种上升、下降或周期性变化趋势时.预测结果就很不可靠,所以一般只能用于短期预测。
    (2)移动平均法。这种方法假设事物在历史上比较远的时期的状况,对未来基本上没有影响,有影响的只是近期的状况。与简单平均法相比,单纯移动平均法虽然反映了时间序列中最新数据的影响,但由于将第t期的一次移动平均值直接作为第t+1期的预测值,因而当时间序列呈明显的线性趋势时,预测值就会产生滞后偏差。为了消除这种滞后偏差,可运用趋势修正移动平均进行预测。
    (3)指数平滑法。同简单平均法一样,指数平滑法也假设事物在历史上各个时期的状况均会影响未来,只是影响程度不同,远期的影响要小些,近期的影响要大些。所以,在预测时给近期的数据以较大的权数。给远期的数据以较小的权数,算出第1期至第t期的加权平均数,作为t+1期的预测值
    而在这些预测法之下,又有细致分类:比如说移动平均法分一次二次多次;指数平滑法也分一次二次多次…但其基本原理与目的都大同小异,产生这种n次xxx法的原因大致如下图所示:
    在这里插入图片描述
    1.3.1 指数平滑的定义

    产生背景:指数平滑由布朗提出、他认为时间序列的态势具有稳定性或规则性,所以时间序列可被合理地顺势推延;他认为最近的过去态势,在某种程度上会持续的未来,所以将较大的权数放在最近的数据。

    基本原理:指数平滑法是移动平均法中的一种,其特点在于给过去的观测值不一样的权重,即较近期观测值的权数比较远期观测值的权数要大。根据平滑次数不同,指数平滑法分为一次指数平滑法、二次指数平滑法和三次指数平滑法等。但它们的基本思想都是:预测值是以前观测值的加权和,且对不同的数据给予不同的权数,新数据给予较大的权数,旧数据给予较小的权数

    方法应用:指数平滑法是生产预测中常用的一种方法。也用于中短期经济发展趋势预测,所有预测方法中,指数平滑是用得最多的一种。

    1.3.2 指数平滑类型
    初期平滑值:不管什么指数平滑都会有个初值,假如数据大于20项,那么初值就可以认定为第一个数据,或者利用下列公式计算也行;假如数据小于20项,则初始值为:在这里插入图片描述
    低于20项一般取3,大于20的看着取就行了。

    1. 一次指数平滑----求解水平型曲线

    在这里插入图片描述
    本期预测值等于上期的平滑值,这里可以发现,我们需要手动设置第一期的预测值,即第0期的平滑值。一般取前三次或前两次的实际值求和取平均。
    数据变化越大,则设置alpha值越大----alpha 的取值常根据实际与预测的误差值来进行选择。

    1. 二次指数平滑----求解斜坡型趋势曲线
      + 一次指数平滑的局限性
      像一次移动平均法一样,一次指数平滑法只适用于水平型历史数据(变化程度不陡)的预测,预测的时间序列为一条直线,不能反映时间序列的趋势和季节性,而不适用于斜坡型线性趋势历史数据的预测。因为对于明显呈斜坡型的历史数据,即使a数值很大(接近于1)仍然会产生较大的系统误差 。
      + 二次指数平滑公式
      在一次指数平滑的基础上再进行二次指数平滑,利用滞后偏差的规律找出曲线的发展方向和发展趋势,然后建立直线趋势预测模型,故称为二次指数平滑法。
      在一次指数平滑的基础上得二次指数平滑 的计算公式为: 在这里插入图片描述
      模型整体公式如下:在这里插入图片描述
      + 三次指数平滑—求解非线性趋势预测
      若时间序列的变动呈现出二次曲线(非线性)趋势,则需要采用三次指数平滑法进行预测。三次指数平滑是在二次指数平滑的基础上再进行一次平滑。
      公式如下:在这里插入图片描述
      参考博客:指数平滑法
      补:移动平均法—周期或者不规则变动的曲线在这里插入图片描述
      显然,时间序列的预测模型还有很多值得深入的地方,仍需学习。

    二,模型实际应用学习思考

    2.1 灰色关联分析模型

    问题:CPI主要受哪些商品影响,关联程度如何?

    1. 首先,因为本问题主要研究食品对CPI的影响,所以这里先初步分析,将食品价格变动曲线与CPI变动曲线画出来,比较发现,两者曲线变动趋势有一定相似性。
    2. 接着,对其进行深入分析,将影响CPI的各对象与CPI的关联程度都求出来,比较一下,看看食品对CPI的影响程度处在什么水平
    3. 根据结果发现,食品对CPI的影响低于其他因素。分析得:在这里插入图片描述
    4. 接下来可深入分析,在影响食品价格变动的各类食物中,究竟是哪类影响程度更大,并进行原因分析

    2.2 时间序列指数平滑 预测模型

    遗留问题:

    1. 为何选择最优指标为标准,就不用求两级最小值与两级最大值?
    2. 无量纲处理的方法为什么是这样的?与一般处理有什么区别?对数据有什么不良影响
    展开全文
  • 论文研究-基于Bagging与决策树算法的在线拍卖成交价格预测模型.pdf, 通过分析在线拍卖出价特点,利用决策树和Bagging算法建立了一种全新的在线拍卖成交价格预测模型.作者...
  • 为了进一步提升原油期货价格预测的精准性,本文基于CEEMDAN分解算法和ELM极限学习机模型,利用PSO粒子群优化算法对机器学习模型进行参数寻优,进而构建了CEEMDAN-PSO-ELM模型用于原油期货价格预测.先基于CEEMDAN算法...
  • 本文基于小波分析和改进的基于PSO的神经网络,提出了基于小波分析的股指期货价格预测模型。 通过使用沪深300股指期货的统计数据作为样本,使用sym 8小波变换技术对统计数据进行降噪,然后使用降噪后的统计数据来...
  • 流行的理论是,股票价格是完全随机且不可预测的,但这提出了一个问题,为什么摩根士丹利和花旗集团这样的顶级公司会聘请定量分析师来建立预测模型。 我们的想法是,交易大厅里充斥着肾上腺素的男人,他们之间的联系...
  • 基于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

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

    展开全文
  • K近邻模型、KNN算法1-构建预测模型

    千次阅读 2019-11-17 07:55:14
    K近邻模型、KNN算法1-构建预测模型 案例 假设你已经清洗好了一份同类型的商品信息和价格数据,如果给一个同品类全新的商品,你如何给它定价或预测它的价格? 比如,这个商品是红酒。你已经获取到了一批红酒的评级...

    K近邻模型、KNN算法1-构建预测模型

    案例

    假设你已经清洗好了一份同类型的商品信息和价格数据,如果给一个同品类全新的商品,你如何给它定价或预测它的价格?

    比如,这个商品是红酒。你已经获取到了一批红酒的评级、生产年份、瓶装大小等红酒属性数据,以及对应的红酒价格。现在请根据这个样本数据对一瓶红酒进行价格预测、价格区间概率预测。

    思路逻辑图

    Python代码

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    #@Time: 2019-11-18 07:07
    #@Author: gaoll
    
    import time
    import random
    from random import randint
    import math
    import numpy as np
    import matplotlib.pyplot as plt
    
    #定义距离函数. 
    def euclidean(v1,v2):
    	d = 0.0
    	for i in range(len(v1)):
    		d+=(v1[i]-v2[i])**2
    	return math.sqrt(d)
    
    #计算距离。KNN算法距离计算完保存起来,使用时无需再计算
    def getdistances(data,vec1,distance=euclidean):
    	distancelist = []
    	for i in range(len(data)):
    		vec2=data[i]['input']
    		d = distance(vec1,vec2)
    		distancelist.append((d,i))
    	distancelist.sort()
    	return distancelist
    
    #定义权重公式
    #反函数
    def inverseweight(dist,num=1.0,const=0.1):
    	return num/(dist+const)
    #减法函数
    def substractweight(dist,const=1.0):
    	if dist>const:
    		return 0 
    	else:
    		return const - dist
    #高斯函数
    def gaussian(dist,sigma=10.0):
    	return math.e**(-dist**2/(2*sigma**2))
    
    #创建KNN函数,根据前k项估计,加权knn
    def createweightedknn(k,weighf=gaussian):
    	def weightedknn(data,vec1):
    			#按照距离值经过排序的列表
    		dlist = getdistances(data,vec1)
    		avg = 0
    		total_weight = 0.0
    		for i in range(k):
    			(dist,id) = dlist[i]
    			weight = weighf(dist)
    			avg+=data[id]['result']*weight
    			total_weight += weight
    		avg = avg/total_weight
    		return avg
    	return weightedknn
    
    #交叉验证--拆分测试集和训练集
    def dividedata(data,test=0.05):
    	trainset = []
    	testset = []
    	for row in data:
    		if random.random()<test:
    			testset.append(row)
    		else:
    			trainset.append(row)
    	return trainset,testset
    
    #定义评估函数。此处使用误差平方和函数
    def testalgorithm(algf,trainset,testset):
    	error =0
    	for row in testset:
    		vec = row['input']
    		guess = algf(trainset,vec)
    		error += (guess - row['result'])**2
    	return error
    
    #交叉验证
    def crossvalidate(algf,data,trials=100,test=0.05):
    	error = 0
    	for i in range(trials):
    		trainset,testset = dividedata(data,test)
    		error += testalgorithm(algf,trainset,testset)
    	if error ==0:
    		return 0
    	return error/trials
    
    #数据各列按一定比例放缩
    def rescale(data,scale):
    	scaled_data = []
    	for row in data:
    		scaled_input = [row['input'][i]*scale[i] for i in range(len(scale))]
    		scaled_data.append({'input':scaled_input,'result':row['result']})
    	return scaled_data
    
    #对向量做放缩
    def rescale_vec(vec,scale):
    	return [vec[i]*scale[i] for i in range(len(scale))]
    
    #定义scale损失函数
    def createcostf_scale(algf,data):
    	def costf_scale(scale):
    		scaled_data = rescale(data,scale)
    		return crossvalidate(algf,scaled_data,trials=10)
    	return costf_scale
    
    #定义k的损失函数
    def createcostf_k(data,algf=createweightedknn):
    	def costf_k(k):
    		weightedknn = algf(k=k,weighf=gaussian)
    		return crossvalidate(weightedknn,data)
    	return costf_k
    
    #区间概率预测
    def probguess(data,vec1,low,high,k=3,weightf=gaussian):
    	dlist = getdistances(data,vec1)
    	inweight = 0.0
    	totalweight= 0.0
    	for i in range(k):
    		(dist,id) = dlist[i]
    		weight = weightf(dist)
    		v = data[id]['result']
    		if v>=low and v<=high:
    			inweight += weight
    		totalweight += weight
    	if inweight == 0:
    		return 0
    	return inweight/totalweight
    
    #根据区间概率预测,绘制累计概率图
    def cumulativegragh(data,vec1,high,k=3,weightf=gaussian):
    	x = np.arange(0.0,high,0.1)
    	y = [probguess(data,vec1,0.0,t,k=k,weightf=weightf) for t in x]
    	fig = plt.figure()
    	ax=fig.add_subplot(1,1,1)
    	ax.plot(x,y)
    	fig.show()
    
    #使用KNN思想,绘制概率密度图
    def probalitygragh(data,vec1,high,k=3,weightf=gaussian,ss=5.0):
    	x = np.arange(0.0,high,0.1)
    	#得到每个小区间上的概率
    	probs = [probguess(data,vec1,v,v+0.1,k,weightf) for v in x]
    	#做平滑处理,即加上近邻概率的高斯权重
    	smoothed = []
    	for i in range(len(probs)):
    		sv = 0.0
    		for j in range(0,len(probs)):
    			dist = abs(i-j)*0.1
    			weight = weightf(dist,sigma=ss)
    			sv+=weight*probs[j]
    		smoothed.append(sv)
    	fig = plt.figure()
    	ax = fig.add_subplot(1,1,1)
    	ax.plot(x,smoothed)
    	fig.show()
    
    
    
    if __name__ == "__main__":
    	#记载数据
    	import wineprice
    	data = wineprice.wineset3()
    
    	#优化K,确定K的大致范围,这里设2-7
    	costf_k = createcostf_k(data,createweightedknn)
    	for i in range(2,8):
    		print(i,costf_k(i))
    
    	'''out:从简单从小,这里k=4交叉验证损失最小
    	2 62368.44691765818
    	3 66027.43378150972
    	4 61087.78286215031
    	5 65923.3855665127
    	6 67817.68744348118
    	7 67395.5927600834
    	'''
    	#以上述得出的k=4为基础,优化scale
    	import optimization 
    	weightedknn = createweightedknn(k=4)
    	domain = [(0,20)]*4
    	costf_scale = createcostf_scale(weightedknn,data)
    	#使用模拟退火算法优化缩放系数。--见前面的博文-优化算法
    	optimization.annealingoptimize(domain,costf_scale)
    	#Out[150]: [1, 13, 12, 0]
    
    	#K和放缩比例相互影响,这个确定的过程比较繁琐,可能要重复几次。
    	#这里经过3次相互交叉验证后,决定使用 k=3,scale=[8, 4, 3, 2]。
    	k = 3
    	scale = [8, 4, 3, 2]
    
    	scaled_data = rescale(data,scale)
    	weightedknn = createweightedknn(k=3,weighf=gaussian)
    	#交叉验证
    	crossvalidate(weightedknn,scaled_data)
    	#Out[153]: 62935.15164770742
    
    	#knn数值预测
    	TobePredict=[90, 35, 13, 3000.0]
    	scaled_tobepredict = rescale_vec(TobePredict,scale) #放缩
    	print(weightedknn(scaled_data,scaled_tobepredict))  #预测
    	#188.3792652896066
    
    	#价格区间预测
    	probguess(scaled_data,scaled_tobepredict,100,150)
    	#Out[106]: 1.2491095402673855e-05
    	probguess(scaled_data,scaled_tobepredict,100,180)
    	#Out[107]: 0.3000429516680889
    	probguess(scaled_data,scaled_tobepredict,100,200)
    	#Out[108]: 1.0
    
    	#累计概率图
    	cumulativegragh(scaled_data,scaled_tobepredict,300)
    
    	#概率密度图
    	probalitygragh(scaled_data,scaled_tobepredict,300)
        

    结果展示

    #1、累计概率图

    #2、概率密度图(从概率密度图中发现它的概率分布并不对称,说明有可能我们的数据中存在未知的隐藏变量,需要再详细询问获取的数据是否有漏标记说明的信息。)

    展开全文
  • 基于遗传算法的BP神经网络的股票预测模型 摘要 在目前的股票投资市场,不少自然人股民的投资主要方式使根据对当天或者一个较长周期对股票数据的预测,来得到下一天的股票数据,从而进行相应的投资。为了满足股民...

    摘要

    在目前的股票投资市场,不少自然人股民的投资主要方式使根据对当天或者一个较长周期对股票数据的预测,来得到下一天的股票数据,从而进行相应的投资。为了满足股民希望能更为理性合理准确的预测股票走向,需要借助机器的帮助。本文主要是利用优化过的遗传算法,利用遗传算法调整BP三层神经网络的权重与阈值,使BP神经网络的训练效果得到提升,从而对股票市场的行情有比较好的预测效果。

    关键词 BP神经网络 遗传算法 特征选取

    实验论文节选

    bp神经网络

    bp神经网络

    遗传算法

    遗传算法

    遗传算法的过程:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    实验结果与分析

    3.1 实验设置
    3.1.1 股票数据库的选择
    本实验使用了两种股票种类,为某单支股票(150个)数据与上证综合指数前复权日线(533个)数据,分别保存在两个文件中,将两个数据集的特征向量人工设定为同一列位置,方便后续实验。

    3.1.2 实验参数设置
    本次实验在Matlab环境上运行,分析给予遗传算法的BP神经网络与随机初始化的BP神经网络在股票预测上的差距。
    本次实验所采用的为BP神经网络:训练次数epochs为1000,训练目标goal为0.01,学习速率lr为0.1;遗传算法:群体规模为N=60。

    3.2 实验结果与分析
    实验1:测试未优化的遗传算法运行的预测效果
    本次实验,隐含层神经元个数为3,交叉概率为p_c=0.8,变异概率为p_m=0.05,交叉位置为15L到20L。迭代次数分别设为10次,50次,100次,比较区别。

    在这里插入图片描述
    本次测试出的每一代的最小误差波动很大,而且随着迭代次数的增加,最新一带的最小误差没有明显减小,达不到预期效果。

    实验2:测试带指标变异操作的遗传算法优化的预测效果
    本次实验,隐含层神经元个数为3,群体规模为N=60,交叉概率为p_c=0.8,变异概率为p_m=0.05,双点交叉,交叉位置为15L到20L。迭代次数分别设为10次,50次,100次,比较区别。
    在这里插入图片描述
    在这里插入图片描述
    本次测试出的每一代的最小误差虽然波动很大,但是可以看出随着迭代次数的增加,最后一代的最小误差有下降的趋势,但是容易陷入局部最优解,可能使由于参数设置的问题。

    实验3:测试优劣同时保留的遗传算法优化的预测效果
    本次实验,隐含层神经元个数为3,群体规模为N=60,交叉概率为p_c=0.8,变异概率为p_m=0.05,交叉位置为15L到20L。迭代次数分别设为10次,50次,100次,比较区别。
    在这里插入图片描述
    在这里插入图片描述
    本次测试出的每一代的最小误差虽然还是有波动,但是较前两个实验,已经是降低的趋势了,最优误差也是下降的趋势,说明此优化可以帮助算法跳出局部最差解,逼近局部最优解。

    实验4:测试大变异值的自适应的遗传算法优化的预测效果
    本次实验,隐含层神经元个数为3,群体规模为N=60,交叉概率为p_c=0.8,交叉位置为15L到20L。迭代次数分别设为10次,50次,100次,比较区别。
    在这里插入图片描述
    在这里插入图片描述
    本次测试出的每一代的最小误差波动相较前几个实验,波动十分巨大,但是产生当前最优解的个数是最大的,说明可以帮助算法跳出局部最优解。

    实验5:遗传算法不同参数的遗传算法优化的预测效果

    可以看出,虽然最终的最终误差相差很小,但是种群个数为100的遗传算法明显要比种群个数为60的遗传算法收敛效果要好,相应的,算法的运行时间也有所增加。

    实验6:BP神经网络算法不同参数的预测效果
    在这里插入图片描述
    可以看出,隐含层神经元个数为3个时,BP神经网络的预测效果更好。


    股票预测模型实验结果对比:实验结果选取证综合指数前复权日线数据的总预测曲线。
    在这里插入图片描述
    在这里插入图片描述图1 普通BP神经网络的预测效果
    图1中,绿色线为股票真实值。可以看出,进行4次的普通BP神经网络算法的预测,预测效果十分不稳定。

    在这里插入图片描述
    图2 优化BP神经网络的预测效果
    图2中,绿色线为股票真实值,红色线为带指标变异操作的遗传算法优化后的BP神经网络的预测值,蓝色线为优劣同时保留的遗传算法优化后的BP神经网络的预测值,黑色线为普通遗传算法优化后的BP神经网络的预测值,紫色线为大变异值的自适应的遗传算法优化后的BP神经网络的预测值。可以看出,这四次实验的预测效果比普通BP神经网络算法的预测效果稳定很多,也更为准确。

    在这里插入图片描述
    在这里插入图片描述图3 优化BP神经网络的预测效果(放大节选)
    从图3中,可以看出,预测效果的最好的是优劣同时保留的遗传算法优化后的BP神经网络,其次是带指标变异操作的遗传算法优化后的BP神经网络,然后是普通遗传算法优化后的BP神经网络,最差的是大变异值的自适应的遗传算法优化后的BP神经网络。

    针对以上实验,可以得知,在遗传算法的优化下BP神经网络的预测值明显比未优化的普通BP神经网络的预测值更为准确和稳定。更进一步对遗传算法进行优化,优化的关键点在于遗传算法的选择、交叉、变异三大操作,优化后预测的准确度也有了进一步的提升

    参考到的资料
    https://download.csdn.net/download/u010667861/9617803
    [1] 史峰,王辉,郁磊,胡斐. MATLAB智能算法30个案例分析——基于遗传算法的BP神经网络优化算法[M]. 北京航空航天大学出版社,2011:27-37.
    [2] 翁苏骏. 遗传算法改进的新思路及其在股市投资中的应用[D]. 厦门:厦门大学,1999.

    完整代码下载:

    注意,代码下载后仍需自行调试~
    有调试能力的人再下载,问关于代码问题的不会回复,应该每个人环境不同,会出现各种问题,需要大家自己解决!!!
    积分值为5(如果有变为csdn自行修改)
    更新下载地址(抱歉这么久)
    https://download.csdn.net/download/zxm_jimin/25625013

    本文为原创,转载请注明出处。

    展开全文
  • 基于LSTM的股票价格预测模型【附源码】

    万次阅读 多人点赞 2018-11-13 18:26:08
    导语:本文介绍了LSTM的相关内容和在股票价格预测上的应用。 LSTM(Long Short Term Memory)是一种 特殊的RNN类型,同其他的RNNs相比可以更加方便地学习长期依赖关系,因此有很多人试图将其应用于 时间序列的预测...
  • 依托于农产品价格数据进行实例验证分析,结果表明相对于单一的预测模型,BP-SVR-BP组合模型在预测精度上有了很大的提升,拟合效果更加逼近真实数据曲线,能够客观真实的反应农产品物价变化规律.
  • 数据挖掘算法中,预测模型详解

    千次阅读 2020-04-14 10:14:24
    预测模型根据被解释变量的度量类型,分为对连续变量建模的回归,对分类变量建模的分类器,其中以二分类器为主。这里的回归不是仅有线性回归,还有回归决策树、回归神经网络,甚至最近邻域(KNN)和支持向量机(SVM...
  • #多元线性回归预测房子的价格,构建一个房子价格的python模型。 ##ex1data2.txt中包含了房子价格的训练组。第一列是房子的尺寸(平方英尺),第二列是卧室的数量,第三列是房子的价格
  • 机器学习对价格预测模型与应用

    千次阅读 2018-04-11 14:33:27
    说到价格预测,我们首先能想到的就是kaggle一个比赛,关于房价的预测,不过在房地产行业这么火热的时代,做一个中国版的房价预测也很有意思,但是博主想做的是一个对二手设备价格预测,通过对二手设备的类型、年代...
  • os.chdir(r'C:\Users\A3\Desktop\2:项目\项目\项目19:基于随机森林算法的房屋价格预测模型\房屋价格预测') data_train = pd.read_csv('train.csv') data_test = pd.read_csv('test.csv') print(data_train.head())...
  • 波斯顿房价预测模型 残差平方和找到最好的拟合直线 RSS train_data,test_data = boston.random_split(.8,seed = 0) 内置函数linear创建一个线性回归模型(用一种特定的算法牛顿迭代法)graphlab create会自动的...
  • 基于遗传算法优化的LSTM神经网络期货价格预测模型研究.pdf
  • 周五福利日活动是电信为回馈老用户而做的活动,其主要回馈老用户的...经研究选用ARIMA算法建立预测模型,对5元话费券进行日领取量的短期预测。数据集收集了2019年1月到2019年2月5元话费券的日领取量数据,并根据此数...
  • 基于LSTM的时序预测,训练1000次后对未来价格进行预测
  • 上篇文章 《算法-基于MACD的Adaboost股价涨跌预测模型》 虽然给出了adaboost算法,但是并没有完全正确的表达,尤其是在权重如何处理上,也就是如何对待那些被误分的样本。 所以打算更严谨的来对待这个算法,本着...
  • Oren Etzioni的机票价格预测算法

    千次阅读 2017-01-24 20:15:36
    最近看到一则eBay收购了商品价格预测的网站decide.com的新闻,再次证明了商品的价格预测这事是靠谱的。新闻里还提到Decide.com的全部26名员工,除了联合创始人兼CTO Oren Etzioni 外,都将加入到eBay。 Oren ...
  • 股票市场在我国产生以来不断地成长,逐步成为证券业乃至整个金融业必不可少的组成部分,并且受到越来越多投资者的关注,因而对股票市场...本研究利用ARMA模型,结合PSO算法,然后得到时间序列模型的参数估计及预测
  • 沪牌每月价格预测模型

    千次阅读 2020-03-13 22:19:45
    沪牌每月价格预测模型 (2018年8月6日) 2018年7月份首次拍牌慌乱中连验证码都没输成功,发了点时间做了研究,写了此文,分享给大家学习参考。 为了找出牌照的中标价格的规律,下载了2016年1月-2018年7月的拍牌...
  • 结果表明,开通直销渠道不影响制造商的批发价定价,但可以迫使零售商降低零售价格;开通直销渠道使制造商在分散式供应链中和协调式供应链中都能获得更多利润,使零售商利润减少;只有当运作成本和消费者区域性差异都...
  • 预测得不准!”是数据分析领域的终极难题了。讲预测算法有一大堆,然后遇到现实基本上都被锤成渣渣,业务方怎么都不满意。到底该怎么破局?今天系统讲一下。01预测算法的本质从本质上看,预测算法...
  • 时间序列建模时最重要的观念即是如何利用过去的资料来判定一个变量的未来走向及不同变量间同期(concurrent)或...单变量时间序列模型~Box 和Jenkins 多变量时间序列模型~如 Box 和 Tiao (1982) 及 Tiao 和 Tsay (1983)。
  • 为了对股票价格进行准确、快速的在线预测,提出一种在线核极限学习机算法(OL-KELM)的股票价格预测模型.首先收集股票价格数据,采用相空间重构理论建立学习样本,然后将学习样本输入在线核极限学习机中进行学习,建立股票...
  • 基于卡尔曼滤波的动态、实时性以及股票市场的分形特性,论文首创利用变维分形理论来建立关于股票市场的卡尔曼滤波状态方程和观测方程,提出了一种新的基于变维分形理论的卡尔曼滤波实时跟踪预测模型算法。...
  • 本节书摘来异步社区《Python机器学习——...1.5 构建预测模型的流程 使用机器学习需要几项不同的技能。一项就是编程技能,本书不会把重点放在这。其他的技能用于获得合适的模型进行训练和部署。这些其他技能将是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,696
精华内容 9,478
关键字:

价格预测模型算法