精华内容
下载资源
问答
  • 经济数据预测 | Python实现ARIMA模型股票趋势预测
    千次阅读
    2022-04-28 20:01:43

    经济数据预测 | Python实现ARIMA模型股票趋势预测

    基本介绍

    随着人们生活水平的提高,人们的投资方式也在发生着巨大的变化,越来越多的人开始关注并参与到股票市场投资中去。股票具有高收益的同时也具有高风险性,股票市场受众多因素的影响,价格令人无法捉摸,股票价格预测的研究具有巨大的价值,因此对于股票价格的预测从股票市场诞生之日起,就成了股民与学者们不懈探索的难题。
    本文以此为背景,建立ARIMA模型,用于研究股票的趋势,并且得出股票预测的估计值,拟合度较高,适应性良好。

    数据描述

    • 本文的数据来源于某股市的交易数据,其中date 、 open 、high 、low 、close 、volumn各字段的含义分别为股票日期、开盘价、最高价、最低价、收盘价、股票价格。
    
    import csv
    i
    更多相关内容
  • Python预测股票走势

    千次阅读 2021-01-14 02:55:03
    本文介绍了如何利用时间序列模型ARIMA进行股票走势预测。环境:windows 64平台:Jupyter Notebook (Kernel python3)库:tushare statsmodels pandas numpy seaborn matplotlib先来看看效果吧图1 预测结果图图1中橙.....

    Python的功能可谓相当强大,在很多行业具有相当的优势,这种优势很大程度上来源于各种第三方库。本文介绍了如何利用时间序列模型ARIMA进行股票走势预测。

    环境:windows 64

    平台:Jupyter Notebook (Kernel python3)

    库:tushare  statsmodels pandas numpy  seaborn matplotlib

    先来看看效果吧

    图1 预测结果图

    图1中橙色线条为股票行情实际数据,蓝色线条为模型预测的行情走势,预测结果显示股票呈上涨趋势,从长期来看,还是符合实际走势的,证明了ARIMA模型具有一定的可信性。但是在这里还是要提醒大家一句,股市有风险,投资需谨慎。模型只能提供一个参考,并不能完全正确的指导用户投资。

    股票行情数据获取

    数据的获取利用第三方库tushare,tushare是一个免费、开源的python财经数据接口包, 具体的介绍点我。

    tushare的安装方法很简单, pip install tushare即可。

    import tushare

    data=tushare.get_h_data('600000',start='2005-05-05')

    data.to_csv('600000_2005.csv')导入库,然后调用get_h_data函数获取数据,‘600000’指定股票代码,start指定数据开始的日期,最后将获取的数据使用to_csv函数以csv格式保存到本地。

    注意:调用get_h_data时有时会出现错误,可能是由于服务器不稳定,重新执行即可。但两次调用之间要间隔一定时间。

    数据读取与预处理

    df=pd.read_csv('600000_2005.csv',index_col=0,parse_dates=[0])

    #index_col表示把第一列设为index,parse_dates=[0]表示把第一列按datetime格式解析使用pandas的read_csv函数进行读取数据,各指标意义见代码段中的注释。

    图2 读取数据展示

    pandas读取出的数据如图2所示,我们将选取close,即收盘价作为考核指标来建立ARIMA模型。

    ARIMA模型建立

    stock_week=df['close'].resample('W-TUE').mean()

    #将收盘价作为评判标准,resample指按周统计平均数据(可以指定哪天为基准日,此处是周二为基准)

    stock_train=stock_week['2005':'2017'].dropna()

    #选取2005-2017的数据原始数据是股票每天的行情,我们这里将数据进行重采样,按每周的平均行情来进行分析,‘W-TUE’表示按周为单位,指定周二为基准日,即周二到下个周二为一个计算周期。

    画图看一下现在的数据

    图3 重采样后的数据

    图3使用matplotlib和seaborn绘制,代码如下

    stock_train.plot(figsize=(12,8))

    # plt.legend(bbox_to_anchor=(1.25,0.5))

    plt.title('Close Price')

    sns.despine() #边框控制,默认没有上方和右方的框

    plt.show()

    由图3可以看出,数据波动比较大,而时间序列模型要求数据平缓,满足平稳性的要求。因此需要对数据进行差分处理。

    stock_diff=stock_train.diff().dropna() #对数据进行差分,目的使数据平缓,满足平稳性的要求

    plt.figure()

    plt.plot(stock_diff)

    font_loc=''

    plt.title('一阶差分',fontproperties=font_set) #注意要设置字体,否则会乱码

    plt.show()

    图4 一阶差分结果图

    一阶差分的结果如图4所示,图4可以看出数据基本已经趋于平缓,为了确定一阶差分足以满足需求,再进行ACF和PACF检验,ACF和PACF可以直接调用statemodel里的函数进行求算。

    from statsmodels.graphics.tsaplots import plot_acf,plot_pacf

    acf=plot_acf(stock_diff,lags=20)

    plt.title('ACF')

    acf.show()

    plt.show()

    pacf=plot_pacf(stock_diff,lags=20)

    plt.title('PACF')

    pacf.show()

    plt.show()

    图5 ACF结果图

    图6 PACF结果图

    由图5和图6可以看出,进行一阶差分时,结果已经落在了置信区间内(图中蓝色区域),因此可以确定进行一阶差分是可靠有效的。

    接下来就可以进行ARIMA模型训练了

    model=ARIMA(stock_train,order=(1,1,1),freq='W-TUE')#训练模型,order表示(p,d,q)

    result=model.fit()参数order=(1,1,1)表示一阶差分,ACF和PACF的取值均为1,关于差分阶数、ACF、PACF取值详细介绍点我。

    最后一步就是利用建立好的result模型来预测走势了

    pred=result.predict('20160816','20180112',dynamic=True,typ='levels')#注意预测的起始时间要在训练时间的范围内,结束时间没有要求需要注意的是,预测数据起始时间必须在训练集内,而终止时间则没有限制

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

    plt.xticks(rotation=45)

    plt.plot(pred)

    plt.plot(stock_train)

    plt.show()

    画图

    就可以看见文章开头的结果了

    注:第一次发博客,不足之处欢迎大家提意见,另外该博文主要参考了唐宇迪机器学习视频以及很多已有博客,在此予以声明。

    展开全文
  • 利用人工智能的最新进展来预测股市走势
  • Python 预测股票价格,竟然这么简单

    千次阅读 2020-08-06 14:22:44
    作为一种技术手段,预测在金融、证券领域的应用非常广泛,尤其是对股票价格的预测。我们介绍一下获得股票数据的方法,并基于此对数据进行预处理,接着使用数据分析方法,建立基础特征,进一步构建预测模型,且基于新...

    作为一种技术手段,预测在金融、证券领域的应用非常广泛,尤其是对股票价格的预测。我们介绍一下获得股票数据的方法,并基于此对数据进行预处理,接着使用数据分析方法,建立基础特征,进一步构建预测模型,且基于新数据验证模型效果。拟使用 VAR 及LSTM两种算法建立预测模型。

    获取股票数据

    股票数据通常可从新浪股票、雅虎股票等网页上获取,此外还有一些炒股软件,如同花顺、通达信等都提供了非常清楚的股票数据展示和图表呈现。如果要获得实时的股票数据,可以考虑使用新浪股票提供的接口获取数据。以大秦铁路(股票代码:601006)为例,如果要获取它的最新行情,只需访问新浪的股票数据接口(具体可以百度),该接口会返回一串文本,例如:

    1 var hq_str_sh601006="大秦铁路,6.980,6.960,7.010,7.070,6.950,7.010,7.020,121033256,847861533.000,18900, 7.010,214867,7.000,66500,6.990,386166,6.980,336728,6.970,273750,7.020,836066,7.030,630800,7.040,936306,7.050,579400,7.060,2016-03-18,15:00:00,00";

    这个字符串由许多数据拼接在一起,不同含义的数据用逗号隔开了,按照程序员的思路,顺序号从0开始。

    0:,股票名字1:6.980>,今日开盘价2:6.960>,昨日收盘价3:7.010>,当前价格4:7.070>,今日最高价5:6.950>,今日最低价6:7.010>,竞买价,即“买一”报价7:7.020>,竞卖价,即“卖一”报价8:121033256>,成交的股票数,由于股票交易以一百股为基本单位,所以在使用时,通常把该值除以一百9:847861533.000>,成交金额,单位为“元”,为了一目了然,通常以“万元”为成交金额的单位,所以通常把该值除以一万10:18900>,“买一”申请4695股,即47手11:7.010>,“买一”报价12:214867>,“买二”13:7.000>,“买二”14:66500>,“买三”15:6.990>,“买三”16:386166>,“买四”17:6.980>,“买四”18:336728>,“买五”19:6.970>,“买五”20:273750>,“卖一”申报3100股,即31手21:7.020>,“卖一”报价(22,23),(24,25),(26,27),(28,29)分别为“卖二”至“卖四的情况”30:2016-03-18>,日期31:15:00:00>,时间

    这个接口对于JavaScript程序非常方便,如果要查看该股票的日K线图,可访问新浪股票的K线图接口(具体可百度),便可得到日K线图。

    日K线图

    如果要查看该股票的分时线,可访问链接新浪股票的分时线图接口(具体可百度),便可得到分时线图。

    分时线图

    对于周K线和月K线的查询,可分别访问新浪股票的周K线图和月K线图的接口(具体可百度)。Python中我们可以使用pandas_datareader库来获取股票数据,默认是访问yahoofinance的数据,其中包括上证和深证的股票数据,还有港股数据,该库只能获取股票的历史交易记录信息:如最高价、最低价、开盘价、收盘价以及成交量,无法获取个股的分笔交易明细历史记录。上证代码是ss,深证代码是sz,港股代码是hk,比如茅台:6000519.ss,万科000002.sz,长江实业0001.hk。这里以贵州茅台股票为例,说明pandas_datareader库中股票数据的获取方法及简单的可视化,代码如下:

    1import pandas as pd

    2import pandas_datareader.data as web

    3import datetime as dt

    4data = web.DataReader('600519.ss','yahoo', dt.datetime(2019,8,1),dt.datetime(2019,8,31))

    5data.head

    6 High Low Open Close Volume Adj Close

    7# Date

    8# 2019-08-01 977.000000 953.020020 976.51001 959.299988 3508952 959.299988

    9# 2019-08-02 957.979980 943.000000 944.00000 954.450012 3971940 954.450012

    10# 2019-08-05 954.000000 940.000000 945.00000 942.429993 3677431 942.429993

    11# 2019-08-06 948.000000 923.799988 931.00000 946.299988 4399116 946.299988

    12# 2019-08-07 955.530029 945.000000 949.50000 945.000000 2686998 945.000000

    13

    14kldata=data.values[:,[2,3,1,0]] # 分别对应开盘价、收盘价、最低价和最高价

    15from pyecharts import options as opts

    16from pyecharts.charts import Kline

    17

    18kobj = Kline.add_xaxis(data.index.strftime("%Y-%m-%d").tolist).add_yaxis("贵州茅台-日K线图",kldata.tolist).set_global_opts(

    19 yaxis_opts=opts.AxisOpts(is_scale=True),

    20 xaxis_opts=opts.AxisOpts(is_scale=True),

    21 title_opts=opts.TitleOpts(title=""))

    22kobj.render

    贵州茅台股票日K线图如图:

    为给定时间序列的财务图表,代码中对象data包含6个属性,依次为Open(开盘价)、High(最高价)、Low(最低价)、Close(收盘价)、Volume(成交量)、Adjusted(复权收盘价)。基于收盘价的重要性,可从收盘价的历史数据中分割训练集、验证集、测试集,使用适当的特征,建立预测模型,并实施预测。

    基于VAR算法的预测

    向量自回归(VAR)模型就是非结构化的多方程模型,它的核心思想不考虑经济理论,而直接考虑经济变量时间时序之间的关系,避开了结构建模方法中需要对系统中每个内生变量关于所有内生变量滞后值函数建模的问题,通常用来预测相关时间序列系统和研究随机扰动项对变量系统的动态影响。VAR模型类似联立方程,将多个变量包含在一个统一的模型中,共同利用多个变量信息,比起仅使用单一时间序列的ARIMA等模型,其涵盖的信息更加丰富,能更好地模拟现实经济体,因而用于预测时能够提供更加贴近现实的预测值。此处拟基于贵州茅台股票数据,建立VAR的预测模型。使用后30天的数据作为验证集,剩余的数据用于建立预测模型。本节从VAR模型的平稳性检验出发,依次完成VAR模型的定阶及建模预测,最终通过分析验证集上的准确率来评估预测效果。

    1、平稳性检验

    只有平稳的时间序列才能够直接建立VAR模型,因此在建立VAR模型之前,首先要对变量进行平稳性检验。通常可利用序列的自相关分析图来判断时间序列的平稳性,如果序列的自相关系数随着滞后阶数的增加很快趋于0,即落入随机区间,则序列是平稳的;反之,序列是不平稳的。另外,也可以对序列进行ADF检验来判断平稳性。对于不平稳的序列,需要进行差分运算,直到差分后的序列平稳后,才能建立VAR模型。此处首先提取用于建立预测模型的基础数据,并对其进行单位根检验,对应的Python代码如下:

    1import statsmodels.tsa.stattools as stat

    4import pandas as pd

    5import numpy as np

    6

    7data = web.DataReader('600519.ss','yahoo', dt.datetime(2014,1,1),dt.datetime(2019,9,30))

    8subdata = data.iloc[:-30,:4]

    9for i in range(4):

    10 pvalue = stat.adfuller(subdata.values[:,i], 1)[1]

    11 print("指标 ",data.columns[i]," 单位根检验的p值为:",pvalue)

    12# 指标 High 单位根检验的p值为:0.9955202280850401

    13# 指标 Low 单位根检验的p值为:0.9942509439755689

    14# 指标 Open 单位根检验的p值为:0.9938548193990323

    15# 指标 Close 单位根检验的p值为:0.9950049124079876

    可以看到,p值都大于0.01,因此都是不平稳序列。现对subdata进行1阶差分运算,并再次进行单位根检验,对应的Python代码如下:

    1subdata_diff1 = subdata.iloc[1:,:].values - subdata.iloc[:-1,:].values

    2for i in range(4):

    3 pvalue = stat.adfuller(subdata_diff1[:,i], 1)[1]

    4 print("指标 ",data.columns[i]," 单位根检验的p值为:",pvalue)

    5# 指标 High 单位根检验的p值为:0.0

    6# 指标 Low 单位根检验的p值为:0.0

    7# 指标 Open 单位根检验的p值为:0.0

    8# 指标 Close 单位根检验的p值为:0.0

    如结果所示,对这4个指标的1阶差分单独进行单位根检验,其p值都不超过0.01,因此可以认为是平稳的。

    2、VAR模型定阶

    接下来就是为VAR模型定阶,可以让阶数从1逐渐增加,当AIC值尽量小时,可以确定最大滞后期。我们使用最小二乘法,求解每个方程的系数,并通过逐渐增加阶数,为模型定阶,Python代码如下:

    1# 模型阶数从1开始逐一增加

    2rows, cols = subdata_diff1.shape

    3aicList =

    4lmList =

    5

    6for p in range(1,11):

    7 baseData = None

    8 for i in range(p,rows):

    9 tmp_list = list(subdata_diff1[i,:]) + list(subdata_diff1[i-p:i].flatten)

    10 if baseData is None:

    11 baseData = [tmp_list]

    12 else:

    13 baseData = np.r_[baseData, [tmp_list]]

    14 X = np.c_[[1]*baseData.shape[0],baseData[:,cols:]]

    15 Y = baseData[:,0:cols]

    16 coefMatrix = np.matmul(np.matmul(np.linalg.inv(np.matmul(X.T,X)),X.T),Y)

    17 aic = np.log(np.linalg.det(np.cov(Y - np.matmul(X,coefMatrix),rowvar=False))) + 2*(coefMatrix.shape[0]-1)**2*p/baseData.shape[0]

    18 aicList.append(aic)

    19 lmList.append(coefMatrix)

    20

    21#对比查看阶数和AIC

    22pd.DataFrame({"P":range(1,11),"AIC":aicList})

    23# P AIC

    24# 0 1 13.580156

    25# 1 2 13.312225

    26# 2 3 13.543633

    27# 3 4 14.266087

    28# 4 5 15.512437

    29# 5 6 17.539047

    30# 6 7 20.457337

    31# 7 8 24.385459

    32# 8 9 29.438091

    33# 9 10 35.785909

    如上述代码所示,当p=2时,AIC值最小为13.312225。因此VAR模型定阶为2,并可从对象lmList[1]中获取各指标对应的线性模型。

    3、预测及效果验证

    基于lmList[1]中获取各指标对应的线性模型,对未来30期的数据进行预测,并与验证数据集进行比较分析,Python代码如下:

    1p = np.argmin(aicList)+1

    2n = rows

    3preddf = None

    4for i in range(30):

    5 predData = list(subdata_diff1[n+i-p:n+i].flatten)

    6 predVals = np.matmul([1]+predData,lmList[p-1])

    7 # 使用逆差分运算,还原预测值

    8 predVals=data.iloc[n+i,:].values[:4]+predVals

    9 if preddf is None:

    10 preddf = [predVals]

    11 else:

    12 preddf = np.r_[preddf, [predVals]]

    13 # 为subdata_diff1增加一条新记录

    14 subdata_diff1 = np.r_[subdata_diff1, [data.iloc[n+i+1,:].values[:4] - data.iloc[n+i,:].values[:4]]]

    15

    16#分析预测残差情况

    17(np.abs(preddf - data.iloc[-30:data.shape[0],:4])/data.iloc[-30:data.shape[0],:4]).describe

    18# High Low Open Close

    19# count 30.000000 30.000000 30.000000 30.000000

    20# mean 0.010060 0.009380 0.005661 0.013739

    21# std 0.008562 0.009968 0.006515 0.013674

    22# min 0.001458 0.000115 0.000114 0.000130

    23# 25% 0.004146 0.001950 0.001653 0.002785

    24# 50% 0.007166 0.007118 0.002913 0.010414

    25# 75% 0.014652 0.012999 0.006933 0.022305

    26# max 0.039191 0.045802 0.024576 0.052800

    从上述代码第17行可以看出这4个指标的最大百分误差率分别为3.9191%、4.5802%、2.4576%、5.28%,最小百分误差率分别为0.1458%、0.0115%、0.0114%、0.013%,进一步,绘制二维图表观察预测数据与真实数据的逼近情况,Python代码如下:

    1import matplotlib.pyplot as plt

    2plt.figure(figsize=(10,7))

    3for i in range(4):

    4 plt.subplot(2,2,i+1)

    5 plt.plot(range(30),data.iloc[-30:data.shape[0],i].values,'o-',c='black')

    6 plt.plot(range(30),preddf[:,i],'o--',c='gray')

    7 plt.ylim(1000,1200)

    8 plt.ylabel("$"+data.columns[i]+"$")

    9plt.show

    10v = 100*(1 - np.sum(np.abs(preddf - data.iloc[-30:data.shape[0],:4]).values)/np.sum(data.iloc[-30:data.shape[0],:4].values))

    11print("Evaluation on test data: accuracy = %0.2f%% \n" % v)

    12# Evaluation on test data: accuracy = 99.03%

    该预测效果如下图,其中黑色实线为真实数据,灰色虚线为预测数据,使用VAR模型进行预测的效果总体还是不错的,平均准确率为99.03%。针对多元时间序列的情况,VAR模型不仅考虑了其他指标的滞后影响,计算效率还比较高,从以上代码可以看到,对于模型的拟合,直接使用的最小二乘法,这增加了该模型的适应性。

    预测效果

    基于LSTM算法的预测

    本节主要基于LSTM算法对贵州茅台股票数据进行预测,该算法非常擅长序列数据的建模,由于引入了遗忘门等更为复杂的内部处理单元来处理上下文信息的存储与更新,这样既可以消除梯度问题的困扰,也可以对存在短期或长期依赖的数据建模,该算法在文本、语音等序列数据模型中广泛使用。本节从LSTM建模的数据要求及网络结构设计讲起,通过设置合理的参数,通过训练得到模型,并基于该模型进行预测,最后将结果与真实数据进行比较,评估预测效果。

    1、数据要求

    本节使用LSTM算法对贵州茅台股票数据进行预测,可基于前N条样本对当前样本进行预测,因此该模型不需要像DNN那样,将历史数据进行复杂转换,将基础数据稍加处理就能用于训练模型。对基础数据的处理即为对该数据进行重新封装,将样本前N期的集合与当前样本对应上,分别得到训练数据的输入与输出。

    所示数据对应关系(具体数据为示意)

    2、数据预处理

    首先,需要将基础数据重构为包含历史3周特征数据的基础数据,以预测日的High(最高价)、Low(最低价)、Open(开盘价)、Close(收盘价)4个指标作为输出数据。这里我们使用2014年1月1日至2019年8月31日的贵州茅台股票数据作为训练数据,使用2019年整个9月的数据作为测试数据,来验证模型效果。用Python将对全体数据进行标准化,并将基础数据的特征进行重构,代码如下:

    1SEQLEN = 21

    2dim_in = 4

    3dim_out = 4

    4pred_len = 30

    5vmean = data.iloc[:,:4].apply(lambda x:np.mean(x))

    6vstd = data.iloc[:,:4].apply(lambda x:np.std(x))

    7t0 = data.iloc[:,:4].apply(lambda x:(x-np.mean(x))/np.std(x)).values

    8X_train = np.zeros((t0.shape[0]-SEQLEN-pred_len, SEQLEN, dim_in))

    9Y_train = np.zeros((t0.shape[0]-SEQLEN-pred_len, dim_out),)

    10X_test = np.zeros((pred_len, SEQLEN, dim_in))

    11Y_test = np.zeros((pred_len, dim_out),)

    12for i in range(SEQLEN, t0.shape[0]-pred_len):

    13 Y_train[i-SEQLEN] = t0[i]

    14 X_train[i-SEQLEN] = t0[(i-SEQLEN):i]

    15for i in range(t0.shape[0]-pred_len,t0.shape[0]):

    16 Y_test[i-t0.shape[0]+pred_len] = t0[i]

    17 X_test[i-t0.shape[0]+pred_len] = t0[(i-SEQLEN):i]

    如上述代码所示,SEQLEN表示使用前期数据的长度,dim_in表示输入数据的维度,dim_out表示输出数据的维度,pred_len表示预测数据的长度。第5~7行代码对数据进行zscore标准化,将数据映射到标准正态分布。第12~17行代码对基础数据进行重构,分别得到训练数据X_train、Y_train以及测试数据X_test、Y_test。

    3、网络结构设计

    经尝试,我们使用近3周的历史数据来训练LSTM模型,同时,设置隐含层神经元的数量为64。因此,我们可以将LSTM神经网络按下面的结构进行设计(图中N可取21,即3周对应的天数)。

    LSTM神经网络结构

    4、建立模型

    现基于Keras搭建LSTM神经网络,并基于训练集对模型进行训练,Python代码如下:

    1from keras.layers import LSTM, Dense

    2from keras.models import Sequential

    3model = Sequential

    4model.add(LSTM(64, input_shape=(SEQLEN, dim_in),activation='relu',recurrent_dropout=0.01))

    5model.add(Dense(dim_out,activation='linear'))

    6model.compile(loss = 'mean_squared_error', optimizer = 'rmsprop')

    7history = model.fit(X_train, Y_train, epochs=200, batch_size=10, validation_split=0)

    8# Epoch 1/200

    9# 1350/1350 [==============================] - 1s 1ms/step - loss: 0.0447

    10# Epoch 2/200

    11# 1350/1350 [==============================] - 1s 737us/step - loss: 0.0059

    12# Epoch 3/200

    13# 1350/1350 [==============================] - 1s 743us/step - loss: 0.0043

    14# ......

    15# Epoch 200/200

    16# 1350/1350 [==============================] - 1s 821us/step - loss: 9.2794e-04

    如上述代码所示,我们使用rmsprop算法来优化模型。由于当前的建模场景是数值预测,因此使用MSE(均方误差)来定义损失函数。算法经过200次迭代,loss从0.0447降到了9.2794e-04。我们可以基于得到的模型进行进一步预测。

    5、预测实现

    基于上文得到的模型,进一步编写Python代码,对X_test对应的输出数据进行预测。需要注意的是,直接得到的预测结果是处于标准化的数据空间中的,需要将其还原成原始数据空间的值,结果才有意义。对应的Python代码如下:

    1preddf=model.predict(X_test)*vstd.values+vmean.values

    如上述代码所示,将模型的预测结果pred_y乘以vstd再加上vmean,即可对数据进行还原。preddf即是最终得到的预测数据,可打印其值,代码如下:

    1preddf

    2# array([[1069.35781887, 1038.57915742, 1056.77147186, 1053.83827734],

    3# [1070.65142282, 1039.58533719, 1057.34561875, 1054.85567074],

    4# [1083.58529328, 1052.70457308, 1070.78824637, 1067.49741882],

    5#

    6# [1186.19297789, 1161.52758381, 1172.33666591, 1170.44623263],

    7# [1181.42680223, 1155.14778501, 1166.5726204 , 1165.00336968],

    8# [1186.75600881, 1160.84733425, 1172.37636963, 1170.09819923]])

    9

    10preddf.shape

    11# (30, 4)

    如上述代码所示,preddf是一个的二维数据,包含了2019年9月整月的预测结果。

    6、效果评估

    对贵州茅台股票数据预测的效果评估可以采用两种方法。一种方法是对预测的结果与真实结果进行绘图比较,通过直观观察可以知道预测效果,如果预测曲线与真实曲线完全重合或相当接近,则说明预测效果较好;反之,则说明预测模型还需要改进。另一种方法是基于贵州茅台股票数据预测的误差累计值来计算一个误差率,从而得到平均精度水平,该值越大说明整体预测效果也就越好,该值越小说明预测模型还存在优化空间。编写Python代码,同时实现预测结果与真实数据的对比图,以及计算累计误差,从而全面地评估预测效果,代码如下:

    10v = 100*(1 - np.sum(np.abs(preddf - data.iloc[-30:data.shape[0],:4]).values)/np.sum (data.iloc[-30:data.shape[0],: 4].values))

    12# Evaluation on test data: accuracy = 99.01%

    预测评估对比图如下。

    我们可以看到,黑色实线为真实数据,灰色虚线为预测数据,横坐标为日期下标,纵坐标为对应的股票价格。使用LSTM模型进行预测的效果总体还是不错的,平均准确率为99.01%。对于多元时间序列数据,可尝试使用LSTM模型,该模型能够记忆历史较长的重要信息,可有效识别历史数据中存在的规律和模式,如今广泛应用于包含大量序列数据的场景中。如果大家对Python感兴趣的话,可以加一下我的薇信哦:abb436574,免费领取一套学习资料和视频课程哟~

    本文节选自《Python预测之美:数据分析与算法实战》一书。《Python预测之美:数据分析与算法实战(双色)》,作者游皓麟,以Python语言为基础,体系化介绍预测技术工程实施的必备技能。基于Python 来做预测,不仅能够在业务上快速落地,还让代码维护起来更加方便。对预测原理的深度剖析和算法的细致解读,是本书的一大亮点。本书共分为预测基础、预测算法、预测案例三部分。希望读者在看完本书后,能够将本书的精要融会贯通,进一步在工作和学习实践中提炼价值。

    #欢迎来留言#

    你学会了吗?

    对此,你怎么看?

    程序人生携手【电子工业出版社-博文视点】送出

    《Python预测之美:数据分析与算法实战》一本

    截至7月17日12:00点

    展开全文
  • python机器学习预测Note from Towards Data Science’s editors: While we allow independent authors to publish articles in accordance with our rules and guidelines, we do not endorse each author’s ...

    python机器学习预测

    Note from Towards Data Science’s editors: While we allow independent authors to publish articles in accordance with our rules and guidelines, we do not endorse each author’s contribution. You should not rely on an author’s works without seeking professional advice. See our Reader Terms for details.

    Towards Data Science编辑的注意事项: 尽管我们允许独立作者按照我们的 规则和指南 发表文章 ,但我们不认可每位作者的贡献。 您不应在未征求专业意见的情况下依赖作者的作品。 有关 详细信息, 请参见我们的 阅读器条款

    With the recent volatility of the stock market due to the COVID-19 pandemic, I thought it was a good idea to try and utilize machine learning to predict the near-future trends of the stock market. I’m fairly new to machine learning, and this is my first Medium article so I thought this would be a good project to start off with and showcase.

    鉴于最近由于COVID-19大流行而导致的股市波动,我认为尝试利用机器学习来预测股市的近期趋势是一个好主意。 我是机器学习的新手,这是我的第一篇中型文章,所以我认为这是一个很好的项目,首先要进行展示。

    This article tackles different topics concerning data science, namely; data collection and cleaning, feature engineering, as well as the creation of machine learning models to make predictions.

    本文讨论了与数据科学有关的不同主题,即: 数据收集和清理,功能工程以及创建机器学习模型以进行预测。

    Author’s disclaimer: This project is not financial or investment advice. It is not a guarantee that it will provide the correct results most of the time. Therefore you should be very careful and not use this as a primary source of trading insight.

    作者免责声明:该项目不是财务或投资建议。 不能保证大部分时间都会提供正确的结果。 因此,您应该非常小心,不要将其用作交易洞察力的主要来源。

    You can find all the code on a jupyter notebook on my github:

    您可以在我的github上的jupyter笔记本上找到所有代码:

    1.进口和数据收集 (1. Imports and Data Collection)

    To begin, we include all of the libraries used for this project. I used the yfinance API to gather all of the historical stock market data. It’s taken directly from the yahoo finance website, so it’s very reliable data.

    首先,我们包括用于该项目的所有库。 我使用yfinance API收集了所有历史股票市场数据。 它直接来自雅虎财经网站,因此它是非常可靠的数据。

    import yfinance as yf
    import datetime
    import pandas as pd
    import numpy as np
    from finta import TA
    import matplotlib.pyplot as plt
    
    
    from sklearn import svm
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.ensemble import AdaBoostClassifier
    from sklearn.ensemble import GradientBoostingClassifier
    from sklearn.ensemble import VotingClassifier
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.metrics import confusion_matrix, classification_report
    from sklearn import metrics

    We then define some constants that used in data retrieval and data processing. The list with the indicator symbols is useful to help use produce more features for our model.

    然后,我们定义一些用于数据检索和数据处理的常量。 带有指示器符号的列表对于帮助使用为我们的模型产生更多功能很有用。

    """
    Defining some constants for data mining
    """
    
    
    NUM_DAYS = 10000     # The number of days of historical data to retrieve
    INTERVAL = '1d'     # Sample rate of historical data
    symbol = 'SPY'      # Symbol of the desired stock
    
    
    # List of symbols for technical indicators
    INDICATORS = ['RSI', 'MACD', 'STOCH','ADL', 'ATR', 'MOM', 'MFI', 'ROC', 'OBV', 'CCI', 'EMV', 'VORTEX']

    Here’s a link where you can find the actual names of some of these features.

    在此链接中,您可以找到其中某些功能的实际名称。

    Now we pull our historical data from yfinance. We don’t have many features to work with — not particularly useful unless we find a way to normalize them at least or derive more features from them.

    现在,我们从yfinance中提取历史数据。 我们没有很多功能可以使用-除非我们找到一种方法至少可以将它们标准化或从中获得更多功能,否则它就没有什么用处。

    """
    Next we pull the historical data using yfinance
    Rename the column names because finta uses the lowercase names
    """
    
    
    start = (datetime.date.today() - datetime.timedelta( NUM_DAYS ) )
    end = datetime.datetime.today()
    
    
    data = yf.download(symbol, start=start, end=end, interval=INTERVAL)
    data.rename(columns={"Close": 'close', "High": 'high', "Low": 'low', 'Volume': 'volume', 'Open': 'open'}, inplace=True)
    print(data.head())
    
    
    tmp = data.iloc[-60:]
    tmp['close'].plot()
    Image for post
    Image for post
    Data from the ‘Close’ column
    来自“关闭”列的数据

    2.数据处理与特征工程 (2. Data Processing & Feature Engineering)

    We see that our data above is rough and contains lots of spikes for a time series. It isn’t very smooth and can be difficult for the model to extract trends from. To reduce the appearance of this we want to exponentially smooth our data before we compute the technical indicators.

    我们看到上面的数据是粗糙的,并且包含一个时间序列的许多峰值。 它不是很平滑,模型很难从中提取趋势。 为了减少这种情况的出现,我们希望在计算技术指标之前以指数方式平滑数据。

    """
    Next we clean our data and perform feature engineering to create new technical indicator features that our
    model can learn from
    """
    
    
    def _exponential_smooth(data, alpha):
        """
        Function that exponentially smooths dataset so values are less 'rigid'
        :param alpha: weight factor to weight recent values more
        """
        
        return data.ewm(alpha=alpha).mean()
    
    
    data = _exponential_smooth(data, 0.65)
    
    
    tmp1 = data.iloc[-60:]
    tmp1['close'].plot()
    Image for post
    Data from ‘Close’, however its been smoothed
    来自“关闭”的数据,但是已被平滑

    We can see that the data is much more smoothed. Having many peaks and troughs can make it hard to approximate, or be difficult to extract tends when computing the technical indicators. It can throw the model off.

    我们可以看到数据更加平滑。 在计算技术指标时,具有许多波峰和波谷会使其难以估计或难以提取趋势。 它可能会使模型失效。

    Now it’s time to compute our technical indicators. As stated above, I use the finta library in combination with python’s built in eval function to quickly compute all the indicators in the INDICATORS list. I also compute some ema’s at different average lengths in addition to a normalized volume value.

    现在该计算我们的技术指标了。 如上所述,我结合使用finta库和python的内置eval函数来快速计算INDICATORS列表中的所有指标。 除了归一化的体积值,我还计算了不同平均长度下的一些ema。

    I remove the columns like ‘Open’, ‘High’, ‘Low’, and ‘Adj Close’ because we can get a good enough approximation with our ema’s in addition to the indicators. Volume has been proven to have a correlation with price fluctuations, which is why I normalized it.

    我删除了诸如“打开”,“高”,“低”和“调整关闭”之类的列,因为除指标外,我们还可以获得与ema足够好的近似值。 交易量已被证明与价格波动有关,这就是为什么我将其标准化。

    def _get_indicator_data(data):
        """
        Function that uses the finta API to calculate technical indicators used as the features
        :return:
        """
    
    
        for indicator in INDICATORS:
            ind_data = eval('TA.' + indicator + '(data)')
            if not isinstance(ind_data, pd.DataFrame):
                ind_data = ind_data.to_frame()
            data = data.merge(ind_data, left_index=True, right_index=True)
        data.rename(columns={"14 period EMV.": '14 period EMV'}, inplace=True)
    
    
        # Also calculate moving averages for features
        data['ema50'] = data['close'] / data['close'].ewm(50).mean()
        data['ema21'] = data['close'] / data['close'].ewm(21).mean()
        data['ema15'] = data['close'] / data['close'].ewm(14).mean()
        data['ema5'] = data['close'] / data['close'].ewm(5).mean()
    
    
        # Instead of using the actual volume value (which changes over time), we normalize it with a moving volume average
        data['normVol'] = data['volume'] / data['volume'].ewm(5).mean()
    
    
        # Remove columns that won't be used as features
        del (data['open'])
        del (data['high'])
        del (data['low'])
        del (data['volume'])
        del (data['Adj Close'])
        
        return data
    
    
    data = _get_indicator_data(data)
    print(data.columns)
    Index(['close', 'RSI', 'MACD', 'SIGNAL', '14 period STOCH %K','MFV', '14 period ATR', 'MOM', '14 period MFI', 'ROC', 'OBV_x', 'OBV_y', '20 period CCI', '14 period EMV', 'VIm', 'VIp', 'ema50', 'ema21', 'ema14', 'ema5', 'normVol'], dtype='object')

    Right before we gather our predictions, I decided to keep a small bit of data to predict future values with. This line captures 5 rows corresponding to the 5 days of the week on July 27th.

    在我们收集预测之前,我决定保留少量数据来预测未来价值。 该行捕获与7月27日一周中的5天相对应的5行。

    live_pred_data = data.iloc[-16:-11]

    Now comes one of the most important part of this project — computing the truth values. Without these, we wouldn’t even be able to train a machine learning model to make predictions.

    现在是该项目最重要的部分之一-计算真值。 没有这些,我们甚至无法训练机器学习模型来进行预测。

    How do we obtain truth value? Well it’s quite intuitive. If we want to know when a stock will increase or decrease (to make a million dollars hopefully!) we would just need to look into the future and observe the price to determine if we should buy or sell right now. Well, with all this historical data, that’s exactly what we can do.

    我们如何获得真理价值? 好吧,这很直观。 如果我们想知道什么时候股票会增加或减少(希望能赚到一百万美元!),我们只需要展望未来并观察价格,以确定我们现在是否应该买卖。 好吧,有了所有这些历史数据,这正是我们所能做的。

    Going back to the table where we initially pulled our data, if we want to know the buy (1) or sell (0) decision on the day of 1993–03–29 (where the closing price was 11.4375), we just need to look X days ahead to see if the price is higher or lower than that on 1993–03–29. So if we look 1 day ahead, we see that the price increased to 11.5. So the truth value on 1993–03–29 would be a buy (1).

    回到我们最初提取数据的表,如果我们想知道1993-03-29日(收盘价为11.4375)当天的买入(1)或卖出(0)决定,我们只需要提前X天查看价格是否高于或低于1993-03-29的价格。 因此,如果我们提前1天查看价格,价格会升至11.5。 因此,1993-03-29年的真值将为购买(1)。

    Since this is also the last step of data processing, we remove all of the NaN value that our indicators and prediction generated, as well as removing the ‘close’ column.

    由于这也是数据处理的最后一步,因此我们删除了指标和预测生成的所有NaN值,并删除了“关闭”列。

    def _produce_prediction(data, window):
        """
        Function that produces the 'truth' values
        At a given row, it looks 'window' rows ahead to see if the price increased (1) or decreased (0)
        :param window: number of days, or rows to look ahead to see what the price did
        """
        
        prediction = (data.shift(-window)['close'] >= data['close'])
        prediction = prediction.iloc[:-window]
        data['pred'] = prediction.astype(int)
        
        return data
    
    
    data = _produce_prediction(data, window=15)
    del (data['close'])
    data = data.dropna() # Some indicators produce NaN values for the first few rows, we just remove them here
    data.tail()
    Image for post

    Because we used Pandas’ shift() function, we lose about 15 rows from the end of the dataset (which is why I captured the week of July 27th before this step).

    因为我们使用了Pandas的shift()函数,所以从数据集的末尾损失了大约15行(这就是为什么我在此步骤之前于7月27日那周捕获了数据)。

    Image for post

    3.模型创建 (3. Model Creation)

    Right before we train our model we must split up the data into a train set and test set. Obvious? That’s because it is. We have about a 80 : 20 split which is pretty good considering the amount of data we have.

    在训练模型之前,我们必须将数据分为训练集和测试集。 明显? 那是因为。 考虑到我们拥有的数据量,我们大约进行了80:20的划分。

    def _split_data(data):
    
    
        """
        Function to partition the data into the train and test set
        :return:
        """
    
    
        y = data['pred']
        features = [x for x in data.columns if x not in ['pred']]
        X = data[features]
    
    
        X_train, X_test, y_train, y_test = train_test_split(X, y, train_size= 4 * len(X) // 5)
        return X_train, X_test, y_train, y_test
    
    
    X_train, X_test, y_train, y_test = _split_data(data)
    print('X Train : ' + str(len(X_train)))
    print('X Test  : ' + str(len(X_test)))
    print('y Train : ' + str(len(y_train)))
    print('y Test  : ' + str(len(y_test)))
    X Train : 5493
    X Test : 1374
    y Train : 5493
    y Test : 1374

    Next we’re going to use multiple classifiers to create an ensemble model. The goal here is to combine the predictions of several models to try and improve on predictability. For each sub-model, we’re also going to use a feature from Sklearn, GridSearchCV, to optimize each model for the best possible results.

    接下来,我们将使用多个分类器创建一个集成模型。 此处的目标是结合几种模型的预测,以尝试并提高可预测性。 对于每个子模型,我们还将使用Sklearn的GridSearchCV功能来优化每个模型以获得最佳结果。

    First we create the random forest model.

    首先,我们创建随机森林模型。

    def _train_random_forest(X_train, y_train, X_test, y_test):
    
    
        """
        Function that uses random forest classifier to train the model
        :return:
        """
        
        # Create a new random forest classifier
        rf = RandomForestClassifier()
        
        # Dictionary of all values we want to test for n_estimators
        params_rf = {'n_estimators': [110,130,140,150,160,180,200]}
        
        # Use gridsearch to test all values for n_estimators
        rf_gs = GridSearchCV(rf, params_rf, cv=5)
        
        # Fit model to training data
        rf_gs.fit(X_train, y_train)
        
        # Save best model
        rf_best = rf_gs.best_estimator_
        
        # Check best n_estimators value
        print(rf_gs.best_params_)
        
        prediction = rf_best.predict(X_test)
    
    
        print(classification_report(y_test, prediction))
        print(confusion_matrix(y_test, prediction))
        
        return rf_best
        
    rf_model = _train_random_forest(X_train, y_train, X_test, y_test)
    {'n_estimators': 160}
    precision recall f1-score support
    0.0 0.88 0.72 0.79 489
    1.0 0.86 0.95 0.90 885
    accuracy 0.87 1374
    macro avg 0.87 0.83 0.85 1374
    weighted avg 0.87 0.87 0.86 1374
    [[353 136]
    [ 47 838]]

    Then the KNN model.

    然后是KNN模型。

    def _train_KNN(X_train, y_train, X_test, y_test):
    
    
        knn = KNeighborsClassifier()
        # Create a dictionary of all values we want to test for n_neighbors
        params_knn = {'n_neighbors': np.arange(1, 25)}
        
        # Use gridsearch to test all values for n_neighbors
        knn_gs = GridSearchCV(knn, params_knn, cv=5)
        
        # Fit model to training data
        knn_gs.fit(X_train, y_train)
        
        # Save best model
        knn_best = knn_gs.best_estimator_
         
        # Check best n_neigbors value
        print(knn_gs.best_params_)
        
        prediction = knn_best.predict(X_test)
    
    
        print(classification_report(y_test, prediction))
        print(confusion_matrix(y_test, prediction))
        
        return knn_best
        
        
    knn_model = _train_KNN(X_train, y_train, X_test, y_test)
    {'n_neighbors': 1}
    precision recall f1-score support
    0.0 0.81 0.84 0.82 489
    1.0 0.91 0.89 0.90 885
    accuracy 0.87 1374
    macro avg 0.86 0.86 0.86 1374
    weighted avg 0.87 0.87 0.87 1374
    [[411 78]
    [ 99 786]]

    Finally, the Gradient Boosted Tree.

    最后,梯度提升树。

    def _train_GBT(X_train, y_train, X_test, y_test):
        
        clf = GradientBoostingClassifier()
        
        # Dictionary of parameters to optimize
        params_gbt = {'n_estimators' :[150,160,170,180] , 'learning_rate' :[0.2,0.1,0.09] }
        
        # Use gridsearch to test all values for n_neighbors
        grid_search = GridSearchCV(clf, params_gbt, cv=5)
        
        # Fit model to training data
        grid_search.fit(X_train, y_train)
        
        gbt_best = grid_search.best_estimator_
        
        # Save best model
        print(grid_search.best_params_)
        
        prediction = gbt_best.predict(X_test)
    
    
        print(classification_report(y_test, prediction))
        print(confusion_matrix(y_test, prediction))
        
        
        return gbt_best
    
    
    
    
    gbt_model = _train_GBT(X_train, y_train, X_test, y_test)
    {'learning_rate': 0.2, 'n_estimators': 180}
    precision recall f1-score support
    0.0 0.81 0.70 0.75 489
    1.0 0.85 0.91 0.88 885
    accuracy 0.84 1374
    macro avg 0.83 0.81 0.81 1374
    weighted avg 0.83 0.84 0.83 1374
    [[342 147]
    [ 79 806]]

    And now finally we create the voting classifier

    现在,我们终于创建了投票分类器

    def _ensemble_model(rf_model, knn_model, gbt_model, X_train, y_train, X_test, y_test):
        
        # Create a dictionary of our models
        estimators=[('knn', knn_model), ('rf', rf_model), ('gbt', gbt_model)]
        
        # Create our voting classifier, inputting our models
        ensemble = VotingClassifier(estimators, voting='hard')
        
        #fit model to training data
        ensemble.fit(X_train, y_train)
        
        #test our model on the test data
        print(ensemble.score(X_test, y_test))
        
        prediction = ensemble.predict(X_test)
    
    
        print(classification_report(y_test, prediction))
        print(confusion_matrix(y_test, prediction))
        
        return ensemble
        
    ensemble_model = _ensemble_model(rf_model, knn_model, gbt_model, X_train, y_train, X_test, y_test)
    0.8748180494905385
    precision recall f1-score support
    0.0 0.89 0.75 0.82 513
    1.0 0.87 0.95 0.90 861
    accuracy 0.87 1374
    macro avg 0.88 0.85 0.86 1374
    weighted avg 0.88 0.87 0.87 1374
    [[387 126]
    [ 46 815]]

    We can see that we gain slightly more accuracy by using ensemble modelling (given the confusion matrix results).

    我们可以看到,通过使用集成建模(鉴于混淆矩阵结果),我们获得了更高的准确性。

    4.结果验证 (4. Verification of Results)

    For the next step we’re going to predict how the S&P500 will behave with our predictive model. I’m writing this article on the weekend of August 17th. So to see if this model can produce accurate results, I’m going to use the closing data from this week as the ‘truth’ values for the prediction. Since this model is tuned to have a 15 day window, we need to feed in the input data with the days in the week of July 27th.

    下一步,我们将预测S&P500在预测模型中的表现。 我在8月17日的周末写这篇文章。 因此,要查看该模型是否可以产生准确的结果,我将使用本周的结束数据作为预测的“真实”值。 由于此模型已调整为具有15天的窗口,因此我们需要将输入数据与7月27日中的星期几一起输入。

    July 27th -> August 17th

    7月27日-> 8月17日

    July 28th -> August 18th

    7月28日-> 8月18日

    July 29th -> August 19th

    7月29日-> 8月19日

    July 30th -> August 20th

    7月30日-> 8月20日

    July 31st -> August 21st

    7月31日-> 8月21日

    We saved the week we’re going to use in live_pred_data.

    我们在live_pred_data中保存了将要使用的一周。

    live_pred_data.head()
    Image for post

    Here are the five main days we are going to generate a prediction for. Looks like the models predicts that the price will increase for each day.

    这是我们要进行预测的五个主要日子。 看起来模型预测价格会每天上涨。

    Lets validate our prediction with the actual results.

    让我们用实际结果验证我们的预测。

    del(live_pred_data['close'])
    prediction = ensemble_model.predict(live_pred_data)
    print(prediction)[1. 1. 1. 1. 1.]

    Results

    结果

    July 27th : $ 322.78 — August 17th : $ 337.91

    7月27日:$ 322.78 — 8月17日:$ 337.91

    July 28th : $ 321.74 — August 18th : $ 338.64

    7月28日:321.74美元-8月18日:338.64美元

    July 29th : $ 323.93 — August 19th : $ 337.23

    7月29日:$ 323.93 — 8月19日:$ 337.23

    July 30th : $ 323.95 — August 20th : $ 338.28

    7月30日:$ 323.95-8月20日:$ 338.28

    July 31st : $ 325.62 — August 21st : $ 339.48

    7月31日:$ 325.62-8月21日:$ 339.48

    As we can see from the actual results, we can confirm that the model was correct in all of its predictions. However there are many factors that go into determining the stock price, so to say that the model will produce similar results every time is naive. However, during relatively normal periods of time (without major panic that causes volatility in the stock market), the model should be able to produce good results.

    从实际结果可以看出,我们可以确认该模型在所有预测中都是正确的。 但是,决定股价的因素有很多,因此说该模型每次都会产生相似的结果是很幼稚的。 但是,在相对正常的时间段内(没有引起股票市场波动的重大恐慌),该模型应该能够产生良好的结果。

    5.总结 (5. Summary)

    To summarize what we’ve done in this project,

    总结一下我们在此项目中所做的工作,

    1. We’ve collected data to be used in analysis and feature creation.

      我们已经收集了用于分析和特征创建的数据。
    2. We’ve used pandas to compute many model features and produce clean data to help us in machine learning. Created predictions or truth values using pandas.

      我们已经使用熊猫来计算许多模型特征并生成干净的数据,以帮助我们进行机器学习。 使用熊猫创建预测或真值。
    3. Trained many machine learning models and then combined them using ensemble learning to produce higher prediction accuracy.

      训练了许多机器学习模型,然后使用集成学习对其进行组合以产生更高的预测精度。
    4. Ensured our predictions were accurate with real world data.

      确保我们的预测对真实世界的数据是准确的。

    I’ve learned a lot about data science and machine learning through this project, and I hope you did too. Being my first article, I’d love any form of feedback to help improve my skills as a programmer and data scientist.

    通过这个项目,我已经学到了很多有关数据科学和机器学习的知识,希望您也能做到。 作为我的第一篇文章,我希望获得任何形式的反馈,以帮助提高我作为程序员和数据科学家的技能。

    Thanks for reading :)

    谢谢阅读 :)

    翻译自: https://towardsdatascience.com/predicting-future-stock-market-trends-with-python-machine-learning-2bf3f1633b3c

    python机器学习预测

    展开全文
  • Python-基于ARIMA模型股票趋势预测

    千次阅读 2020-06-04 13:14:51
    本文利用ARIMA模型(自回归移动平均模型),(是统计模型中最常见的一种用来进行时 间序列预测的模型。)预测股票趋势
  • 1.1 训练过程中所有的股票日 K 数据均来自 tushare import tushare pro = ts.pro_api(token) df = pro.daily(ts_code, start_date, end_date) df.to_csv(filename) 二、 数据预处理 2.1 获取到的数据格式如图所示 ...
  • 首先调用tushare包import tushare as tsimport pandas as pdimport matplotlib.pyplot as plt查自己比较感兴趣的股票,这里我查找的是新能源/燃料电池/氢燃料,在数据库里查找下concept = ts.get_concept_classified...
  • 趋势”要这样理解:对于股票预测,不是说我知道这个股票昨天指数是多少,然后预测今天他的指数能涨到多少。而是,我们通过过去一段时间股票的跌或者涨,总结出当出现某种波动的时候股票会有相应的涨或者跌的趋势...
  • 它基于一个假设,即新闻文章对股票市场有影响,以此假设为基础,我们研究了新闻与股票趋势之间的关系,并证明了负面新闻对股票市场具有持续影响。 为了证明这一假设,使用了半监督学习技术来构建新闻分类的最终模型...
  • python3.7 -*- coding: UTF-8 -*- @Project -> File :Code -> Stock @IDE :PyCharm @Author :YangShouWei @USER: 296714435 @Date :2021/3/18 15:52:15 @LastEditor: ''' import tushare as ts # 引入...
  • 1 波士顿房价数据分析安装好Python的Sklearn库后,在安装包下的路径中就能看到描述波士顿房价的csv文件,具体路径是“python安装路径\Lib\site-packages\sklearn\datasets\data”,在这个目录中还包含了Sklearn库会...
  • 在做数据预处理的时候,超额收益率是股票行业里的一个专有名词,指大于无风险投资的收益率,在我国无风险投资收益率即是银行定期存款。pycharm + anaconda3.6开发,涉及到的第三方库有pandas,numpy,matplotlib,...
  • 预测股票市场价格 预测股票价格-线性回归vs随机森林对于这个项目,我使用了包含指数价格的csv文件。 文件中的每一行都包含1950年至2015年间S&P500指数价格的每日记录。数据集存储在sphist.csv中。 数据集的列为: ...
  • 本期导读⊙ML、SVM介绍⊙股价的正负统计分析⊙预测第二天开盘趋势机器学习方法是计算机科学的一个分支,它借助于计算机算法,对数据进行分析后,实现模式识别,进而实现对未来数据的预测。机器学习方法可以分为以下...
  • Python股票数据分析预测目录索引模块安装股票数据获取雅虎财经Quandl 模块Pandas Datareader 模块数据预处理缺失值查找数据规范化股价涨跌变化绘制 K 线图绘制相对变化股票交易策略股票走势预测Prophet 加法模型...
  • Python预测的七种方法,必看

    千次阅读 2020-12-18 07:37:45
    多数人都听说过关于Cryptocurrency,许多人也许...除了加密货币,还有许多重要的应用时序预测的领域,例如:销售预测,呼叫中心的通话量,太阳的活动,海潮,股市行为等等。目录:理解问题描述和数据集安装库方法 1...
  • Python实现LSTM股票预测阶段心得笔记

    万次阅读 多人点赞 2019-07-13 16:24:33
    前言 尝试阶段,本科课设,简易实现,应付期末,还在探索,欢迎交流 实现框架 TensorFlow 实验数据 来自老师给的CSV文件,共3000多行,每行包含字段如下: ...本次预测是就是基...
  • 用于从每个周期到,我估计在第一库存LASSO,如(公式定义2使用先前的)数据的时间段,其中可能预测股票。这意味着使用时间段来估计具有潜在右侧变量的模型。作为有用的基准,我还从方程(1)和oracle回归估计自...
  • Python快速分析和预测股票价格

    千次阅读 2020-06-24 08:38:00
    点击上方“Python爬虫与数据挖掘”,进行关注回复“书籍”即可获赠Python从入门到进阶共10本电子书今日鸡汤会挽雕弓如满月,西北望,射天狼。作者 |Vincent Tatan...
  • 说明 其实最早的时候HMM成功应用在语音...所以针对最近的走势去预测明天的股市,我们先直接去找历史上最相似的走势,然后看看它后来是怎么走的就好了 以下使用hmmlearn来跑一下 # play a search from hmmlearn impo
  • 卧槽,我学会了用Python预测股票价格

    万次阅读 多人点赞 2020-07-12 09:01:00
    文章来源:博文视点Broadview作者:博文视点作为一种技术手段,预测在金融、证券领域的应用非常广泛,尤其是对股票价格的预测。我们介绍一下获得股票数据的方法,并基于此对数据进行预处理,...
  • 在这种情况下,我们可以采用年平均数,但是对于复杂的情况的像预测股票价格,是很难得到一个数字的。所以,我们采取“加权移动平均法”可以对最近的值赋予更高的权重。关于指定加重这儿有很多技巧。 指数加权移动...
  • 预测股票价格 简述:使用Python建立导入数据方式,导入数据集数据,Python清理数据,Python使用探索性数据分析方法分析数据获得趋势图。 Python移动平均模型平滑数据,获得5天内的时间窗口数据趋势图,依次进行,...
  • 一文教你如何用Python预测股票价格

    万次阅读 多人点赞 2018-01-25 00:00:00
    夜深人静的时候,营长常常会点着一支烟,思索到底有没有一个完美的算法,可以预测股价的涨跌,这样就可以早日实现财务自由,走向人生巅峰。这时,一篇外国友人的文章成功引起了营长的注意,看完后备受
  • 介绍大多数人都听说过关于Cryptocurrency,许多人...除了加密货币,还有许多重要的应用时序预测的领域,例如:销售预测,呼叫中心的通话量,太阳的活动,海潮,股市行为等等。目录理解问题描述和数据集安装库方法...
  • python线性回归预测股票走势

    千次阅读 2020-05-27 15:22:40
    提前说明:虽然最后预测股价和真实价之间有差距,但涨跌的趋势大致相同。而且在预测时没有考虑到涨跌停的因素,所以预测结果的涨跌幅度比真实数据要大。 本人上传只作学习练习笔记作用,并不打算用在实操的 直接...

空空如也

空空如也

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

python预测股票趋势