641 lines
38 KiB
Python
641 lines
38 KiB
Python
# https://bibot.tistory.com/63
|
|
# https://nonmeyet.tistory.com/entry/Python-TALib%EB%A5%BC-%ED%99%9C%EC%9A%A9%ED%95%9C-%EB%B9%84%ED%8A%B8%EC%BD%94%EC%9D%B8%EC%A3%BC%EA%B0%80%EA%B8%B0%EC%88%A0%EB%B6%84%EC%84%9D-%EB%B3%B4%EC%A1%B0%EC%A7%80%ED%91%9C-%EC%B6%94%EA%B0%80
|
|
# https://lunadaddy.tistory.com/122
|
|
# https://wikidocs.net/186885
|
|
|
|
import numpy as np
|
|
np.seterr(divide='ignore', invalid='ignore')
|
|
from scipy.signal import argrelextrema
|
|
# https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib
|
|
# https://lunadaddy.tistory.com/122
|
|
import talib
|
|
|
|
import pandas as pd
|
|
from datetime import datetime, timedelta
|
|
from sklearn.preprocessing import MinMaxScaler
|
|
|
|
from JSDPattern import JSDPattern
|
|
|
|
class JSDPattern_minutely (JSDPattern):
|
|
|
|
scaler = None
|
|
|
|
def __init__(self, RESOURCE_PATH=None):
|
|
super().__init__(RESOURCE_PATH)
|
|
self.scaler = MinMaxScaler()
|
|
|
|
return
|
|
|
|
def get_Support_Resistance(self, df):
|
|
n = 10
|
|
support_df = df.iloc[argrelextrema(df.values, np.less_equal, order=n)[0]]
|
|
resistance_df = df.iloc[argrelextrema(df.values, np.greater_equal, order=n)[0]]
|
|
|
|
support, resistance = np.zeros(len(df)), np.zeros(len(df))
|
|
support[0], resistance[0] = df[0].iloc[0], df[0].iloc[0]
|
|
s_i, r_i = 0, 0
|
|
for i in range(1, len(df)):
|
|
if s_i < len(support_df) and df.index[i] == support_df.index[s_i]:
|
|
support[i] = support_df[0].iloc[s_i]
|
|
s_i += 1
|
|
else:
|
|
support[i] = support[i-1]
|
|
|
|
if r_i < len(resistance_df) and df.index[i] == resistance_df.index[r_i]:
|
|
resistance[i] = resistance_df[0].iloc[r_i]
|
|
r_i += 1
|
|
else:
|
|
resistance[i] = resistance[i-1]
|
|
|
|
return support, resistance
|
|
|
|
def analyze_raw(self, result):
|
|
result["volume"] = [result["volume"][i] if 0 < result["volume"][i] else 1 for i in range(len(result["volume"]))]
|
|
# 기본 캔들 정보
|
|
open_df = pd.DataFrame(result["open"])
|
|
close_df = pd.DataFrame(result["close"])
|
|
high_df = pd.DataFrame(result["high"])
|
|
low_df = pd.DataFrame(result["low"])
|
|
volume_df = pd.DataFrame(result["volume"])
|
|
|
|
# 중복 제거
|
|
ymd_df = pd.DataFrame(result["ymd"])
|
|
data_dup = pd.concat([ymd_df, open_df, close_df, high_df, low_df, volume_df], axis=1)
|
|
data_dup.columns = ["ymd", "open", "close", "high", "low", "volume"]
|
|
data_dup.index = pd.DatetimeIndex(result["ymd"])
|
|
data_dup_sorted = data_dup.sort_index(ascending=True)
|
|
data_dup_sorted = data_dup_sorted.drop_duplicates()
|
|
|
|
ymd_df = data_dup_sorted["ymd"]
|
|
open_df = data_dup_sorted["open"]
|
|
close_df = data_dup_sorted["close"]
|
|
high_df = data_dup_sorted["high"]
|
|
low_df = data_dup_sorted["low"]
|
|
volume_df = data_dup_sorted["volume"]
|
|
|
|
ymd = ymd_df.tolist()
|
|
open = open_df.tolist()
|
|
close = close_df.tolist()
|
|
high = high_df.tolist()
|
|
low = low_df.tolist()
|
|
volume = volume_df.tolist()
|
|
|
|
volume_rate = np.zeros(len(close))
|
|
head_rate, body_rate, tail_rate = np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close))
|
|
open_low_rate, open_high_rate, open_open_rate, open_close_rate = np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close))
|
|
close_low_rate, close_high_rate, close_open_rate, close_close_rate = np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close))
|
|
for i in range(len(close)):
|
|
length = high[i] - low[i]
|
|
|
|
if 0 < length:
|
|
max_value = max(open[i], close[i])
|
|
min_value = min(open[i], close[i])
|
|
|
|
head_rate[i] = (high[i] - max_value) / length
|
|
body_rate[i] = (max_value - min_value) / length
|
|
tail_rate[i] = (min_value - low[i]) / length
|
|
|
|
if 0 < i:
|
|
if 0 < volume[i-1]:
|
|
volume_rate[i] = volume[i]/volume[i-1]
|
|
open_low_rate[i] = (low[i] - open[i-1])/open[i-1]
|
|
open_high_rate[i] = (high[i] - open[i-1])/open[i-1]
|
|
open_open_rate[i] = (open[i] - open[i-1])/open[i-1]
|
|
open_close_rate[i] = (close[i] - open[i-1])/open[i-1]
|
|
close_low_rate[i] = (low[i] - close[i-1])/close[i-1]
|
|
close_high_rate[i] = (high[i] - close[i-1])/close[i-1]
|
|
close_open_rate[i] = (open[i] - close[i-1])/close[i-1]
|
|
close_close_rate[i] = (close[i] - close[i-1])/close[i-1]
|
|
|
|
|
|
support, resistance = self.get_Support_Resistance(pd.DataFrame(close))
|
|
|
|
#z = np.polyfit(df['speed'], df['dist'], 1) # 기울기와 절편 확인
|
|
#f = np.poly1d(z) # f(x): f함수
|
|
if 5 < len(close):
|
|
poly_5 = [0] * 4 + [np.polyfit(range(5), close[i - 4: i + 1], 1)[0] for i in range(4, len(close))]
|
|
else:
|
|
poly_5 = [0] * len(close)
|
|
if 10 < len(close):
|
|
poly_10 = [0] * 9 + [np.polyfit(range(10), close[i - 9: i + 1], 1)[0] for i in range(9, len(close))]
|
|
else:
|
|
poly_10 = [0] * len(close)
|
|
if 20 < len(close):
|
|
poly_20 = [0] * 19 + [np.polyfit(range(20), close[i - 19: i + 1], 1)[0] for i in range(19, len(close))]
|
|
else:
|
|
poly_20 = [0] * len(close)
|
|
if 60 < len(close):
|
|
poly_60 = [0] * 59 + [np.polyfit(range(60), close[i - 59: i + 1], 1)[0] for i in range(59, len(close))]
|
|
else:
|
|
poly_60 = [0] * len(close)
|
|
if 120 < len(close):
|
|
poly_120 = [0] * 119 + [np.polyfit(range(120), close[i - 119: i + 1], 1)[0] for i in range(119, len(close))]
|
|
else:
|
|
poly_120 = [0] * len(close)
|
|
if 240 < len(close):
|
|
poly_240 = [0] * 239 + [np.polyfit(range(240), close[i - 239: i + 1], 1)[0] for i in range(239, len(close))]
|
|
else:
|
|
poly_240 = [0] * len(close)
|
|
if 480 < len(close):
|
|
poly_480 = [0] * 479 + [np.polyfit(range(480), close[i - 479: i + 1], 1)[0] for i in range(479, len(close))]
|
|
else:
|
|
poly_480 = [0] * len(close)
|
|
if 720 < len(close):
|
|
poly_720 = [0] * 719 + [np.polyfit(range(720), close[i - 719: i + 1], 1)[0] for i in range(719, len(close))]
|
|
else:
|
|
poly_720 = [0] * len(close)
|
|
if 1440 < len(close):
|
|
poly_1440 = [0] * 1439 + [np.polyfit(range(1440), close[i - 1439: i + 1], 1)[0] for i in range(1439, len(close))]
|
|
else:
|
|
poly_1440 = [0] * len(close)
|
|
|
|
# 7일 신고가
|
|
new_high_7 = [0 for c in range(6)] + [1 if (close[c - 1] is not None and close[c] is not None and close[c - 1] < close[c]) and None not in close[c - 6:c + 1] and max(close[c - 6:c]) < close[c] else 0 for c in range(6, len(close))]
|
|
# 9일 신고가
|
|
new_high_9 = [0 for c in range(8)] + [1 if (close[c - 1] is not None and close[c] is not None and close[c - 1] < close[c]) and None not in close[c - 8:c + 1] and max(close[c - 8:c]) < close[c] else 0 for c in range(8, len(close))]
|
|
# 26일 신고가
|
|
new_high_26 = [0 for c in range(25)] + [1 if (close[c - 1] is not None and close[c] is not None and close[c - 1] < close[c]) and None not in close[c - 25:c + 1] and max(close[c - 25:c]) < close[c] else 0 for c in range(25, len(close))]
|
|
|
|
# 7일 신저가
|
|
new_low_7 = [0 for c in range(6)] + [1 if (close[c - 1] is not None and close[c] is not None and close[c - 1] < close[c]) and None not in close[c - 6:c + 1] and close[c - 6] < min(close[c - 6:c + 1]) else 0 for c in range(6, len(close))]
|
|
# 9일 신저가
|
|
new_low_9 = [0 for c in range(8)] + [1 if (close[c - 1] is not None and close[c] is not None and close[c - 1] < close[c]) and None not in close[c - 8:c + 1] and close[c - 8] < min(close[c - 8:c + 1]) else 0 for c in range(8, len(close))]
|
|
# 26일 신저가
|
|
new_low_26 = [0 for c in range(25)] + [1 if (close[c - 1] is not None and close[c] is not None and close[c - 1] < close[c]) and None not in close[c - 25:c + 1] and close[c - 25] < min(close[c - 25:c + 1]) else 0 for c in range(25, len(close))]
|
|
|
|
high_th = [0]
|
|
for i in range(1, len(close)):
|
|
count = 0
|
|
for c in range(i - 1, i - 30, -1):
|
|
if c < 0:
|
|
break
|
|
if close[i] < close[c]:
|
|
break
|
|
else:
|
|
count += 1
|
|
high_th.append(count)
|
|
|
|
# 이동 평균
|
|
close_df = pd.DataFrame(close)
|
|
|
|
avg5_df = close_df.ewm(5).mean()
|
|
avg10_df = close_df.ewm(10).mean()
|
|
avg20_df = close_df.ewm(20).mean()
|
|
avg60_df = close_df.ewm(60).mean()
|
|
avg120_df = close_df.ewm(120).mean()
|
|
avg240_df = close_df.ewm(240).mean()
|
|
avg480_df = close_df.ewm(480).mean()
|
|
avg720_df = close_df.ewm(720).mean()
|
|
avg1440_df = close_df.ewm(1440).mean()
|
|
|
|
# 이격도
|
|
disparity_avg5_df = (close_df / close_df.ewm(span=5, min_periods=5, adjust=False).mean())
|
|
disparity_avg5_df = disparity_avg5_df.replace({None: np.nan})
|
|
disparity_avg20_df = (close_df / close_df.ewm(span=20, min_periods=20, adjust=False).mean())
|
|
disparity_avg20_df = disparity_avg20_df.replace({None: np.nan})
|
|
disparity_avg60_df = (close_df / close_df.ewm(span=60, min_periods=60, adjust=False).mean())
|
|
disparity_avg60_df = disparity_avg60_df.replace({None: np.nan})
|
|
disparity_avg120_df = (close_df / close_df.ewm(span=120, min_periods=120, adjust=False).mean())
|
|
disparity_avg120_df = disparity_avg120_df.replace({None: np.nan})
|
|
disparity_avg240_df = (close_df / close_df.ewm(span=240, min_periods=240, adjust=False).mean())
|
|
disparity_avg240_df = disparity_avg240_df.replace({None: np.nan})
|
|
disparity_avg480_df = (close_df / close_df.ewm(span=480, min_periods=480, adjust=False).mean())
|
|
disparity_avg480_df = disparity_avg480_df.replace({None: np.nan})
|
|
disparity_avg720_df = (close_df / close_df.ewm(span=720, min_periods=720, adjust=False).mean())
|
|
disparity_avg720_df = disparity_avg720_df.replace({None: np.nan})
|
|
disparity_avg1440_df = (close_df / close_df.ewm(span=1440, min_periods=1440, adjust=False).mean())
|
|
disparity_avg1440_df = disparity_avg1440_df.replace({None: np.nan})
|
|
disparity_avg2880_df = (close_df / close_df.ewm(span=2880, min_periods=2880, adjust=False).mean())
|
|
disparity_avg2880_df = disparity_avg2880_df.replace({None: np.nan})
|
|
|
|
|
|
""""""
|
|
n, t = 20, 2
|
|
max_20 = close_df.rolling(window=n).mean()
|
|
stddev_20 = close_df.rolling(window=n).std()
|
|
upper_20 = max_20 + (stddev_20 * t) # 상단 볼리저 밴드
|
|
lower_20 = max_20 - (stddev_20 * t) # 하단 볼리저 밴드
|
|
middle_20 = (upper_20 + lower_20) / 2
|
|
|
|
width_df = (upper_20 - lower_20) / middle_20
|
|
width_min = np.min(width_df[0])
|
|
width_max = np.max(width_df[0])
|
|
bb_width_df = 100 * (width_df - width_min) / (width_max - width_min)
|
|
bb_pb_df = 100 * (close_df - lower_20) / (upper_20 - lower_20)
|
|
|
|
upper_20 = list(np.reshape(upper_20.values, -1))
|
|
lower_20 = list(np.reshape(lower_20.values, -1))
|
|
middle_20 = list(np.reshape(middle_20.values, -1))
|
|
|
|
np_high, np_low, np_close = np.array(high, dtype=np.float64), np.array(low, dtype=np.float64), np.array(close, dtype=np.float64)
|
|
slowk_5_df, slowd_5_df = talib.STOCH(np_high, np_low, np_close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
|
|
slowk_10_df, slowd_10_df = talib.STOCH(np_high, np_low, np_close, fastk_period=10, slowk_period=6, slowk_matype=0, slowd_period=6, slowd_matype=0)
|
|
slowk_20_df, slowd_20_df = talib.STOCH(np_high, np_low, np_close, fastk_period=20, slowk_period=12, slowk_matype=0, slowd_period=12, slowd_matype=0)
|
|
slowk_60_df, slowd_60_df = talib.STOCH(np_high, np_low, np_close, fastk_period=60, slowk_period=37, slowk_matype=0, slowd_period=37, slowd_matype=0)
|
|
slowk_120_df, slowd_120_df = talib.STOCH(np_high, np_low, np_close, fastk_period=120, slowk_period=74, slowk_matype=0, slowd_period=74, slowd_matype=0)
|
|
slowk_240_df, slowd_240_df = talib.STOCH(np_high, np_low, np_close, fastk_period=240, slowk_period=148, slowk_matype=0, slowd_period=148, slowd_matype=0)
|
|
slowk_480_df, slowd_480_df = talib.STOCH(np_high, np_low, np_close, fastk_period=480, slowk_period=296, slowk_matype=0, slowd_period=296, slowd_matype=0)
|
|
slowk_720_df, slowd_720_df = talib.STOCH(np_high, np_low, np_close, fastk_period=720, slowk_period=445, slowk_matype=0, slowd_period=445, slowd_matype=0)
|
|
slowk_1440_df, slowd_1440_df = talib.STOCH(np_high, np_low, np_close, fastk_period=1440, slowk_period=890, slowk_matype=0, slowd_period=890, slowd_matype=0)
|
|
willr = talib.WILLR(np_high, np_low, np_close, timeperiod=11) + 100
|
|
rsi = talib.RSI(np_close, timeperiod=9)
|
|
rsi_720 = talib.RSI(np_close, timeperiod=720)
|
|
rsi_1440 = talib.RSI(np_close, timeperiod=1440)
|
|
macd, macds, macdo = talib.MACD(np_close, fastperiod=24, slowperiod=52, signalperiod=18)
|
|
macd_720, macds_720, macdo_720 = talib.MACD(np_close, fastperiod=332, slowperiod=720, signalperiod=250)
|
|
macd_1440, macds_1440, macdo_1440 = talib.MACD(np_close, fastperiod=665, slowperiod=1440, signalperiod=498)
|
|
|
|
"""
|
|
"""
|
|
|
|
df_list = [
|
|
pd.DataFrame(ymd),
|
|
pd.DataFrame(open), pd.DataFrame(close), pd.DataFrame(high), pd.DataFrame(low), pd.DataFrame(volume),
|
|
pd.DataFrame(volume_rate), pd.DataFrame(head_rate), pd.DataFrame(body_rate), pd.DataFrame(tail_rate),
|
|
pd.DataFrame(open_low_rate), pd.DataFrame(open_high_rate), pd.DataFrame(open_open_rate), pd.DataFrame(open_close_rate), pd.DataFrame(close_low_rate), pd.DataFrame(close_high_rate), pd.DataFrame(close_open_rate), pd.DataFrame(close_close_rate),
|
|
|
|
pd.DataFrame(list(support)), pd.DataFrame(list(resistance)),
|
|
pd.DataFrame(poly_5), pd.DataFrame(poly_10), pd.DataFrame(poly_20), pd.DataFrame(poly_60), pd.DataFrame(poly_120), pd.DataFrame(poly_240), pd.DataFrame(poly_480), pd.DataFrame(poly_720), pd.DataFrame(poly_1440),
|
|
|
|
avg5_df, avg10_df, avg20_df, avg60_df, avg120_df, avg240_df, avg480_df, avg720_df, avg1440_df,
|
|
disparity_avg5_df, disparity_avg20_df, disparity_avg60_df, disparity_avg120_df, disparity_avg240_df, disparity_avg480_df, disparity_avg720_df, disparity_avg1440_df, disparity_avg2880_df,
|
|
|
|
pd.DataFrame(new_high_7), pd.DataFrame(new_high_9), pd.DataFrame(new_high_26), pd.DataFrame(new_low_7), pd.DataFrame(new_low_9), pd.DataFrame(new_low_26), pd.DataFrame(high_th),
|
|
pd.DataFrame(upper_20), pd.DataFrame(lower_20), pd.DataFrame(middle_20), bb_width_df, bb_pb_df, pd.DataFrame(willr),
|
|
pd.DataFrame(slowk_5_df), pd.DataFrame(slowd_5_df),
|
|
pd.DataFrame(slowk_10_df), pd.DataFrame(slowd_10_df),
|
|
pd.DataFrame(slowk_20_df), pd.DataFrame(slowd_20_df),
|
|
pd.DataFrame(slowk_60_df), pd.DataFrame(slowd_60_df),
|
|
pd.DataFrame(slowk_120_df), pd.DataFrame(slowd_120_df),
|
|
pd.DataFrame(slowk_240_df), pd.DataFrame(slowd_240_df),
|
|
pd.DataFrame(slowk_480_df), pd.DataFrame(slowd_480_df),
|
|
pd.DataFrame(slowk_720_df), pd.DataFrame(slowd_720_df),
|
|
pd.DataFrame(slowk_1440_df), pd.DataFrame(slowd_1440_df),
|
|
pd.DataFrame(rsi), pd.DataFrame(rsi_720), pd.DataFrame(rsi_1440),
|
|
pd.DataFrame(macd), pd.DataFrame(macds), pd.DataFrame(macdo),
|
|
pd.DataFrame(macd_720), pd.DataFrame(macds_720), pd.DataFrame(macdo_720),
|
|
pd.DataFrame(macd_1440), pd.DataFrame(macds_1440), pd.DataFrame(macdo_1440),
|
|
|
|
pd.DataFrame(open), pd.DataFrame(close), pd.DataFrame(high), pd.DataFrame(low), pd.DataFrame(volume),
|
|
|
|
]
|
|
|
|
data = pd.concat(df_list, axis=1)
|
|
column_names = [
|
|
'ymd',
|
|
'open', 'close', 'high', 'low', 'volume',
|
|
'volume_rate', 'head_rate', 'body_rate', 'tail_rate',
|
|
'open_low_rate', 'open_high_rate', 'open_open_rate', 'open_close_rate', 'close_low_rate', 'close_high_rate', 'close_open_rate', 'close_close_rate',
|
|
'support', 'resistance',
|
|
'poly_5', 'poly_10', 'poly_20', 'poly_60', 'poly_120', 'poly_240', 'poly_480', 'poly_720', 'poly_1440',
|
|
|
|
'avg5', 'avg10', 'avg20', 'avg60', 'avg120', 'avg240', 'avg480', 'avg720', 'avg1440',
|
|
'disparity_avg5', 'disparity_avg20', 'disparity_avg60', 'disparity_avg120', 'disparity_avg240', 'disparity_avg480', 'disparity_avg720', 'disparity_avg1440', 'disparity_avg2880',
|
|
|
|
'new_high_7', 'new_high_9', 'new_high_26', 'new_low_7', 'new_low_9', 'new_low_26', 'high_th',
|
|
'upper_20', 'lower_20', 'middle_20', 'bb_width', 'bb_pb', 'willr',
|
|
'slowk_5', 'slowd_5',
|
|
'slowk_10', 'slowd_10',
|
|
'slowk_20', 'slowd_20',
|
|
'slowk_60', 'slowd_60',
|
|
'slowk_120', 'slowd_120',
|
|
'slowk_240', 'slowd_240',
|
|
'slowk_480', 'slowd_480',
|
|
'slowk_720', 'slowd_720',
|
|
'slowk_1440', 'slowd_1440',
|
|
'rsi', 'rsi_720', 'rsi_1440',
|
|
'macd', 'macds', 'macdo',
|
|
'macd_720', 'macds_720', 'macdo_720',
|
|
'macd_1440', 'macds_1440', 'macdo_1440',
|
|
|
|
'open_raw', 'close_raw', 'high_raw', 'low_raw', 'volume_raw'
|
|
]
|
|
data.columns = column_names
|
|
data.index = pd.DatetimeIndex(ymd)
|
|
#data = data.dropna(axis=0)
|
|
return data, len(data)
|
|
|
|
def analyze_scale(self, result):
|
|
result["volume"] = [result["volume"][i] if 0 < result["volume"][i] else 1 for i in range(len(result["volume"]))]
|
|
# 기본 캔들 정보
|
|
open_df = pd.DataFrame(result["open"])
|
|
close_df = pd.DataFrame(result["close"])
|
|
high_df = pd.DataFrame(result["high"])
|
|
low_df = pd.DataFrame(result["low"])
|
|
volume_df = pd.DataFrame(result["volume"])
|
|
|
|
# 중복 제거
|
|
ymd_df = pd.DataFrame(result["ymd"])
|
|
data_dup = pd.concat([ymd_df, open_df, close_df, high_df, low_df, volume_df], axis=1)
|
|
data_dup.columns = ["ymd", "open", "close", "high", "low", "volume"]
|
|
data_dup.index = pd.DatetimeIndex(result["ymd"])
|
|
data_dup_sorted = data_dup.sort_index(ascending=True)
|
|
data_dup_sorted = data_dup_sorted.drop_duplicates()
|
|
|
|
ymd_df = data_dup_sorted["ymd"]
|
|
open_df = data_dup_sorted["open"]
|
|
close_df = data_dup_sorted["close"]
|
|
high_df = data_dup_sorted["high"]
|
|
low_df = data_dup_sorted["low"]
|
|
volume_df = data_dup_sorted["volume"]
|
|
|
|
ymd = ymd_df.tolist()
|
|
open = open_df.tolist()
|
|
close = close_df.tolist()
|
|
high = high_df.tolist()
|
|
low = low_df.tolist()
|
|
volume = volume_df.tolist()
|
|
|
|
open_scaled = (self.scaler.fit_transform(pd.DataFrame(open))).reshape(1,-1)[0]
|
|
open_scaled = [0.0000000001 if c==0 else c for c in open_scaled]
|
|
close_scaled = (self.scaler.fit_transform(pd.DataFrame(close))).reshape(1,-1)[0]
|
|
close_scaled = [0.0000000001 if c == 0 else c for c in close_scaled]
|
|
high_scaled = (self.scaler.fit_transform(pd.DataFrame(high))).reshape(1,-1)[0]
|
|
high_scaled = [0.0000000001 if c == 0 else c for c in high_scaled]
|
|
low_scaled = (self.scaler.fit_transform(pd.DataFrame(low))).reshape(1,-1)[0]
|
|
low_scaled = [0.0000000001 if c == 0 else c for c in low_scaled]
|
|
volume_scaled = (self.scaler.fit_transform(pd.DataFrame(volume))).reshape(1, -1)[0]
|
|
volume_scaled = [0.0000000001 if c == 0 else c for c in volume_scaled]
|
|
|
|
volume_rate = np.zeros(len(close))
|
|
head_rate, body_rate, tail_rate = np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close))
|
|
open_low_rate, open_high_rate, open_open_rate, open_close_rate = np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close))
|
|
close_low_rate, close_high_rate, close_open_rate, close_close_rate = np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close)), np.zeros(len(close))
|
|
for i in range(len(close)):
|
|
length = high_scaled[i] - low_scaled[i]
|
|
|
|
if 0 < length:
|
|
max_value = max(open_scaled[i], close_scaled[i])
|
|
min_value = min(open_scaled[i], close_scaled[i])
|
|
|
|
head_rate[i] = (high_scaled[i] - max_value) / length
|
|
body_rate[i] = (max_value - min_value) / length
|
|
tail_rate[i] = (min_value - low_scaled[i]) / length
|
|
|
|
if 0 < i:
|
|
if 0 < volume[i-1]:
|
|
volume_rate[i] = volume_scaled[i]/volume_scaled[i-1]
|
|
open_low_rate[i] = (low_scaled[i] - open_scaled[i-1])/open_scaled[i-1]
|
|
open_high_rate[i] = (high_scaled[i] - open_scaled[i-1])/open_scaled[i-1]
|
|
open_open_rate[i] = (open_scaled[i] - open_scaled[i-1])/open_scaled[i-1]
|
|
open_close_rate[i] = (close_scaled[i] - open_scaled[i-1])/open_scaled[i-1]
|
|
close_low_rate[i] = (low_scaled[i] - close_scaled[i-1])/close_scaled[i-1]
|
|
close_high_rate[i] = (high_scaled[i] - close_scaled[i-1])/close_scaled[i-1]
|
|
close_open_rate[i] = (open_scaled[i] - close_scaled[i-1])/close_scaled[i-1]
|
|
close_close_rate[i] = (close_scaled[i] - close_scaled[i-1])/close_scaled[i-1]
|
|
|
|
|
|
support, resistance = self.get_Support_Resistance(pd.DataFrame(close_scaled))
|
|
|
|
#z = np.polyfit(df['speed'], df['dist'], 1) # 기울기와 절편 확인
|
|
#f = np.poly1d(z) # f(x): f함수
|
|
if 5 < len(close):
|
|
poly_5 = [0] * 4 + [np.polyfit(range(5), close[i - 4: i + 1], 1)[0] for i in range(4, len(close))]
|
|
else:
|
|
poly_5 = [0] * len(close)
|
|
if 10 < len(close):
|
|
poly_10 = [0] * 9 + [np.polyfit(range(10), close[i - 9: i + 1], 1)[0] for i in range(9, len(close))]
|
|
else:
|
|
poly_10 = [0] * len(close)
|
|
if 20 < len(close):
|
|
poly_20 = [0] * 19 + [np.polyfit(range(20), close[i - 19: i + 1], 1)[0] for i in range(19, len(close))]
|
|
else:
|
|
poly_20 = [0] * len(close)
|
|
if 60 < len(close):
|
|
poly_60 = [0] * 59 + [np.polyfit(range(60), close[i - 59: i + 1], 1)[0] for i in range(59, len(close))]
|
|
else:
|
|
poly_60 = [0] * len(close)
|
|
if 120 < len(close):
|
|
poly_120 = [0] * 119 + [np.polyfit(range(120), close[i - 119: i + 1], 1)[0] for i in range(119, len(close))]
|
|
else:
|
|
poly_120 = [0] * len(close)
|
|
if 240 < len(close):
|
|
poly_240 = [0] * 239 + [np.polyfit(range(240), close[i - 239: i + 1], 1)[0] for i in range(239, len(close))]
|
|
else:
|
|
poly_240 = [0] * len(close)
|
|
if 480 < len(close):
|
|
poly_480 = [0] * 479 + [np.polyfit(range(480), close[i - 479: i + 1], 1)[0] for i in range(479, len(close))]
|
|
else:
|
|
poly_480 = [0] * len(close)
|
|
if 720 < len(close):
|
|
poly_720 = [0] * 719 + [np.polyfit(range(720), close[i - 719: i + 1], 1)[0] for i in range(719, len(close))]
|
|
else:
|
|
poly_720 = [0] * len(close)
|
|
if 1440 < len(close):
|
|
poly_1440 = [0] * 1439 + [np.polyfit(range(1440), close[i - 1439: i + 1], 1)[0] for i in range(1439, len(close))]
|
|
else:
|
|
poly_1440 = [0] * len(close)
|
|
|
|
# 7일 신고가
|
|
new_high_7 = [0 for c in range(6)] + [1 if (close_scaled[c - 1] is not None and close_scaled[c] is not None and close_scaled[c - 1] < close_scaled[c]) and None not in close_scaled[c - 6:c + 1] and max(close_scaled[c - 6:c]) < close_scaled[c] else 0 for c in range(6, len(close_scaled))]
|
|
# 9일 신고가
|
|
new_high_9 = [0 for c in range(8)] + [1 if (close_scaled[c - 1] is not None and close_scaled[c] is not None and close_scaled[c - 1] < close_scaled[c]) and None not in close_scaled[c - 8:c + 1] and max(close_scaled[c - 8:c]) < close_scaled[c] else 0 for c in range(8, len(close_scaled))]
|
|
# 26일 신고가
|
|
new_high_26 = [0 for c in range(25)] + [1 if (close_scaled[c - 1] is not None and close_scaled[c] is not None and close_scaled[c - 1] < close_scaled[c]) and None not in close_scaled[c - 25:c + 1] and max(close_scaled[c - 25:c]) < close_scaled[c] else 0 for c in range(25, len(close_scaled))]
|
|
|
|
# 7일 신저가
|
|
new_low_7 = [0 for c in range(6)] + [1 if (close_scaled[c - 1] is not None and close_scaled[c] is not None and close_scaled[c - 1] < close_scaled[c]) and None not in close_scaled[c - 6:c + 1] and close_scaled[c - 6] < min(close_scaled[c - 6:c + 1]) else 0 for c in range(6, len(close_scaled))]
|
|
# 9일 신저가
|
|
new_low_9 = [0 for c in range(8)] + [1 if (close_scaled[c - 1] is not None and close_scaled[c] is not None and close_scaled[c - 1] < close_scaled[c]) and None not in close_scaled[c - 8:c + 1] and close_scaled[c - 8] < min(close_scaled[c - 8:c + 1]) else 0 for c in range(8, len(close_scaled))]
|
|
# 26일 신저가
|
|
new_low_26 = [0 for c in range(25)] + [1 if (close_scaled[c - 1] is not None and close_scaled[c] is not None and close_scaled[c - 1] < close_scaled[c]) and None not in close_scaled[c - 25:c + 1] and close_scaled[c - 25] < min(close_scaled[c - 25:c + 1]) else 0 for c in range(25, len(close_scaled))]
|
|
|
|
high_th = [0]
|
|
for i in range(1, len(close_scaled)):
|
|
count = 0
|
|
for c in range(i-1,i-30,-1):
|
|
if c < 0:
|
|
break
|
|
if close_scaled[i] < close_scaled[c]:
|
|
break
|
|
else:
|
|
count += 1
|
|
high_th.append(count)
|
|
|
|
# 이동 평균
|
|
close_df = pd.DataFrame(close_scaled)
|
|
|
|
avg5_df = close_df.ewm(5).mean()
|
|
avg10_df = close_df.ewm(10).mean()
|
|
avg20_df = close_df.ewm(20).mean()
|
|
avg60_df = close_df.ewm(60).mean()
|
|
avg120_df = close_df.ewm(120).mean()
|
|
avg240_df = close_df.ewm(240).mean()
|
|
avg480_df = close_df.ewm(480).mean()
|
|
avg720_df = close_df.ewm(720).mean()
|
|
avg1440_df = close_df.ewm(1440).mean()
|
|
|
|
# 이격도
|
|
disparity_avg5_df = (close_df / close_df.ewm(span=5, min_periods=5, adjust=False).mean())
|
|
disparity_avg5_df = disparity_avg5_df.replace({None: np.nan})
|
|
disparity_avg20_df = (close_df / close_df.ewm(span=20, min_periods=20, adjust=False).mean())
|
|
disparity_avg20_df = disparity_avg20_df.replace({None: np.nan})
|
|
disparity_avg60_df = (close_df / close_df.ewm(span=60, min_periods=60, adjust=False).mean())
|
|
disparity_avg60_df = disparity_avg60_df.replace({None: np.nan})
|
|
disparity_avg120_df = (close_df / close_df.ewm(span=120, min_periods=120, adjust=False).mean())
|
|
disparity_avg120_df = disparity_avg120_df.replace({None: np.nan})
|
|
disparity_avg240_df = (close_df / close_df.ewm(span=240, min_periods=240, adjust=False).mean())
|
|
disparity_avg240_df = disparity_avg240_df.replace({None: np.nan})
|
|
disparity_avg480_df = (close_df / close_df.ewm(span=480, min_periods=480, adjust=False).mean())
|
|
disparity_avg480_df = disparity_avg480_df.replace({None: np.nan})
|
|
disparity_avg720_df = (close_df / close_df.ewm(span=720, min_periods=720, adjust=False).mean())
|
|
disparity_avg720_df = disparity_avg720_df.replace({None: np.nan})
|
|
disparity_avg1440_df = (close_df / close_df.ewm(span=1440, min_periods=1440, adjust=False).mean())
|
|
disparity_avg1440_df = disparity_avg1440_df.replace({None: np.nan})
|
|
disparity_avg2880_df = (close_df / close_df.ewm(span=2880, min_periods=2880, adjust=False).mean())
|
|
disparity_avg2880_df = disparity_avg2880_df.replace({None: np.nan})
|
|
|
|
disparity_avg5_list = list(disparity_avg5_df.values.reshape(-1))
|
|
disparity_avg20_list = list(disparity_avg20_df.values.reshape(-1))
|
|
disparity_avg60_list = list(disparity_avg60_df.values.reshape(-1))
|
|
disparity_avg120_list = list(disparity_avg120_df.values.reshape(-1))
|
|
disparity_avg240_list = list(disparity_avg240_df.values.reshape(-1))
|
|
disparity_avg480_list = list(disparity_avg480_df.values.reshape(-1))
|
|
disparity_avg720_list = list(disparity_avg720_df.values.reshape(-1))
|
|
disparity_avg1440_list = list(disparity_avg1440_df.values.reshape(-1))
|
|
|
|
disparity_diff_20_5, disparity_diff_20_5_rate = self.getDiff_Rate(disparity_avg20_list, disparity_avg5_list, duration=20)
|
|
disparity_diff_60_20, disparity_diff_60_20_rate = self.getDiff_Rate(disparity_avg60_list, disparity_avg20_list, duration=60)
|
|
disparity_diff_120_20, disparity_diff_120_20_rate = self.getDiff_Rate(disparity_avg120_list, disparity_avg20_list, duration=120)
|
|
disparity_diff_240_20, disparity_diff_240_20_rate = self.getDiff_Rate(disparity_avg240_list, disparity_avg20_list, duration=240)
|
|
disparity_diff_480_20, disparity_diff_480_20_rate = self.getDiff_Rate(disparity_avg480_list, disparity_avg20_list, duration=480)
|
|
disparity_diff_720_20, disparity_diff_720_20_rate = self.getDiff_Rate(disparity_avg720_list, disparity_avg20_list, duration=720)
|
|
disparity_diff_1440_20, disparity_diff_1440_20_rate = self.getDiff_Rate(disparity_avg1440_list, disparity_avg20_list, duration=1440)
|
|
|
|
|
|
""""""
|
|
n, t = 20, 2
|
|
max_20 = close_df.rolling(window=n).mean()
|
|
stddev_20 = close_df.rolling(window=n).std()
|
|
upper_20 = max_20 + (stddev_20 * t) # 상단 볼리저 밴드
|
|
lower_20 = max_20 - (stddev_20 * t) # 하단 볼리저 밴드
|
|
middle_20 = (upper_20 + lower_20) / 2
|
|
|
|
width_df = (upper_20 - lower_20) / middle_20
|
|
width_min = np.min(width_df[0])
|
|
width_max = np.max(width_df[0])
|
|
bb_width_df = 100 * (width_df - width_min) / (width_max - width_min)
|
|
bb_pb_df = 100 * (close_df - lower_20) / (upper_20 - lower_20)
|
|
|
|
upper_20 = list(np.reshape(upper_20.values, -1))
|
|
lower_20 = list(np.reshape(lower_20.values, -1))
|
|
middle_20 = list(np.reshape(middle_20.values, -1))
|
|
|
|
np_high, np_low, np_close = np.array(high_scaled, dtype=np.float64), np.array(low_scaled, dtype=np.float64), np.array(close_scaled, dtype=np.float64)
|
|
slowk_5_df, slowd_5_df = talib.STOCH(np_high, np_low, np_close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
|
|
slowk_10_df, slowd_10_df = talib.STOCH(np_high, np_low, np_close, fastk_period=10, slowk_period=6, slowk_matype=0, slowd_period=6, slowd_matype=0)
|
|
slowk_20_df, slowd_20_df = talib.STOCH(np_high, np_low, np_close, fastk_period=20, slowk_period=12, slowk_matype=0, slowd_period=12, slowd_matype=0)
|
|
slowk_60_df, slowd_60_df = talib.STOCH(np_high, np_low, np_close, fastk_period=60, slowk_period=37, slowk_matype=0, slowd_period=37, slowd_matype=0)
|
|
slowk_120_df, slowd_120_df = talib.STOCH(np_high, np_low, np_close, fastk_period=120, slowk_period=74, slowk_matype=0, slowd_period=74, slowd_matype=0)
|
|
slowk_240_df, slowd_240_df = talib.STOCH(np_high, np_low, np_close, fastk_period=240, slowk_period=148, slowk_matype=0, slowd_period=148, slowd_matype=0)
|
|
slowk_480_df, slowd_480_df = talib.STOCH(np_high, np_low, np_close, fastk_period=480, slowk_period=296, slowk_matype=0, slowd_period=296, slowd_matype=0)
|
|
slowk_720_df, slowd_720_df = talib.STOCH(np_high, np_low, np_close, fastk_period=720, slowk_period=445, slowk_matype=0, slowd_period=445, slowd_matype=0)
|
|
slowk_1440_df, slowd_1440_df = talib.STOCH(np_high, np_low, np_close, fastk_period=1440, slowk_period=890, slowk_matype=0, slowd_period=890, slowd_matype=0)
|
|
willr = talib.WILLR(np_high, np_low, np_close, timeperiod=11) + 100
|
|
rsi = talib.RSI(np_close, timeperiod=9)
|
|
rsi_720 = talib.RSI(np_close, timeperiod=720)
|
|
rsi_1440 = talib.RSI(np_close, timeperiod=1440)
|
|
macd, macds, macdo = talib.MACD(np_close, fastperiod=24, slowperiod=52, signalperiod=18)
|
|
macd_720, macds_720, macdo_720 = talib.MACD(np_close, fastperiod=332, slowperiod=720, signalperiod=250)
|
|
macd_1440, macds_1440, macdo_1440 = talib.MACD(np_close, fastperiod=665, slowperiod=1440, signalperiod=498)
|
|
|
|
"""
|
|
"""
|
|
|
|
df_list = [
|
|
pd.DataFrame(ymd),
|
|
pd.DataFrame(open_scaled), pd.DataFrame(close_scaled), pd.DataFrame(high_scaled), pd.DataFrame(low_scaled), pd.DataFrame(volume_scaled),
|
|
pd.DataFrame(volume_rate), pd.DataFrame(head_rate), pd.DataFrame(body_rate), pd.DataFrame(tail_rate),
|
|
pd.DataFrame(open_low_rate), pd.DataFrame(open_high_rate), pd.DataFrame(open_open_rate), pd.DataFrame(open_close_rate), pd.DataFrame(close_low_rate), pd.DataFrame(close_high_rate), pd.DataFrame(close_open_rate), pd.DataFrame(close_close_rate),
|
|
|
|
pd.DataFrame(list(support)), pd.DataFrame(list(resistance)),
|
|
pd.DataFrame(poly_5), pd.DataFrame(poly_10), pd.DataFrame(poly_20), pd.DataFrame(poly_60), pd.DataFrame(poly_120), pd.DataFrame(poly_240), pd.DataFrame(poly_480), pd.DataFrame(poly_720), pd.DataFrame(poly_1440),
|
|
|
|
avg5_df, avg10_df, avg20_df, avg60_df, avg120_df, avg240_df, avg480_df, avg720_df, avg1440_df,
|
|
disparity_avg5_df, disparity_avg20_df, disparity_avg60_df, disparity_avg120_df, disparity_avg240_df, disparity_avg480_df, disparity_avg720_df, disparity_avg1440_df, disparity_avg2880_df,
|
|
pd.DataFrame(disparity_diff_20_5), pd.DataFrame(disparity_diff_20_5_rate),
|
|
pd.DataFrame(disparity_diff_60_20), pd.DataFrame(disparity_diff_60_20_rate),
|
|
pd.DataFrame(disparity_diff_120_20), pd.DataFrame(disparity_diff_120_20_rate),
|
|
pd.DataFrame(disparity_diff_240_20), pd.DataFrame(disparity_diff_240_20_rate),
|
|
pd.DataFrame(disparity_diff_480_20), pd.DataFrame(disparity_diff_480_20_rate),
|
|
pd.DataFrame(disparity_diff_720_20), pd.DataFrame(disparity_diff_720_20_rate),
|
|
pd.DataFrame(disparity_diff_1440_20), pd.DataFrame(disparity_diff_1440_20_rate),
|
|
|
|
pd.DataFrame(new_high_7), pd.DataFrame(new_high_9), pd.DataFrame(new_high_26), pd.DataFrame(new_low_7), pd.DataFrame(new_low_9), pd.DataFrame(new_low_26), pd.DataFrame(high_th),
|
|
pd.DataFrame(upper_20), pd.DataFrame(lower_20), pd.DataFrame(middle_20), bb_width_df, bb_pb_df, pd.DataFrame(willr),
|
|
pd.DataFrame(slowk_5_df), pd.DataFrame(slowd_5_df),
|
|
pd.DataFrame(slowk_10_df), pd.DataFrame(slowd_10_df),
|
|
pd.DataFrame(slowk_20_df), pd.DataFrame(slowd_20_df),
|
|
pd.DataFrame(slowk_60_df), pd.DataFrame(slowd_60_df),
|
|
pd.DataFrame(slowk_120_df), pd.DataFrame(slowd_120_df),
|
|
pd.DataFrame(slowk_240_df), pd.DataFrame(slowd_240_df),
|
|
pd.DataFrame(slowk_480_df), pd.DataFrame(slowd_480_df),
|
|
pd.DataFrame(slowk_720_df), pd.DataFrame(slowd_720_df),
|
|
pd.DataFrame(slowk_1440_df), pd.DataFrame(slowd_1440_df),
|
|
pd.DataFrame(rsi), pd.DataFrame(rsi_720), pd.DataFrame(rsi_1440),
|
|
pd.DataFrame(macd), pd.DataFrame(macds), pd.DataFrame(macdo),
|
|
pd.DataFrame(macd_720), pd.DataFrame(macds_720), pd.DataFrame(macdo_720),
|
|
pd.DataFrame(macd_1440), pd.DataFrame(macds_1440), pd.DataFrame(macdo_1440),
|
|
|
|
pd.DataFrame(open), pd.DataFrame(close), pd.DataFrame(high), pd.DataFrame(low), pd.DataFrame(volume)
|
|
]
|
|
|
|
data = pd.concat(df_list, axis=1)
|
|
column_names = [
|
|
'ymd',
|
|
'open', 'close', 'high', 'low', 'volume',
|
|
'volume_rate', 'head_rate', 'body_rate', 'tail_rate',
|
|
'open_low_rate', 'open_high_rate', 'open_open_rate', 'open_close_rate', 'close_low_rate', 'close_high_rate', 'close_open_rate', 'close_close_rate',
|
|
|
|
'support', 'resistance',
|
|
'poly_5', 'poly_10', 'poly_20', 'poly_60', 'poly_120', 'poly_240', 'poly_480', 'poly_720', 'poly_1440',
|
|
|
|
'avg5', 'avg10', 'avg20', 'avg60', 'avg120', 'avg240', 'avg480', 'avg720', 'avg1440',
|
|
'disparity_avg5', 'disparity_avg20', 'disparity_avg60', 'disparity_avg120', 'disparity_avg240', 'disparity_avg480', 'disparity_avg720', 'disparity_avg1440', 'disparity_avg2880',
|
|
'disparity_diff_20_5', 'disparity_diff_20_5_rate',
|
|
'disparity_diff_60_20', 'disparity_diff_60_20_rate',
|
|
'disparity_diff_120_20', 'disparity_diff_120_20_rate',
|
|
'disparity_diff_240_20', 'disparity_diff_240_20_rate',
|
|
'disparity_diff_480_20', 'disparity_diff_480_20_rate',
|
|
'disparity_diff_720_20', 'disparity_diff_720_20_rate',
|
|
'disparity_diff_1440_20', 'disparity_diff_1440_20_rate',
|
|
|
|
'new_high_7', 'new_high_9', 'new_high_26', 'new_low_7', 'new_low_9', 'new_low_26', 'high_th',
|
|
'upper_20', 'lower_20', 'middle_20', 'bb_width', 'bb_pb', 'willr',
|
|
'slowk_5', 'slowd_5',
|
|
'slowk_10', 'slowd_10',
|
|
'slowk_20', 'slowd_20',
|
|
'slowk_60', 'slowd_60',
|
|
'slowk_120', 'slowd_120',
|
|
'slowk_240', 'slowd_240',
|
|
'slowk_480', 'slowd_480',
|
|
'slowk_720', 'slowd_720',
|
|
'slowk_1440', 'slowd_1440',
|
|
'rsi', 'rsi_720', 'rsi_1440',
|
|
'macd', 'macds', 'macdo',
|
|
'macd_720', 'macds_720', 'macdo_720',
|
|
'macd_1440', 'macds_1440', 'macdo_1440',
|
|
|
|
'open_raw', 'close_raw', 'high_raw', 'low_raw', 'volume_raw'
|
|
]
|
|
data.columns = column_names
|
|
data.index = pd.DatetimeIndex(ymd)
|
|
#data = data.dropna(axis=0)
|
|
return data, len(data)
|
|
|
|
def getData(self, ticker, mins=None, ymd=None, get_days=14):
|
|
if ymd is None:
|
|
result = self.getCoinData(ticker, mins=mins, get_days=get_days)
|
|
else:
|
|
result = self.getCoinData(ticker, mins=mins, ymd=ymd, get_days=get_days)
|
|
|
|
if len(result['ymd']) < 1:
|
|
return None, None, None
|
|
|
|
#result_tic = self.makeTickData(result_m1, mins=minute)
|
|
data_scale, ci = self.analyze_scale(result)
|
|
data, ci = self.analyze_raw(result)
|
|
|
|
ticker['disparity_low_min'] = self.getDisparity_low_min(ticker, min='minutely')
|
|
|
|
return data, data_scale, ci |