1115 lines
49 KiB
Python
1115 lines
49 KiB
Python
import pandas as pd
|
|
import numpy as np
|
|
from stock.analysis.Common import Common
|
|
from stock.analysis.Stochastic import Stochastic
|
|
from stock.analysis.RSI import RSI
|
|
from stock.analysis.MACD import MACD
|
|
from stock.analysis.IchimokuCloud import IchimokuCloud
|
|
|
|
class BuySellChecker:
|
|
|
|
common = None
|
|
stochastic = None
|
|
rsi = None
|
|
macd = None
|
|
ichimokuCloud = None
|
|
|
|
def __init__(self):
|
|
self.common = Common()
|
|
self.stochastic = Stochastic()
|
|
self.rsi = RSI()
|
|
self.macd = MACD()
|
|
self.ichimokuCloud = IchimokuCloud()
|
|
|
|
return
|
|
|
|
def getPriceAndWeight1(self, data, i):
|
|
buy, weight, sell = -1, -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
################
|
|
### sell 분석 ###
|
|
################
|
|
# 1. 볼린져밴드 상단이 최고와 종가 사이 아래에 있는 경우 매도한다.
|
|
#if (hts["high"][i] - hts["close"][i]) / 2 + hts["close"][i] > hts["upper"][i]:
|
|
# sell = hts["high"][i]
|
|
|
|
# 2. slow_k가 90이 넘으면 매도한다.
|
|
if data["slow_k"][i] > 90:
|
|
sell = data["high"][i]
|
|
|
|
#if hts["slow_k"][i] >= 85:
|
|
# if hts["slow_d"][i-1] < hts["slow_k"][i-1] and hts["slow_k"][i] < hts["slow_d"][i]:
|
|
# sell = hts["high"][i]
|
|
|
|
# 3. 2시 이후에는 최고가가 볼린져밴드 상단 위에 있으면 매도한다.
|
|
if i > 300 and data["high"][i] > data["upper"][i]:
|
|
sell = data["high"][i]
|
|
|
|
##########################
|
|
### buy 분석 ###
|
|
##########################
|
|
if data["low"][i] < data["lower"][i] + 5 and data["open"][i] <= data["close"][i]:
|
|
if data["slow_k"][i-1] < 30 and data["slow_k"][i] < 30:
|
|
if data["slow_k"][i-1] < data["slow_k"][i]:
|
|
buy = data["low"][i]
|
|
|
|
if data["rsi"][i] < 25:
|
|
if data["rsi"][i - 2] < data["rsis"][i - 2] and data["rsi"][i - 1] < data["rsis"][i - 1] and data["rsis"][i] < data["rsi"][i]:
|
|
if data["close"][i] < data["avg5"][i]:
|
|
buy = data["close"][i]
|
|
else:
|
|
buy = data["low"][i]
|
|
weight = 1
|
|
|
|
#############################
|
|
### STOCHASTIC weight 분석 ###
|
|
#############################
|
|
if data["slow_k"][i] in (0, 1, 2, 3):
|
|
weight = 1
|
|
if data["slow_k"][i] in (4, 5, 6, 7, 8):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35):
|
|
weight = 1
|
|
|
|
return buy, weight, sell
|
|
|
|
def getPriceAndWeight2(self, data, i):
|
|
buy, weight, sell = -1, -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i >= START_TIME_INDEX:
|
|
################
|
|
### sell 분석 ###
|
|
################
|
|
# 1. 볼린져밴드 상단이 최고와 종가 사이 아래에 있는 경우 매도한다.
|
|
if (data["high"][i] - data["close"][i]) / 2 + data["close"][i] > data["upper"][i]:
|
|
sell = data["high"][i]
|
|
|
|
if data["slow_k"][i] >= 85:
|
|
if data["slow_d"][i - 1] < data["slow_k"][i - 1] and data["slow_k"][i] < data["slow_d"][i]:
|
|
sell = data["high"][i]
|
|
|
|
# 3. 2시 이후에는 최고가가 볼린져밴드 상단 위에 있으면 매도한다.
|
|
if i > 300 and data["high"][i] > data["upper"][i]:
|
|
sell = data["high"][i]
|
|
|
|
##########################
|
|
### STOCHASTIC buy 분석 ###
|
|
##########################
|
|
if i < 40:
|
|
pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
|
|
now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
|
|
if pre_slow < 0 and 0 < now_slow:
|
|
if data["slow_k"][i] <= 35:
|
|
if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
|
|
if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
|
|
if data['avg10'][i] < data['avg5'][i]:
|
|
if data["open"][i] < data["close"][i]:
|
|
buy = data["close"][i]
|
|
else:
|
|
buy = data["low"][i]
|
|
else:
|
|
pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
|
|
now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
|
|
if pre_slow < 0 and pre_slow < now_slow and -0.15 < now_slow:
|
|
if data["slow_k"][i] <= 30:
|
|
if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
|
|
if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
|
|
if data['avg10'][i] < data['avg5'][i]:
|
|
if data["close"][i] < data["avg5"][i]:
|
|
buy = data["close"][i]
|
|
else:
|
|
buy = data["low"][i]
|
|
|
|
#############################
|
|
### STOCHASTIC weight 분석 ###
|
|
#############################
|
|
if data["slow_k"][i] in (0, 1, 2, 3):
|
|
weight = 1
|
|
if data["slow_k"][i] in (4, 5, 6, 7, 8):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20):
|
|
weight = 1
|
|
elif data["slow_k"][i] in (21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35):
|
|
weight = 1
|
|
|
|
return buy, weight, sell
|
|
|
|
def getBuyCheck(self, data, i, buy, weight):
|
|
if data['close'][i]<data['avg3'][i]<data['avg5'][i]<data['avg10'][i]<data['avg20'][i]<data['avg30'][i]:
|
|
buy, weight, sell = -1, -1, -1
|
|
|
|
if data['slow_k'][i] > 40:
|
|
buy, weight, sell = -1, -1, -1
|
|
|
|
return buy, weight
|
|
|
|
|
|
|
|
|
|
def isYangbong(self, data, i):
|
|
if data['close'][i] > data['open'][i]:
|
|
return True
|
|
else:
|
|
if data['low'][i] < data['close'][i] == data['open'][i] == data['high'][i]:
|
|
return True
|
|
if data['low'][i] < data['open'][i] == data['close'][i] < data['high'][i]:
|
|
return True
|
|
return False
|
|
|
|
def isUmbong(self, data, i):
|
|
if data['close'][i] < data['open'][i]:
|
|
return True
|
|
else:
|
|
if data['low'][i] == data['close'][i] == data['open'][i] < data['high'][i]:
|
|
return True
|
|
if data['low'][i] < data['open'][i] == data['close'][i] < data['high'][i]:
|
|
return True
|
|
return False
|
|
|
|
|
|
|
|
def getBuyPriceAndWeight(self, data, i):
|
|
buy, weight = -1, -1
|
|
slow_k = 60
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i > START_TIME_INDEX:
|
|
# 매수 분석
|
|
|
|
valid = True
|
|
for c in range(i-10, i+1):
|
|
if data["avg20"][c-1] > data["avg20"][c]:
|
|
valid = False
|
|
if valid:
|
|
min_value = min(data["open"][i], data["close"][i])
|
|
max_value = max(data["open"][i], data["close"][i])
|
|
if min_value < data["avg20"][i] < max_value:
|
|
if data["slow_k"][i] < slow_k:
|
|
buy = min_value
|
|
weight = 1
|
|
|
|
if data["slow_k"][i] < slow_k:
|
|
valid = True
|
|
for c in range(i - 5, i + 1):
|
|
if data["avg20"][c] >= min(data["avg3"][c], data["avg6"][c], data["avg9"][c], data["avg12"][c]):
|
|
valid = False
|
|
break
|
|
if valid:
|
|
valid = False
|
|
for c in range(i - 20, i + 1):
|
|
if data["avg20"][c] > max(data["avg3"][c], data["avg6"][c], data["avg9"][c], data["avg12"][c]):
|
|
valid = True
|
|
break
|
|
if valid:
|
|
buy = max(int(data["open"][i]+data["close"][i])/2, min(data["open"][i], data["close"][i]))
|
|
weight = 1
|
|
|
|
return buy, weight
|
|
|
|
def getSellPriceAndWeight(self, data, i):
|
|
sell, weight = -1, -1
|
|
slow_k = 60
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i > START_TIME_INDEX:
|
|
# 매도 분석
|
|
|
|
# 3분선이 10분 이상 6분선 위에 있다가 6분선 아래로 내려옴
|
|
if i >= 381 + 10:
|
|
vaild = True
|
|
count = 0
|
|
for c in range(i-10, i+1):
|
|
if data["avg3"][c-1] == data["avg20"][c]:
|
|
count += 1
|
|
if data["avg3"][c-1] < data["avg20"][c]:
|
|
vaild = False
|
|
break
|
|
if vaild and count < 3:
|
|
if data["avg3"][i] < data["avg20"][i]:
|
|
if data["slow_k"][i] > slow_k:
|
|
sell = int(data["avg3"][i] - data["avg3"][i] % 5)
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
# 12분선이 5분 이상 20분선 위에 있다가 20분선 아래로 내려옴
|
|
if i >= 381 + 5:
|
|
vaild = True
|
|
for c in range(1, 6):
|
|
if data["avg12"][i - c] < data["avg20"][i - c]:
|
|
vaild = False
|
|
break
|
|
if vaild:
|
|
if data["avg12"][i] < data["avg20"][i] and data["avg20"][i-1] < data["avg20"][i]:
|
|
if data["slow_k"][i] > slow_k:
|
|
sell = data["close"][i]
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
if (not (data["avg20"][i-1] > max(data["avg3"][i-1], data["avg6"][i-1], data["avg9"][i-1], data["avg12"][i-1])) and
|
|
(data["avg20"][i] > max(data["avg3"][i], data["avg6"][i], data["avg9"][i], data["avg12"][i]))):
|
|
if data["slow_k"][i] > slow_k:
|
|
sell = data["close"][i]
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
return sell, weight
|
|
|
|
|
|
# 곱버스에 해당함
|
|
def getBuyPriceAndWeight_252670(self, data, i):
|
|
buy, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i > START_TIME_INDEX:
|
|
# 매수 분석
|
|
|
|
param = 1
|
|
if (data["macd"][i] < -3.110935149 and data["macds"][i] < -2.370579802 and
|
|
data["diff_avg27"][i] < -0.51457476*param and
|
|
data["diff_avg3_avg54"][i] < -11.04578189 * param and
|
|
|
|
data["diff_avg6_avg27"][i] < -6.53755144 * param and
|
|
data["diff_avg6_avg54"][i] < -9.518004115*param and
|
|
|
|
data["diff_avg9_avg27"][i] < -5.21244856 * param and
|
|
data["diff_avg9_avg54"][i] < -8.192901235*param and
|
|
|
|
data["diff_open_lead1"][i] < -13.26157407*param and
|
|
data["diff_close_lead1"][i] < -13.71064815*param and
|
|
data["diff_high_lead1"][i] < -10.08564815*param and
|
|
data["diff_low_lead1"][i] < -17.8912037*param and
|
|
|
|
data["abs_avg_1"][i] > 15.72655178 * param and
|
|
29.0499289 - 22.02727828/3 < data["diff_upper_lower"][i] < 29.0499289*param + 22.02727828
|
|
):
|
|
|
|
buy = int((data["open"][i] + data["close"][i]) / 2)
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
return buy, weight
|
|
|
|
def getSellPriceAndWeight_252670(self, data, i):
|
|
sell, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i > START_TIME_INDEX:
|
|
# 매도 분석
|
|
|
|
# 3분선이 10분 이상 6분선 위에 있다가 5분선 아래로 내려옴
|
|
if i >= 381 + 10:
|
|
vaild = True
|
|
count = 0
|
|
for c in range(1, 11):
|
|
if data["avg3"][i - c] == data["avg6"][i - c]:
|
|
count += 1
|
|
if data["avg3"][i - c] < data["avg6"][i - c]:
|
|
vaild = False
|
|
break
|
|
if vaild and count < 3:
|
|
if data["avg3"][i] < data["avg6"][i]:
|
|
sell = int(data["avg3"][i] - data["avg3"][i] % 5)
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
# 3분선이 5분 이상 12분선 위에 있다가 12분선 아래로 내려옴
|
|
if i >= 381 + 5:
|
|
vaild = True
|
|
for c in range(1, 6):
|
|
if not (data["avg3"][i - c] >= data["avg6"][i - c] >= data["avg9"][i - c] >= data["avg12"][i - c]):
|
|
vaild = False
|
|
break
|
|
if vaild:
|
|
if data["avg3"][i] < data["avg12"][i]:
|
|
sell = data["close"][i]
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
return sell, weight
|
|
|
|
def getBuyPriceAndWeight_122630(self, data, i):
|
|
buy, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i > START_TIME_INDEX:
|
|
# 매수 분석
|
|
|
|
param = 1
|
|
if (data["macd"][i] < -8.532976905 and data["macds"][i] < -5.679850674 and data["abs_avg_1"][i] > 70.48701299 * param ):
|
|
"""
|
|
if (data["diff_avg27"][i] < -1.637205387 * param and
|
|
|
|
data["diff_avg3_avg27"][i] < -25.4455267 * param and
|
|
data["diff_avg3_avg54"][i] < -31.55964406 * param and
|
|
|
|
data["diff_avg6_avg27"][i] < -17.45039683 * param and
|
|
data["diff_avg6_avg54"][i] < -23.56451419 * param and
|
|
|
|
data["diff_avg9_avg27"][i] < -13.27020202 * param and
|
|
data["diff_avg9_avg54"][i] < -19.38431938 * param and
|
|
|
|
data["diff_avg12_avg27"][i] < -10.42388167 * param and
|
|
data["diff_avg12_avg54"][i] < -16.53799904 * param and
|
|
|
|
data["diff_change_lead1"][i] < -25.68993506 * param and
|
|
data["diff_open_lead1"][i] < -37.53246753 * param and
|
|
data["diff_close_lead1"][i] < -45.1461039 * param and
|
|
data["diff_high_lead1"][i] < -30.03246753 * param and
|
|
data["diff_low_lead1"][i] < -53.08441558 * param
|
|
):
|
|
|
|
buy = int((data["open"][i] + data["close"][i]) / 2)
|
|
weight = 1
|
|
return buy, weight
|
|
"""
|
|
|
|
if -30 < data["macd"][i] < -25:
|
|
valid = True
|
|
for c in range(1, 20):
|
|
if data["macd"][i-c] < -30:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
buy = int((data["open"][i] + data["close"][i]) / 2)
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
previous_lowest_close = 99999999
|
|
for c in range(10, 30):
|
|
if data["close"][i-c] < previous_lowest_close:
|
|
previous_lowest_close = data["close"][i-c]
|
|
|
|
if data["close"][i] > previous_lowest_close:
|
|
valid = True
|
|
for c in range(1, 20):
|
|
if data["macd"][i-c] < -30:
|
|
valid = False
|
|
break
|
|
if valid:
|
|
buy = int((data["open"][i] + data["close"][i]) / 2)
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
|
|
if (data["avg54"][i-4] < data["avg54"][i-3] < data["avg54"][i-2] < data["avg54"][i-1] < data["avg54"][i] and
|
|
data["avg54"][i] < min(data["avg3"][i], data["avg6"][i], data["avg9"][i], data["avg12"][i], data["avg27"][i]) and
|
|
data["avg54"][i] < data["avg27"][i] < data["avg12"][i] < data["avg9"][i] < data["avg6"][i] < data["avg3"][i] and
|
|
max(data["avg3"][i], data["avg6"][i], data["avg9"][i], data["avg12"][i], data["avg27"][i]) - min(data["avg3"][i], data["avg6"][i], data["avg9"][i], data["avg12"][i], data["avg27"][i]) < 5
|
|
):
|
|
buy = data["close"][i]
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
|
|
|
|
if (data["avg54"][i-4] < data["avg54"][i-3] < data["avg54"][i-2] < data["avg54"][i-1] < data["avg54"][i] and
|
|
data["avg54"][i-7] < data["avg3"][i-7] < data["avg6"][i-7] < data["avg9"][i-7] < data["avg12"][i-7] and
|
|
data["avg54"][i] < data["avg12"][i] < data["avg9"][i] < data["avg6"][i] < data["avg3"][i]
|
|
):
|
|
if data['macd'][i] < -5:
|
|
buy = data["close"][i]
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
return buy, weight
|
|
|
|
|
|
def getSellPriceAndWeight_122630(self, data, i):
|
|
sell, weight = -1, -1
|
|
|
|
START_TIME_INDEX = 0
|
|
for c in range(370, len(data.index)):
|
|
if data.index[c].strftime("%H:%M:%S") == "09:01:00":
|
|
START_TIME_INDEX = c
|
|
break
|
|
|
|
if i > START_TIME_INDEX:
|
|
# 매수 분석
|
|
|
|
# 3분선이 10분 이상 6분선 위에 있다가 5분선 아래로 내려옴
|
|
if i >= 381 + 10:
|
|
vaild = True
|
|
count = 0
|
|
for c in range(1, 11):
|
|
if data["avg3"][i - c] == data["avg6"][i - c]:
|
|
count += 1
|
|
if data["avg3"][i - c] < data["avg6"][i - c]:
|
|
vaild = False
|
|
break
|
|
if vaild and count < 3:
|
|
if data["avg3"][i] < data["avg6"][i]:
|
|
sell = int(data["avg3"][i] - data["avg3"][i]%5)
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
# 3분선이 5분 이상 12분선 위에 있다가 12분선 아래로 내려옴
|
|
if i >= 381 + 5:
|
|
vaild = True
|
|
for c in range(1, 6):
|
|
if not (data["avg3"][i - c] >= data["avg6"][i - c] >= data["avg9"][i - c] >= data["avg12"][i - c]):
|
|
vaild = False
|
|
break
|
|
if vaild:
|
|
if data["avg3"][i] < data["avg12"][i]:
|
|
sell = data["close"][i]
|
|
weight = 1
|
|
return sell, weight
|
|
|
|
param = 2
|
|
if (data["macd"][i] > 11.4590339 and
|
|
data["diff_avg27"][i] > 2.261904762 * param and
|
|
data["diff_avg3_avg27"][i] > 28.83730159 * param and
|
|
data["diff_avg3_avg54"][i] > 40.84391534 * param and
|
|
|
|
data["diff_avg6_avg27"][i] > 22.49801587 * param and
|
|
data["diff_avg6_avg54"][i] > 34.50462963 * param and
|
|
|
|
data["diff_avg9_avg27"][i] > 17.6984127 * param and
|
|
data["diff_avg9_avg54"][i] > 29.70502646 * param and
|
|
|
|
data["diff_avg12_avg27"][i] > 13.59920635 * param and
|
|
data["diff_avg12_avg54"][i] > 25.60582011 * param and
|
|
|
|
data["diff_change_lead1"][i] > 40.82142857 * param and
|
|
data["diff_open_lead1"][i] > 53.48214286 * param and
|
|
data["diff_close_lead1"][i] > 58.23214286 * param and
|
|
data["diff_high_lead1"][i] > 63.125 * param and
|
|
data["diff_low_lead1"][i] > 49.41071429 * param and
|
|
|
|
data["diff_upper_lower"][i] < 70.63330362 * param + 124.7189534 / 3 and
|
|
data["diff_change_base"][i] > 16.73214286 * param and
|
|
|
|
data["diff_avg3"][i] > 4.714285714 * param and
|
|
data["diff_avg6"][i] > 3.857142857 * param and
|
|
data["diff_avg9"][i] > 3.373015873 * param and
|
|
data["diff_avg12"][i] > 3.026785714 * param and
|
|
data["diff_avg27"][i] > 2.261904762 * param and
|
|
data["diff_avg54"][i] > 1.18452381 * param
|
|
):
|
|
buy = int((data["open"][i] + data["close"][i]) / 2)
|
|
weight = 1
|
|
return buy, weight
|
|
|
|
return sell, weight
|
|
|
|
def analyze(self, result):
|
|
# 기본 캔들 정보
|
|
open = result["open"]
|
|
close = result["close"]
|
|
high = result["high"]
|
|
low = result["low"]
|
|
vol = result["vol"]
|
|
label = result["label"]
|
|
|
|
# 이동 평균
|
|
close_df = pd.DataFrame(close)
|
|
avg3_list = close_df.rolling(window=3).mean().fillna(close[0]).values.tolist()
|
|
avg3 = [item[0] for item in avg3_list]
|
|
avg6_list = close_df.rolling(window=6).mean().fillna(close[0]).values.tolist()
|
|
avg6 = [item[0] for item in avg6_list]
|
|
avg9_list = close_df.rolling(window=9).mean().fillna(close[0]).values.tolist()
|
|
avg9 = [item[0] for item in avg9_list]
|
|
avg12_list = close_df.rolling(window=12).mean().fillna(close[0]).values.tolist()
|
|
avg12 = [item[0] for item in avg12_list]
|
|
avg20_list = close_df.rolling(window=20).mean().fillna(close[0]).values.tolist()
|
|
avg20 = [item[0] for item in avg20_list]
|
|
|
|
# 볼린져 밴드
|
|
df = pd.DataFrame(close)
|
|
max20 = df.rolling(window=20).mean()
|
|
stddev20 = df.rolling(window=20).std()
|
|
upper_df = max20 + (stddev20 * 2) # 상단 볼린저 밴드
|
|
lower_df = max20 - (stddev20 * 2) # 하단 볼린저 밴드
|
|
|
|
upper, lower = [], []
|
|
for i in range(len(upper_df)):
|
|
if i < 10:
|
|
upper.append(upper_df.values[0][0])
|
|
lower.append(lower_df.values[0][0])
|
|
else:
|
|
upper.append(upper_df.values[i][0])
|
|
lower.append(lower_df.values[i][0])
|
|
|
|
point_temp = result["time"]
|
|
STOCK = []
|
|
for i in range(len(open)):
|
|
STOCK.append({'volume': vol[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
|
|
'avg20': avg20[i]})
|
|
|
|
# stochastic
|
|
stochastic_df = self.stochastic.apply(STOCK, n=30, m=5, t=5)
|
|
fast_k = stochastic_df['fast_k'].values.tolist()
|
|
slow_k = stochastic_df['slow_k'].values.tolist()
|
|
slow_d = stochastic_df['slow_d'].values.tolist()
|
|
|
|
# macd
|
|
macd_df = self.macd.apply(STOCK, short=12, long=26, t=9)
|
|
macd = macd_df['macd'].values.tolist()
|
|
macds = macd_df['macds'].values.tolist()
|
|
macdo = macd_df['macdo'].values.tolist()
|
|
|
|
# rsi
|
|
rsi_df = self.rsi.apply(STOCK, period=30, window=5)
|
|
rsi = rsi_df['rsi'].values.tolist()
|
|
rsis = rsi_df['rsis'].values.tolist()
|
|
|
|
# ichimokuCloud
|
|
ichimokuCloud_df = self.ichimokuCloud.apply(STOCK, c=9, b=26, l=52)
|
|
ichimokuCloud_df = ichimokuCloud_df[:len(ichimokuCloud_df) - 51]
|
|
changeLine = ichimokuCloud_df['changeLine'].values.tolist()
|
|
baseLine = ichimokuCloud_df['baseLine'].values.tolist()
|
|
leadingSpan1 = ichimokuCloud_df['leadingSpan1'].values.tolist()
|
|
leadingSpan2 = ichimokuCloud_df['leadingSpan2'].values.tolist()
|
|
|
|
# 결과
|
|
temp = {
|
|
"date": point_temp,
|
|
"open": open, "high": high, "low": low, "close": close, "volume": vol,
|
|
"avg3": avg3,"avg6": avg6,"avg9": avg9,"avg12": avg12, "avg20": avg20,
|
|
"upper": upper, "lower": lower,
|
|
"macd": macd, "macds": macds, "macdo": macdo,
|
|
"fast_k": fast_k, "slow_k": slow_k, "slow_d": slow_d,
|
|
"rsi": rsi, "rsis": rsis,
|
|
"changeLine": changeLine, "baseLine": baseLine, "leadingSpan1": leadingSpan1, "leadingSpan2": leadingSpan2,
|
|
|
|
"label": label
|
|
}
|
|
|
|
data = pd.DataFrame(temp)
|
|
df_final_time = pd.DatetimeIndex(point_temp)
|
|
data.index = df_final_time
|
|
|
|
data = data.fillna(close[0])
|
|
return data
|
|
|
|
def analyze1(self, result):
|
|
# 기본 캔들 정보
|
|
open = result["open"]
|
|
close = result["close"]
|
|
high = result["high"]
|
|
low = result["low"]
|
|
vol = result["vol"]
|
|
label = result["label"]
|
|
|
|
# 캔들 정보 연산
|
|
height = [close[i] - open[i] for i in range(0, len(close))]
|
|
top_tail_height = [high[i] - max(open[i], close[i]) for i in range(0, len(close))]
|
|
bottom_tail_height = [min(open[i], close[i]) - low[i] for i in range(0, len(close))]
|
|
|
|
# 이동 평균
|
|
close_df = pd.DataFrame(close)
|
|
avg3_list = close_df.rolling(window=3).mean().fillna(close[0]).values.tolist()
|
|
avg3 = [item[0] for item in avg3_list]
|
|
avg6_list = close_df.rolling(window=6).mean().fillna(close[0]).values.tolist()
|
|
avg6 = [item[0] for item in avg6_list]
|
|
avg9_list = close_df.rolling(window=9).mean().fillna(close[0]).values.tolist()
|
|
avg9 = [item[0] for item in avg9_list]
|
|
avg12_list = close_df.rolling(window=12).mean().fillna(close[0]).values.tolist()
|
|
avg12 = [item[0] for item in avg12_list]
|
|
avg27_list = close_df.rolling(window=27).mean().fillna(close[0]).values.tolist()
|
|
avg27 = [item[0] for item in avg27_list]
|
|
avg54_list = close_df.rolling(window=54).mean().fillna(close[0]).values.tolist()
|
|
avg54 = [item[0] for item in avg54_list]
|
|
|
|
abs_avg_1 = [max(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i], avg54[i]) - min(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i], avg54[i]) for i in range(0, len(close))]
|
|
abs_avg_2 = [max(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i]) - min(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i]) for i in range(0, len(close))]
|
|
abs_avg_3 = [max(avg3[i], avg6[i], avg9[i], avg12[i]) - min(avg3[i], avg6[i], avg9[i], avg12[i]) for i in range(0, len(close))]
|
|
abs_avg_4 = [max(avg3[i], avg6[i], avg9[i]) - min(avg3[i], avg6[i], avg9[i]) for i in range(0, len(close))]
|
|
abs_avg_5 = [max(avg3[i], avg6[i]) - min(avg3[i], avg6[i]) for i in range(0, len(close))]
|
|
|
|
diff_open, diff_close, diff_low, diff_high = [], [], [], []
|
|
diff_open.append(0)
|
|
for i in range(1, len(open)):
|
|
diff_open.append(open[i] - open[i - 1])
|
|
diff_close.append(0)
|
|
for i in range(1, len(close)):
|
|
diff_close.append(close[i] - close[i - 1])
|
|
diff_low.append(0)
|
|
for i in range(1, len(low)):
|
|
diff_low.append(low[i] - low[i - 1])
|
|
diff_high.append(0)
|
|
for i in range(1, len(high)):
|
|
diff_high.append(high[i] - high[i - 1])
|
|
|
|
diff_avg3, diff_avg6, diff_avg9, diff_avg12, diff_avg27, diff_avg54 = [], [], [], [], [], []
|
|
diff_avg3.append(0)
|
|
for i in range(1, len(avg3)):
|
|
diff_avg3.append(avg3[i]-avg3[i-1])
|
|
diff_avg6.append(0)
|
|
for i in range(1, len(avg6)):
|
|
diff_avg6.append(avg6[i] - avg6[i - 1])
|
|
diff_avg9.append(0)
|
|
for i in range(1, len(avg9)):
|
|
diff_avg9.append(avg9[i] - avg9[i - 1])
|
|
diff_avg12.append(0)
|
|
for i in range(1, len(avg12)):
|
|
diff_avg12.append(avg12[i] - avg12[i - 1])
|
|
diff_avg27.append(0)
|
|
for i in range(1, len(avg27)):
|
|
diff_avg27.append(avg27[i] - avg27[i - 1])
|
|
diff_avg54.append(0)
|
|
for i in range(1, len(avg54)):
|
|
diff_avg54.append(avg54[i] - avg54[i - 1])
|
|
|
|
|
|
diff_avg3_avg6 = [avg3[i] - avg6[i] for i in range(0, len(close))]
|
|
diff_avg3_avg9 = [avg3[i] - avg9[i] for i in range(0, len(close))]
|
|
diff_avg3_avg12 = [avg3[i] - avg12[i] for i in range(0, len(close))]
|
|
diff_avg3_avg27 = [avg3[i] - avg27[i] for i in range(0, len(close))]
|
|
diff_avg3_avg54 = [avg3[i] - avg54[i] for i in range(0, len(close))]
|
|
diff_avg6_avg9 = [avg6[i] - avg9[i] for i in range(0, len(close))]
|
|
diff_avg6_avg12 = [avg6[i] - avg12[i] for i in range(0, len(close))]
|
|
diff_avg6_avg27 = [avg6[i] - avg27[i] for i in range(0, len(close))]
|
|
diff_avg6_avg54 = [avg6[i] - avg54[i] for i in range(0, len(close))]
|
|
diff_avg9_avg12 = [avg9[i] - avg12[i] for i in range(0, len(close))]
|
|
diff_avg9_avg27 = [avg9[i] - avg27[i] for i in range(0, len(close))]
|
|
diff_avg9_avg54 = [avg9[i] - avg54[i] for i in range(0, len(close))]
|
|
diff_avg12_avg27 = [avg12[i] - avg27[i] for i in range(0, len(close))]
|
|
diff_avg12_avg54 = [avg12[i] - avg54[i] for i in range(0, len(close))]
|
|
diff_avg27_avg54 = [avg27[i] - avg54[i] for i in range(0, len(close))]
|
|
|
|
# 볼린져 밴드
|
|
df = pd.DataFrame(close)
|
|
max20 = df.rolling(window=20).mean()
|
|
stddev20 = df.rolling(window=20).std()
|
|
upper_df = max20 + (stddev20 * 2) # 상단 볼린저 밴드
|
|
lower_df = max20 - (stddev20 * 2) # 하단 볼린저 밴드
|
|
|
|
upper, lower = [], []
|
|
for i in range(len(upper_df)):
|
|
if i < 10:
|
|
upper.append(upper_df.values[0][0])
|
|
lower.append(lower_df.values[0][0])
|
|
else:
|
|
upper.append(upper_df.values[i][0])
|
|
lower.append(lower_df.values[i][0])
|
|
|
|
point_temp = result["time"]
|
|
STOCK = []
|
|
for i in range(len(open)):
|
|
STOCK.append({'volume': vol[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
|
|
'avg3': avg3[i], 'avg6': avg6[i],'avg9': avg9[i],'avg12': avg12[i],'avg27': avg27[i],'avg54': avg54[i]})
|
|
|
|
# stochastic
|
|
stochastic_df = self.stochastic.apply(STOCK, n=30, m=5, t=5)
|
|
fast_k = stochastic_df['fast_k'].values.tolist()
|
|
slow_k = stochastic_df['slow_k'].values.tolist()
|
|
slow_d = stochastic_df['slow_d'].values.tolist()
|
|
|
|
# macd
|
|
macd_df = self.macd.apply(STOCK, short=12, long=26, t=9)
|
|
macd = macd_df['macd'].values.tolist()
|
|
macds = macd_df['macds'].values.tolist()
|
|
macdo = macd_df['macdo'].values.tolist()
|
|
|
|
# rsi
|
|
rsi_df = self.rsi.apply(STOCK, period=30, window=5)
|
|
rsi = rsi_df['rsi'].values.tolist()
|
|
rsis = rsi_df['rsis'].values.tolist()
|
|
|
|
# ichimokuCloud
|
|
ichimokuCloud_df = self.ichimokuCloud.apply(STOCK, c=9, b=26, l=52)
|
|
ichimokuCloud_df = ichimokuCloud_df[:len(ichimokuCloud_df) - 51]
|
|
changeLine = ichimokuCloud_df['changeLine'].values.tolist()
|
|
baseLine = ichimokuCloud_df['baseLine'].values.tolist()
|
|
leadingSpan1 = ichimokuCloud_df['leadingSpan1'].values.tolist()
|
|
leadingSpan2 = ichimokuCloud_df['leadingSpan2'].values.tolist()
|
|
|
|
# 간격
|
|
##### 볼린져 밴드
|
|
diff_upper_lower = [upper[i] - lower[i] for i in range(0, len(upper))]
|
|
diff_open_lower = [open[i] - lower[i] for i in range(0, len(open))]
|
|
diff_open_upper = [open[i] - upper[i] for i in range(0, len(open))]
|
|
diff_close_lower = [close[i] - lower[i] for i in range(0, len(close))]
|
|
diff_close_upper = [close[i] - upper[i] for i in range(0, len(close))]
|
|
diff_high_lower = [high[i] - lower[i] for i in range(0, len(high))]
|
|
diff_high_upper = [high[i] - upper[i] for i in range(0, len(high))]
|
|
diff_low_lower = [low[i] - lower[i] for i in range(0, len(low))]
|
|
diff_low_upper = [low[i] - upper[i] for i in range(0, len(low))]
|
|
|
|
|
|
##### 일목균형표
|
|
diff_lead1_lead2 = [leadingSpan1[i] - leadingSpan2[i] for i in range(0, len(leadingSpan1))]
|
|
diff_change_base = [changeLine[i] - baseLine[i] for i in range(0, len(baseLine))]
|
|
diff_base_lead1 = [baseLine[i] - leadingSpan1[i] for i in range(0, len(baseLine))]
|
|
diff_base_lead2 = [baseLine[i] - leadingSpan2[i] for i in range(0, len(baseLine))]
|
|
diff_change_lead1 = [changeLine[i] - leadingSpan1[i] for i in range(0, len(changeLine))]
|
|
diff_change_lead2 = [changeLine[i] - leadingSpan2[i] for i in range(0, len(changeLine))]
|
|
diff_open_lead2 = [open[i] - leadingSpan2[i] for i in range(0, len(open))]
|
|
diff_open_lead1 = [open[i] - leadingSpan1[i] for i in range(0, len(open))]
|
|
diff_open_change = [open[i] - changeLine[i] for i in range(0, len(open))]
|
|
diff_open_base = [open[i] - baseLine[i] for i in range(0, len(open))]
|
|
diff_close_lead2 = [close[i] - leadingSpan2[i] for i in range(0, len(close))]
|
|
diff_close_lead1 = [close[i] - leadingSpan1[i] for i in range(0, len(close))]
|
|
diff_close_change = [close[i] - changeLine[i] for i in range(0, len(close))]
|
|
diff_close_base = [close[i] - baseLine[i] for i in range(0, len(close))]
|
|
diff_high_lead2 = [high[i] - leadingSpan2[i] for i in range(0, len(high))]
|
|
diff_high_lead1 = [high[i] - leadingSpan1[i] for i in range(0, len(high))]
|
|
diff_high_change = [high[i] - changeLine[i] for i in range(0, len(high))]
|
|
diff_high_base = [high[i] - baseLine[i] for i in range(0, len(high))]
|
|
diff_low_lead2 = [low[i] - leadingSpan2[i] for i in range(0, len(low))]
|
|
diff_low_lead1 = [low[i] - leadingSpan1[i] for i in range(0, len(low))]
|
|
diff_low_change = [low[i] - changeLine[i] for i in range(0, len(low))]
|
|
diff_low_base = [low[i] - baseLine[i] for i in range(0, len(low))]
|
|
diff_macd_macds = [macd[i] - macds[i] for i in range(0, len(macd))]
|
|
diff_slowk_slowd = [slow_k[i] - slow_d[i] for i in range(0, len(slow_k))]
|
|
diff_rsi_rsis = [rsi[i] - rsis[i] for i in range(0, len(rsi))]
|
|
|
|
|
|
diff_macd, diff_macdo, diff_macds = [], [], []
|
|
diff_macd.append(0)
|
|
for i in range(1, len(macd)):
|
|
diff_macd.append(macd[i] - macd[i - 1])
|
|
diff_macdo.append(0)
|
|
for i in range(1, len(macdo)):
|
|
diff_macdo.append(macdo[i] - macdo[i - 1])
|
|
diff_macds.append(0)
|
|
for i in range(1, len(macds)):
|
|
diff_macds.append(macds[i] - macds[i - 1])
|
|
|
|
diff_fast_k, diff_slow_k, diff_slow_d = [], [], []
|
|
diff_fast_k.append(0)
|
|
for i in range(1, len(fast_k)):
|
|
diff_fast_k.append(fast_k[i] - fast_k[i - 1])
|
|
diff_slow_k.append(0)
|
|
for i in range(1, len(slow_k)):
|
|
diff_slow_k.append(slow_k[i] - slow_k[i - 1])
|
|
diff_slow_d.append(0)
|
|
for i in range(1, len(slow_d)):
|
|
diff_slow_d.append(slow_d[i] - slow_d[i - 1])
|
|
|
|
diff_rsi, diff_rsis = [], []
|
|
diff_rsi.append(0)
|
|
for i in range(1, len(rsi)):
|
|
diff_rsi.append(rsi[i] - rsi[i - 1])
|
|
diff_rsis.append(0)
|
|
for i in range(1, len(rsis)):
|
|
diff_rsis.append(rsis[i] - rsis[i - 1])
|
|
|
|
diff_changeLine, diff_baseLine = [], []
|
|
diff_changeLine.append(0)
|
|
for i in range(1, len(changeLine)):
|
|
diff_changeLine.append(changeLine[i] - changeLine[i - 1])
|
|
diff_baseLine.append(0)
|
|
for i in range(1, len(baseLine)):
|
|
diff_baseLine.append(baseLine[i] - baseLine[i - 1])
|
|
|
|
diff_upper, diff_lower = [], []
|
|
diff_upper.append(0)
|
|
for i in range(1, len(upper)):
|
|
diff_upper.append(upper[i] - upper[i - 1])
|
|
diff_lower.append(0)
|
|
for i in range(1, len(lower)):
|
|
diff_lower.append(lower[i] - lower[i - 1])
|
|
|
|
# 결과
|
|
temp = {
|
|
"date": point_temp,
|
|
"open": open, "high": high, "low": low, "close": close, "volume": vol,
|
|
"avg3": avg3, "avg6": avg6, "avg9": avg9, "avg12": avg12, "avg27": avg27, "avg54": avg54,
|
|
"upper": upper, "lower": lower,
|
|
"macd": macd, "macds": macds, "macdo": macdo,
|
|
"fast_k": fast_k, "slow_k": slow_k, "slow_d": slow_d,
|
|
"rsi": rsi, "rsis": rsis,
|
|
"changeLine": changeLine, "baseLine": baseLine, "leadingSpan1": leadingSpan1, "leadingSpan2": leadingSpan2,
|
|
"height": height, "top_tail_height": top_tail_height, "bottom_tail_height": bottom_tail_height,
|
|
"abs_avg_1": abs_avg_1, "abs_avg_2": abs_avg_2, "abs_avg_3": abs_avg_3, "abs_avg_4": abs_avg_4, "abs_avg_5": abs_avg_5,
|
|
"diff_open": diff_open, "diff_close": diff_close, "diff_low": diff_low, "diff_high": diff_high,
|
|
"diff_avg3":diff_avg3, "diff_avg6":diff_avg6, "diff_avg9":diff_avg9, "diff_avg12":diff_avg12, "diff_avg27":diff_avg27, "diff_avg54":diff_avg54,
|
|
"diff_macd":diff_macd, "diff_macdo":diff_macdo, "diff_macds":diff_macds,
|
|
"diff_fast_k":diff_fast_k, "diff_slow_k":diff_slow_k, "diff_slow_d":diff_slow_d,
|
|
"diff_rsi":diff_rsi, "diff_rsis":diff_rsis,
|
|
"diff_changeLine":diff_changeLine, "diff_baseLine":diff_baseLine,
|
|
"diff_upper":diff_upper, "diff_lower":diff_lower,
|
|
"diff_avg3_avg6": diff_avg3_avg6,
|
|
"diff_avg3_avg9": diff_avg3_avg9,
|
|
"diff_avg3_avg12": diff_avg3_avg12,
|
|
"diff_avg3_avg27": diff_avg3_avg27,
|
|
"diff_avg3_avg54": diff_avg3_avg54,
|
|
"diff_avg6_avg9": diff_avg6_avg9,
|
|
"diff_avg6_avg12": diff_avg6_avg12,
|
|
"diff_avg6_avg27": diff_avg6_avg27,
|
|
"diff_avg6_avg54": diff_avg6_avg54,
|
|
"diff_avg9_avg12": diff_avg9_avg12,
|
|
"diff_avg9_avg27": diff_avg9_avg27,
|
|
"diff_avg9_avg54": diff_avg9_avg54,
|
|
"diff_avg12_avg27": diff_avg12_avg27,
|
|
"diff_avg12_avg54": diff_avg12_avg54,
|
|
"diff_avg27_avg54": diff_avg27_avg54,
|
|
"diff_upper_lower": diff_upper_lower,
|
|
"diff_open_lower": diff_open_lower,
|
|
"diff_open_upper": diff_open_upper,
|
|
"diff_close_lower": diff_close_lower,
|
|
"diff_close_upper": diff_close_upper,
|
|
"diff_high_lower": diff_high_lower,
|
|
"diff_high_upper": diff_high_upper,
|
|
"diff_low_lower": diff_low_lower,
|
|
"diff_low_upper": diff_low_upper,
|
|
"diff_lead1_lead2": diff_lead1_lead2,
|
|
"diff_change_base": diff_change_base,
|
|
"diff_base_lead1": diff_base_lead1,
|
|
"diff_base_lead2": diff_base_lead2,
|
|
"diff_change_lead1": diff_change_lead1,
|
|
"diff_change_lead2": diff_change_lead2,
|
|
"diff_open_lead2": diff_open_lead2,
|
|
"diff_open_lead1": diff_open_lead1,
|
|
"diff_open_change": diff_open_change,
|
|
"diff_open_base": diff_open_base,
|
|
"diff_close_lead2": diff_close_lead2,
|
|
"diff_close_lead1": diff_close_lead1,
|
|
"diff_close_change": diff_close_change,
|
|
"diff_close_base": diff_close_base,
|
|
"diff_high_lead2": diff_high_lead2,
|
|
"diff_high_lead1": diff_high_lead1,
|
|
"diff_high_change": diff_high_change,
|
|
"diff_high_base": diff_high_base,
|
|
"diff_low_lead2": diff_low_lead2,
|
|
"diff_low_lead1": diff_low_lead1,
|
|
"diff_low_change": diff_low_change,
|
|
"diff_low_base": diff_low_base,
|
|
"diff_macd_macds": diff_macd_macds,
|
|
"diff_slowk_slowd": diff_slowk_slowd,
|
|
"diff_rsi_rsis": diff_rsi_rsis,
|
|
|
|
"label": label
|
|
}
|
|
|
|
data = pd.DataFrame(temp)
|
|
df_final_time = pd.DatetimeIndex(point_temp)
|
|
data.index = df_final_time
|
|
|
|
data = data.fillna(close[0])
|
|
return data
|
|
|
|
def write(self, outFp, df, i):
|
|
outFp.write(str(df["macd"][i]) + "\t")
|
|
outFp.write(str(df["macds"][i]) + "\t")
|
|
outFp.write(str(df["macdo"][i]) + "\t")
|
|
outFp.write(str(df["fast_k"][i]) + "\t")
|
|
outFp.write(str(df["slow_k"][i]) + "\t")
|
|
outFp.write(str(df["slow_d"][i]) + "\t")
|
|
outFp.write(str(df["rsi"][i]) + "\t")
|
|
outFp.write(str(df["rsis"][i]) + "\t")
|
|
outFp.write(str(df["height"][i]) + "\t")
|
|
outFp.write(str(df["top_tail_height"][i]) + "\t")
|
|
outFp.write(str(df["bottom_tail_height"][i]) + "\t")
|
|
outFp.write(str(df["abs_avg_1"][i]) + "\t")
|
|
outFp.write(str(df["abs_avg_2"][i]) + "\t")
|
|
outFp.write(str(df["abs_avg_3"][i]) + "\t")
|
|
outFp.write(str(df["abs_avg_4"][i]) + "\t")
|
|
outFp.write(str(df["abs_avg_5"][i]) + "\t")
|
|
outFp.write(str(df["diff_open"][i]) + "\t")
|
|
outFp.write(str(df["diff_close"][i]) + "\t")
|
|
outFp.write(str(df["diff_low"][i]) + "\t")
|
|
outFp.write(str(df["diff_high"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg3"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg6"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg9"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg12"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg27"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg54"][i]) + "\t")
|
|
outFp.write(str(df["diff_macd"][i]) + "\t")
|
|
outFp.write(str(df["diff_macdo"][i]) + "\t")
|
|
outFp.write(str(df["diff_macds"][i]) + "\t")
|
|
outFp.write(str(df["diff_fast_k"][i]) + "\t")
|
|
outFp.write(str(df["diff_slow_k"][i]) + "\t")
|
|
outFp.write(str(df["diff_slow_d"][i]) + "\t")
|
|
outFp.write(str(df["diff_rsi"][i]) + "\t")
|
|
outFp.write(str(df["diff_rsis"][i]) + "\t")
|
|
outFp.write(str(df["diff_changeLine"][i]) + "\t")
|
|
outFp.write(str(df["diff_baseLine"][i]) + "\t")
|
|
outFp.write(str(df["diff_upper"][i]) + "\t")
|
|
outFp.write(str(df["diff_lower"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg3_avg6"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg3_avg9"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg3_avg12"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg3_avg27"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg3_avg54"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg6_avg9"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg6_avg12"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg6_avg27"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg6_avg54"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg9_avg12"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg9_avg27"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg9_avg54"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg12_avg27"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg12_avg54"][i]) + "\t")
|
|
outFp.write(str(df["diff_avg27_avg54"][i]) + "\t")
|
|
outFp.write(str(df["diff_upper_lower"][i]) + "\t")
|
|
outFp.write(str(df["diff_open_lower"][i]) + "\t")
|
|
outFp.write(str(df["diff_open_upper"][i]) + "\t")
|
|
outFp.write(str(df["diff_close_lower"][i]) + "\t")
|
|
outFp.write(str(df["diff_close_upper"][i]) + "\t")
|
|
outFp.write(str(df["diff_high_lower"][i]) + "\t")
|
|
outFp.write(str(df["diff_high_upper"][i]) + "\t")
|
|
outFp.write(str(df["diff_low_lower"][i]) + "\t")
|
|
outFp.write(str(df["diff_low_upper"][i]) + "\t")
|
|
outFp.write(str(df["diff_lead1_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_change_base"][i]) + "\t")
|
|
outFp.write(str(df["diff_base_lead1"][i]) + "\t")
|
|
outFp.write(str(df["diff_base_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_change_lead1"][i]) + "\t")
|
|
outFp.write(str(df["diff_change_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_open_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_open_lead1"][i]) + "\t")
|
|
outFp.write(str(df["diff_open_change"][i]) + "\t")
|
|
outFp.write(str(df["diff_open_base"][i]) + "\t")
|
|
outFp.write(str(df["diff_close_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_close_lead1"][i]) + "\t")
|
|
outFp.write(str(df["diff_close_change"][i]) + "\t")
|
|
outFp.write(str(df["diff_close_base"][i]) + "\t")
|
|
outFp.write(str(df["diff_high_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_high_lead1"][i]) + "\t")
|
|
outFp.write(str(df["diff_high_change"][i]) + "\t")
|
|
outFp.write(str(df["diff_high_base"][i]) + "\t")
|
|
outFp.write(str(df["diff_low_lead2"][i]) + "\t")
|
|
outFp.write(str(df["diff_low_lead1"][i]) + "\t")
|
|
outFp.write(str(df["diff_low_change"][i]) + "\t")
|
|
outFp.write(str(df["diff_low_base"][i]) + "\t")
|
|
outFp.write(str(df["diff_macd_macds"][i]) + "\t")
|
|
outFp.write(str(df["diff_slowk_slowd"][i]) + "\t")
|
|
outFp.write(str(df["diff_rsi_rsis"][i]) + "\t")
|
|
outFp.write(str(df["label"][i]) + "\n")
|
|
return
|
|
|
|
def checkTransaction(self, data, stock_code, isRealTime=True):
|
|
# 4일치 중에서 앞에 2일은 제거한다.
|
|
date = data['date'].dt.date.unique().tolist()
|
|
data = data[data['date'].dt.date != date[0]]
|
|
data = data[data['date'].dt.date != date[1]]
|
|
|
|
# 어제 오늘 데이터로 분석
|
|
bsLine = {}
|
|
size = len(data["close"])
|
|
if isRealTime:
|
|
# isRealTime=True, 실시간 적용
|
|
last_index = size - 1
|
|
|
|
buy, buy_weight = self.getBuyPriceAndWeight(data, last_index)
|
|
sell, sell_weight = self.getSellPriceAndWeight(data, last_index)
|
|
"""
|
|
if stock_code == "252670":
|
|
sell, sell_weight = self.getSellPriceAndWeight_252670(data, last_index)
|
|
buy, buy_weight = self.getBuyPriceAndWeight_252670(data, last_index)
|
|
else:
|
|
sell, sell_weight = self.getSellPriceAndWeight_122630(data, last_index)
|
|
buy, buy_weight = self.getBuyPriceAndWeight_122630(data, last_index)
|
|
"""
|
|
|
|
bsLine['buy'] = [buy]
|
|
bsLine['buy_weight'] = [buy_weight]
|
|
bsLine['sell'] = [sell]
|
|
bsLine['sell_weight'] = [sell_weight]
|
|
else:
|
|
# Type=False, 시뮬레이션 적용
|
|
bsLine['buy'] = [-1 for i in range(size)]
|
|
bsLine['buy_weight'] = [-1 for i in range(size)]
|
|
bsLine['sell'] = [-1 for i in range(size)]
|
|
bsLine['sell_weight'] = [-1 for i in range(size)]
|
|
|
|
for i in range(size):
|
|
buy, buy_weight = self.getBuyPriceAndWeight(data, i)
|
|
sell, sell_weight = self.getSellPriceAndWeight(data, i)
|
|
"""
|
|
if stock_code == "252670":
|
|
sell, sell_weight = self.getSellPriceAndWeight_252670(data, i)
|
|
buy, buy_weight = self.getBuyPriceAndWeight_252670(data, i)
|
|
else:
|
|
sell, sell_weight = self.getSellPriceAndWeight_122630(data, i)
|
|
buy, buy_weight = self.getBuyPriceAndWeight_122630(data, i)
|
|
"""
|
|
bsLine['buy'][i] = buy
|
|
bsLine['buy_weight'][i] = buy_weight
|
|
bsLine['sell'][i] = sell
|
|
bsLine['sell_weight'][i] = sell_weight
|
|
|
|
return bsLine, data
|
|
|
|
|
|
def checkTransactionML(self, data, stock_code, predY, isRealTime=True):
|
|
# 4일치 중에서 앞에 2일은 제거한다.
|
|
date = data['date'].dt.date.unique().tolist()
|
|
data = data[data['date'].dt.date != date[0]]
|
|
data = data[data['date'].dt.date != date[1]]
|
|
|
|
# 어제 오늘 데이터로 분석
|
|
bsLine = {}
|
|
size = len(data["close"])
|
|
if isRealTime:
|
|
# isRealTime=True, 실시간 적용
|
|
last_index = size - 1
|
|
|
|
# Type=False, 시뮬레이션 적용
|
|
bsLine['buy'] = [-1 for i in range(size)]
|
|
bsLine['buy_weight'] = [-1 for i in range(size)]
|
|
bsLine['sell'] = [-1 for i in range(size)]
|
|
bsLine['sell_weight'] = [-1 for i in range(size)]
|
|
|
|
sell, sell_weight, buy, buy_weight = -1, -1, -1, -1
|
|
if predY[last_index] == 1:
|
|
sell = int((data["open"][last_index] + data["close"][last_index]) / 2)
|
|
sell_weight = 1
|
|
elif predY[last_index] == 2:
|
|
buy = int((data["open"][last_index] + data["close"][last_index]) / 2)
|
|
buy_weight = 1
|
|
|
|
bsLine['buy'] = [buy]
|
|
bsLine['buy_weight'] = [buy_weight]
|
|
bsLine['sell'] = [sell]
|
|
bsLine['sell_weight'] = [sell_weight]
|
|
else:
|
|
# Type=False, 시뮬레이션 적용
|
|
bsLine['buy'] = [-1 for i in range(size)]
|
|
bsLine['buy_weight'] = [-1 for i in range(size)]
|
|
bsLine['sell'] = [-1 for i in range(size)]
|
|
bsLine['sell_weight'] = [-1 for i in range(size)]
|
|
|
|
for i in range(size):
|
|
if predY[i] == 1:
|
|
bsLine['sell'][i] = int((data["open"][i] + data["close"][i]) / 2)
|
|
bsLine['sell_weight'][i] = 1
|
|
elif predY[i] == 2:
|
|
bsLine['buy'][i] = int((data["open"][i] + data["close"][i]) / 2)
|
|
bsLine['buy_weight'][i] = 1
|
|
|
|
return bsLine, data |