zoukankan      html  css  js  c++  java
  • 基于皮尔逊系数实现股票预测【多线程】

      1 # -*- coding: utf-8 -*-
      2 """
      3 Created on Tue Dec  4 08:53:08 2018
      4 
      5 @author: zhen
      6 """
      7 from dtw import fastdtw
      8 import matplotlib.pyplot as plt
      9 import numpy as np
     10 import pandas as pd
     11 import threading
     12 import time
     13 from datetime import datetime
     14 
     15 def normalization(x): # np.std:计算矩阵的标准差(方差的算术平方根)
     16     return (x - np.mean(x)) / np.std(x)
     17 
     18 def corrcoef(a,b):
     19     corrc = np.corrcoef(a,b) # 计算皮尔逊相关系数,用于度量两个变量之间的相关性,其值介于-1到1之间
     20     corrc = corrc[0,1]
     21     return (16 * ((1 - corrc) / (1 + corrc)) ** 1) # ** 表示乘方
     22         
     23 startTimeStamp = datetime.now() # 获取当前时间
     24 # 加载数据
     25 filename = 'C:/Users/zhen/.spyder-py3/sh000300_2017.csv'
     26 # 获取第一,二列的数据
     27 all_date = pd.read_csv(filename,usecols=[0, 1], dtype = 'str')
     28 all_date = np.array(all_date)
     29 data = all_date[:, 0]
     30 times = all_date[:, 1]
     31 
     32 data_points = pd.read_csv(filename,usecols=[3])
     33 data_points = np.array(data_points)
     34 data_points = data_points[:,0] #数据
     35 
     36 topk = 10 #只显示top-10
     37 baselen = 100 # 假设在50到150之间变化
     38 basebegin = 365
     39 basedata = data[basebegin]+' '+times[basebegin]+'~'+data[basebegin+baselen-1]+' '+times[basebegin+baselen-1]
     40 length = len(data_points) #数据长度
     41 
     42 # 定义自定义线程类
     43 class Thread_Local(threading.Thread):
     44     def __init__(self, thread_id, name, counter):
     45         threading.Thread.__init__(self)
     46         self.thread_id = thread_id
     47         self.name = name
     48         self.counter = counter
     49         self.__running = threading.Event() # 标识停止线程
     50         self.__running.set() # 设置为True
     51         
     52     def run(self):
     53         print("starting %s" % self.name)
     54         split_data(self, self.counter) # 执行代码逻辑
     55         
     56     def stop(self):
     57         self.__running.clear()
     58         
     59 # 分割片段并执行匹配,多线程
     60 def split_data(self, split_len):
     61     base = data_points[basebegin:basebegin+split_len]  # 获取初始要匹配的数据
     62     subseries = []
     63     dateseries = []
     64     for j in range(0, length): 
     65         if (j < (basebegin - split_len) or j > (basebegin + split_len - 1)) and j <length - split_len:
     66             subseries.append(data_points[j:j+split_len])
     67             dateseries.append(j) #开始位置
     68     search(self, subseries, base, dateseries)  # 调用模式匹配
     69 
     70 # 定义结果变量
     71 result = []  
     72 base_list = []
     73 date_list = []
     74 def search(self, subseries, base, dateseries):
     75      # 片段搜索
     76     listdistance = []
     77     for i in range(0, len(subseries)):
     78         tt = np.array(subseries[i])
     79         # dist, cost, acc, path = fastdtw(base, tt, dist='euclidean')
     80         # listdistance.append(dist)
     81         distance = corrcoef(base, tt)
     82         listdistance.append(distance)
     83     # 排序
     84     index = np.argsort(listdistance, kind='quicksort') #排序,返回排序后的索引序列
     85     result.append(subseries[index[0]])
     86     print("result length is %d" % len(result))
     87     base_list.append(base)
     88     date_list.append(dateseries[index[0]])
     89     # 关闭线程
     90     self.stop()
     91     
     92 # 变换数据(收缩或扩展),生成50到150之间的数据,间隔为10
     93 loc = 0
     94 for split_len in range(round(0.5 * baselen), round(1.5 * baselen), 10):
     95     # 执行匹配
     96    thread = Thread_Local(1, "Thread" + str(loc), split_len)
     97    loc += 1
     98    # 开启线程
     99    thread.start()
    100 
    101 boo = 1
    102 
    103 while(boo > 0):
    104     if(len(result) < 10):
    105         if(boo % 100 == 0):
    106             print("has running %d s" % boo)
    107         boo += 1
    108         time.sleep(1)
    109     else:
    110         boo = 0
    111         
    112  # 片段搜索
    113 listdistance = []
    114 for i in range(0, len(result)):
    115     tt = np.array(result[i])
    116     distance = corrcoef(base_list[i], tt)
    117     listdistance.append(distance)
    118 # 最终排序   
    119 index = np.argsort(listdistance, kind='quicksort') #排序,返回排序后的索引序列
    120 print("closed Main Thread")
    121 endTimeStamp = datetime.now()
    122 # 结果集对比
    123 plt.figure(0)
    124 plt.plot(normalization(base_list[index[0]]),label= basedata,linewidth='2')
    125 length = len(result[index[0]])
    126 begin = data[date_list[index[0]]] + ' ' + times[date_list[index[0]]]
    127 end = data[date_list[index[0]] + length - 1] + ' ' + times[date_list[index[0]] + length - 1]
    128 label = begin + '~' + end
    129 plt.plot(normalization(result[index[0]]), label=label, linewidth='2')  
    130 plt.legend(loc='upper left')
    131 plt.title('normal similarity search')
    132 plt.show()
    133 print('run time', (endTimeStamp-startTimeStamp).seconds, "s")

    结果:

    分析:

      皮尔逊相关系数(corrcoef)运算速度远超DTW或FASTDTW,但DTW或FASTDTW应用范围更广,适用于等长或变长的比较。

  • 相关阅读:
    java相关
    cmd批处理命令及powershell
    火狐浏览器调试模式
    windows 配置java环境变量
    Acwing-279-自然数拆分(背包)
    Acwing-278-数字组合(背包)
    Acwing-277-饼干(DP)
    Acwing-274-移动服务(DP)
    Acwing-275-传纸条(DP)
    Acwing-121-赶牛入圈(二分, 二维前缀和,离散化)
  • 原文地址:https://www.cnblogs.com/yszd/p/10079660.html
Copyright © 2011-2022 走看看