Example #1
0
 def _make_lines(self):
     (indexes, dates, open, high, low, close, volume) = self.data
     
     self._get_normal_lines(open, high, low, close, volume)
     (pnf_joints, pnf_indexes, pnf_pmmask) = lines.get_pnf(high, low, close)
     (pnf_ljoints, pnf_lindexes, pnf_lpmmask) = lines.get_pnf(high, low, close, "l")
     self.pnf_joints = pnf_joints 
     self.pnf_indexes = pnf_indexes
     self.pnf_pmmask = pnf_pmmask
     self.pnf_ljoints = pnf_ljoints 
     self.pnf_lindexes = pnf_lindexes
     self.pnf_lpmmask = pnf_lpmmask
     self._set_trend_lines()
     self._set_dow_lines(pnf_ljoints, pnf_lindexes, pnf_lpmmask, len(indexes)-1)
 def _make_lines(self):
     for code in self.data.keys():
         (indexes, dates, open, high, low, close, volume) = self.data[code]
         
         self._get_normal_lines(code, open, high, low, close, volume)
         (pnf_joints, pnf_indexes, pnf_pmmask) = lines.get_pnf(high, low, close)
         self._get_base_lines(code, pnf_joints, pnf_indexes, pnf_pmmask, len(indexes)-1)
         self._get_trend_lines(code, pnf_joints, pnf_indexes, pnf_pmmask)
         self.pnf_joints[code] = pnf_joints 
         self.pnf_indexes[code] = pnf_indexes
         self.pnf_pmmask[code] = pnf_pmmask
    def get_line_data(self, meigaras=[]):
        data = kf.get_kabuka(meigaras, self.startd, self.endd, True)
        xbatch = []
        ybatch = []
        for code in data.keys():
            (indexes, dates, open, high, low, close, volume) = data[code]
            (pnf_joints, pnf_indexes, pnf_pmmask) = lines.get_pnf(high, low, close)
            (avg, bollp2, bollm2) = lines.get_bollinger(close)
            (pnf_indexes, pnf_pmmask) = self.add_mid_joints(pnf_indexes, pnf_pmmask)

            for i in range(1, len(pnf_indexes)):
                jointi = pnf_indexes[i]
                if jointi >= MA_DAYS + WATCH_DAYS:
                    ylist = [0, 0, 1, 0, 0]
                    if pnf_pmmask[i] == -2:
                        ylist = [1, 0, 0, 0, 0]
                    if pnf_pmmask[i] == -1:
                        ylist = [0, 1, 0, 0, 0]
                    if pnf_pmmask[i] == 1:
                        ylist = [0, 0, 0, 1, 0]
                    if pnf_pmmask[i] == 2:
                        ylist = [0, 0, 0, 0, 1]
                    xlist = self.lines2image(
                        open[jointi - WATCH_DAYS + 1 : jointi + 1],
                        high[jointi - WATCH_DAYS + 1 : jointi + 1],
                        low[jointi - WATCH_DAYS + 1 : jointi + 1],
                        close[jointi - WATCH_DAYS + 1 : jointi + 1],
                        olines=[
                            avg[jointi - WATCH_DAYS + 1 : jointi + 1],
                            bollp2[jointi - WATCH_DAYS + 1 : jointi + 1],
                            bollm2[jointi - WATCH_DAYS + 1 : jointi + 1],
                        ],
                    )

                    ylist = np.array(ylist)
                    if len(xbatch) == 0:
                        xbatch = np.array([xlist])
                        ybatch = np.array([ylist])
                    else:
                        xbatch = np.append(xbatch, [xlist], axis=0)
                        ybatch = np.append(ybatch, [ylist], axis=0)
        return [xbatch, ybatch]
 def get_line_data(self):
     xbatch = []
     ybatch = []
     data = self.data
     meigaras = data.keys()
     random.shuffle(meigaras)
     for code in meigaras[:BATCH_SIZE]:
         (indexes, dates, open, high, low, close, volume) = data[code]
         (pnf_joints, pnf_indexes, pnf_pmmask) = lines.get_pnf(high, low, close)
         avg05 = lines.get_ma(close, 5)
         avg25 = lines.get_ma(close, 25)
         (pnf_indexes, pnf_pmmask) = self.add_mid_joints(pnf_indexes, pnf_pmmask)
         
         idxs = range(1, len(pnf_indexes))
         random.shuffle(idxs)
         for i in idxs[:BATCH_SIZE]:
             jointi = pnf_indexes[i]
             if jointi >= INVALID_DAYS+WATCH_DAYS:
                 ylist = [0, 1, 0]
                 if pnf_pmmask[i] == -1:
                     ylist = [1, 0, 0]
                 if pnf_pmmask[i] == 1:
                     ylist = [0, 0, 1]
                     
                 if self.mode == "DAILY":
                     (o, h, l, c, v, ot) = self.get_daily_legs(jointi, open, high, low, close, volume)
                 elif self.mode == "WEEKLY":
                     (o, h, l, c, v) = self.get_monthly_legs(jointi, open, high, low, close, volume)
                     ot = []
                 else:
                     raise Exception("mode is not correctly set")
                 xlist = self.lines2image(o, h, l, c, v, ot)
                 
                 ylist = np.array(ylist)
                 if len(xbatch) == 0:
                     xbatch = np.array([xlist])
                     ybatch = np.array([ylist])
                 else:
                     xbatch = np.append(xbatch, [xlist], axis=0)
                     ybatch = np.append(ybatch, [ylist], axis=0)
     return [xbatch, ybatch]
 def get_line_data(self, meigaras=[]):
     data = kf.get_kabuka(meigaras, self.startd, self.endd, True)
     xbatch = []
     ybatch = []
     for code in data.keys():
         (indexes, dates, open, high, low, close, volume) = data[code]
         (pnf_joints, pnf_indexes, pnf_pmmask) = lines.get_pnf(high, low, close)
         avg = lines.get_ma(close)
         (pnf_indexes, pnf_pmmask) = self.add_mid_joints(pnf_indexes, pnf_pmmask)
         
         for i in range(1, len(pnf_indexes)):
             jointi = pnf_indexes[i]
             if jointi >= MA_DAYS+WATCH_DAYS:
                 #xlist = open[jointi-5+1:jointi+1]
                 #xlist += high[jointi-5+1:jointi+1]
                 #xlist += low[jointi-5+1:jointi+1]
                 #xlist += close[jointi-5+1:jointi+1]
                 ylist = [0, 1, 0]
                 if pnf_pmmask[i] == -1:
                     ylist = [1, 0, 0]
                 if pnf_pmmask[i] == 1:
                     ylist = [0, 0, 1]
                 #xlist = self.normalize(np.array(xlist))
                 #xlist = np.append(xlist, self.normalize_volume(volume[jointi-5+1:jointi+1]))
                 #xlist = np.append(xlist, np.zeros(XSIZE-len(xlist)))
                 xlist = self.lines2image( 
                         open[jointi-WATCH_DAYS+1:jointi+1], 
                         high[jointi-WATCH_DAYS+1:jointi+1], 
                         low[jointi-WATCH_DAYS+1:jointi+1], 
                         close[jointi-WATCH_DAYS+1:jointi+1], 
                         olines=[avg[jointi-WATCH_DAYS+1:jointi+1]])
                 
                 ylist = np.array(ylist)
                 if len(xbatch) == 0:
                     xbatch = np.array([xlist])
                     ybatch = np.array([ylist])
                 else:
                     xbatch = np.append(xbatch, [xlist], axis=0)
                     ybatch = np.append(ybatch, [ylist], axis=0)
     return [xbatch, ybatch]
 def get_line_data(self):
     xbatch = []
     ybatch = []
     data = self.data
     meigaras = data.keys()
     random.shuffle(meigaras)
     for code in meigaras[:BATCH_SIZE]:
         (indexes, dates, open, high, low, close, volume) = data[code]
         (pnf_joints, pnf_indexes, pnf_pmmask) = lines.get_pnf(high, low, close)
         avg05 = lines.get_ma(close, 5)
         #avg25 = lines.get_ma(close, 25)
         (pnf_indexes, pnf_pmmask) = self.add_mid_joints(pnf_indexes, pnf_pmmask)
         
         idxs = range(1, len(pnf_indexes))
         random.shuffle(idxs)
         for i in idxs[:BATCH_SIZE]:
             jointi = pnf_indexes[i]
             if jointi >= INVALID_DAYS+WATCH_DAYS:
                 if i >= len(pnf_indexes)-1:
                     continue
                 ylist = [0, 1, 0]
                 if pnf_indexes[i+1]-pnf_indexes[i]<MIN_LEG_LEN:
                     ylist = [0, 0, 0]
                 else:
                     if pnf_pmmask[i] == -1:
                         ylist = [1, 0, 0]
                     if pnf_pmmask[i] == 1:
                         ylist = [0, 0, 1]
                     
                 (o, h, l, c, v, ot) = self.get_daily_legs(jointi, open, high, low, close, volume)
                 xlist = self.lines2image(o, h, l, c, v, ot)
                 
                 ylist = np.array(ylist)
                 if len(xbatch) == 0:
                     xbatch = np.array([xlist])
                     ybatch = np.array([ylist])
                 else:
                     xbatch = np.append(xbatch, [xlist], axis=0)
                     ybatch = np.append(ybatch, [ylist], axis=0)
     return [xbatch, ybatch]