def __init__(self, ind: str, params: dict,
buffer_day: int, frequency: str) -> None:
name = f"{ind}_{next(self.counter)}"
self.indicator = Function(ind)
self.indicator.set_parameters(params)
rolling_window = self.indicator.lookback+1
super().__init__(name, rolling_window, buffer_day, frequency)
self.save_to_env(self)
self.data = self.get_data()
def __init__(self,
ind: str,
params: dict,
frequency: str = None,
buffer_day: int = 5) -> None:
super().__init__(None, buffer_day, frequency)
self.indicator = Function(ind)
self.indicator.set_parameters(params)
self.rolling_window = self.indicator.lookback + 1
self.data = defaultdict(dict) # type:dict[str,dict[str,deque]]
def set_factors_labels(self, price=None, ta_list=None, lags=None):
"""
根据价格数据及选定的指标计算特征
:return: the factors array DataFrame
"""
ta_fun_names = ta.get_functions()
df_price = price if price else self.price_data
ta_list = ta_list if ta_list else self.dic_factors
lags = lags if lags else self.ta_lags
ta_factors = df_price.copy()
ii = 1
for j in ta_list:
if j[0] in ta_fun_names:
ta_fun = Function(j[0])
if j[1] == {}:
ta_fun = ta_fun
else:
dic_param = dict(ta_fun.parameters)
for key1 in dic_param:
dic_param[key1] = j[1][key1]
ta_fun.parameters = dic_param
ta_value = ta_fun(df_price)
if ta_value.size > len(ta_value):
ta_factors["%s_%d" % (j[0], ii)] = ta_value.ix[:, 0]
else:
ta_factors["%s_%d" % (j[0], ii)] = ta_value
ii += 1
ta_factors['ACC'] = TSSB_TA(df_price).ACC()
ta_factors['ADOSC'] = TSSB_TA(df_price).ADOSC()
# 计算lags指标
if lags > 0:
ret = pd.DataFrame(index=ta_factors.index)
columns = ta_factors.columns
for col in columns:
for lag in xrange(0, lags):
ret[col + "_%s" % str(lag+1)] = ta_factors[col].shift(lag)
else:
ret = ta_factors
# 定义标签: 上涨为1， 下跌为-1
if self.predict_type == 1:
labels = df_price['close'].pct_change().shift(-1) # 预测明收盘与今收盘的涨跌
else:
labels = (df_price['close'] - df_price['open']).shift(-1) # 预测明收盘与明开盘的涨跌
labels[labels >= 0] = 1
labels[labels < 0] = 0
ret = ret.dropna()
labels = labels[ret.index]
self.ta_factors, self.labels = ret, labels
return ret, labels
def abstract_example():
sma = Function('sma')
input_arrays = sma.get_input_arrays()
for key in input_arrays.keys():
input_arrays[key] = idata
sma.set_input_arrays(input_arrays)
odata = sma(30) # timePeriod=30, specified as an arg
bbands = Function('bbands', input_arrays)
bbands.set_function_parameters(timePeriod=20, nbDevUp=2, nbDevDown=2)
upper, middle, lower = bbands(
) # multiple output values unpacked (these will always have the correct order)
kama = Function('kama').run(
input_arrays) # alternative run() calling method.
plot(odata, upper, middle, lower, kama)
def ta(symbol, indicators, timeframe='15m', limit=100, csv=False, params=''):
args = []
if len(params):
args = params.split(',') if ',' in params else [params]
args = map(lambda a: float(a) if '.' in a else int(a), args)
df = ohlc(symbol, timeframe, limit, _raw=True) # type: pd.DataFrame
df.index = df.pop('date')
table_data = list()
for indicator in indicators.split(','):
fn = Function(indicator.upper())
d = fn(df, *args).bfill().round(8)
if csv:
df[indicator.lower()] = d
else:
table_data.append(
[indicator.upper(), d[-1],
d.diff().round(8)[-1]])
if csv:
from io import StringIO
str_io = StringIO()
df.insert(0, 'date', [int(d.timestamp()) for d in df.index])
df = df.reset_index(drop=True)
df.to_csv(str_io, index=False, float_format='.8f')
print(str_io.getvalue())
else:
print(' === {} ==='.format(symbol))
print(
tabulate(table_data,
headers=['Indicator', 'Value', 'Diff'],
stralign='center',
numalign='right',
tablefmt='fancy_grid'))
def SAREXT(data,
start=0,
offset_on_reverse=0,
accel_init_long=0.02,
accel_long=0.02,
accel_max_long=0.2,
accel_init_short=0.02,
accel_short=0.02,
accel_max_short=0.2):
"""
Parabolic SAR - Extended
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:param start: start value
:param int offset_on_reverse: offset on reverse
:param float accel_init_long: initial long acceleration factor
:param float accel_long: long acceleration factor
:param float accel_max_long: max long acceleration factor
:param float accel_init_short: initial short acceleration factor
:param float accel_short: short acceleration factor
:param float accel_max_short: max short acceleration factor
:return pd.Series: with indicator data calculation results with indicator data calculation results
"""
fn = Function('SAREXT')
return fn(data,
startvalue=start,
offsetonreverse=offset_on_reverse,
accelerationinitlong=accel_init_long,
accelerationlong=accel_long,
accelerationmaxlong=accel_max_long,
accelerationinitshort=accel_init_short,
accelerationshort=accel_short,
accelerationmaxshort=accel_max_short)
def MACDEXT(data,
fast_period=12,
fast_ma_type=0,
slow_period=26,
slow_ma_type=0,
signal_period=9,
signal_ma_type=0):
"""
Moving Average Convergence Divergence Extended
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:param int fast_period: fast period used for indicator calculation
:param int fast_ma_type: fast moving average type (0 simple, 1 exponential)
:param int slow_period: slow period used for indicator calculation
:param int slow_ma_type: slow moving average type (0 simple, 1 exponential)
:param int signal_period: period used for signal calculation
:param int signal_ma_type: signal moving average type (0 simple, 1 exponential)
:return pd.Series: with indicator data calculation results with indicator data calculation results
"""
fn = Function('MACDEXT')
return fn(data,
fastperiod=fast_period,
fastmatype=fast_ma_type,
slowperiod=slow_period,
slowmatype=slow_ma_type,
signalperiod=signal_period,
signalmatype=signal_ma_type)
def STOCH(data,
fastk_period=5,
slowk_period=3,
slowk_ma_type=0,
slowd_period=3,
slowd_ma_type=0):
"""
Stochastic Oscillator
The Stochastic Oscillator is a momentum indicator comparing the closing price of a security to the range of it's
prices over a certain period of time.
The sensitivity of the oscillator to market movements is reducible by adjusting that time period or by taking a
moving average of the result.
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:param int fastk_period: period used for K fast indicator calculation
:param int slowk_period: period used for K slow indicator calculation
:param int slowk_ma_type: slow K moving average type (0 simple, 1 exponential)
:param int slowd_period: period used for D slow indicator calculation
:param int slowd_ma_type: slow D moving average type (0 simple, 1 exponential)
:return pd.Series: with indicator data calculation results
"""
fn = Function('STOCH')
return fn(data,
fastk_period=fastk_period,
slowk_period=slowk_period,
slowk_matype=slowk_ma_type,
slowd_matype=slowd_ma_type,
slowd_period=slowd_period)
def ULTOSC(data, period1=7, period2=14, period3=28):
"""
Ultimate Oscillator
UO or ULTOSC is a momentum oscillator designed to capture momentum across three different time frames.
The multiple time frame objective seeks to avoid the pitfalls of other oscillators.
Many momentum oscillators surge at the beginning of a strong advance and then form bearish divergence as the
advance continues.
This is because they are stuck with one time frame. The Ultimate Oscillator attempts to correct this fault by
incorporating longer time frames into the basic formula.
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:param int period1: first period used for indicator calculation period used for indicator calculation
:param int period2: second period used for indicator calculation period used for indicator calculation
:param int period3: third period used for indicator calculation period used for indicator calculation
:return pd.Series: with indicator data calculation results
"""
fn = Function('ULTOSC')
return fn(data,
timeperiod1=period1,
timeperiod2=period2,
timeperiod3=period3)
def get_ta_functions():
# func_names = []
func_groups = ['Volume Indicators', 'Volatility Indicators',
'Overlap Studies', 'Momentum Indicators']
func_names = [func_name for g in func_groups for func_name in ta.get_function_groups()[g]]
funcs = {func_name: Function(func_name) for func_name in func_names}
return funcs
def THRUSTING(data):
"""
Thrusting Pattern
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLTHRUSTING')
return fn(data)
def THREE_STARSINSOUTH(data):
"""
Three Stars In The South
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDL3STARSINSOUTH')
return fn(data)
def ABANDONED_BABY(data):
"""
Abandoned Baby
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLABANDONEDBABY')
return fn(data)
def STICK_SANDWICH(data):
"""
Stick Sandwich
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLSTICKSANDWICH')
return fn(data)
def X_SIDE_GAP_THREE_METHODS(data):
"""
Upside/Downside Gap Three Methods
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLXSIDEGAP3METHODS')
return fn(data)
def CLOSING_MARUBOZU(data):
"""
Closing Marubozu
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLCLOSINGMARUBOZU')
return fn(data)
def UPSIDE_GAP_TWO_CROWS(data):
"""
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLUPSIDEGAP2CROWS')
return fn(data)
def THREE_OUTSIDE(data):
"""
Three Outside Up/Down
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDL3OUTSIDE')
return fn(data)
def BREAKAWAY(data):
"""
Breakaway
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLBREAKAWAY')
return fn(data)
def ADVANCE_BLOCK(data):
"""
Advance Block
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLADVANCEBLOCK')
return fn(data)
def TWO_CROWS(data):
"""
Two Crows
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDL2CROWS')
return fn(data)
def THREE_BLACK_CROWS(data):
"""
Three Black Crows
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDL3BLACKCROWS')
return fn(data)
def HT_SINE(data):
"""
Hilbert Transform - SineWave Indicator
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('HT_SINE')
return fn(data)
def TAKURI(data):
"""
Takuri (Dragonfly Doji with very long lower shadow)
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLTAKURI')
return fn(data)
def TASUKI_GAP(data):
"""
Tasuki Gap
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLTASUKIGAP')
return fn(data)
def BOP(data):
"""
Balance of Power Indicator
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('BOP')
return fn(data)
def THREE_LINE_STRIKE(data):
"""
Three-Line Strike
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDL3LINESTRIKE')
return fn(data)
def UNIQUE_THREE_RIVER(data):
"""
Unique 3 River
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLUNIQUE3RIVER')
return fn(data)
def THREE_WHITE_SOLDIERS(data):
"""
Three Advancing White Soldiers
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDL3WHITESOLDIERS')
return fn(data)
def TRISTAR(data):
"""
Tristar Pattern
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLTRISTAR')
return fn(data)
def BELT_HOLD(data):
"""
Belt-hold
:param pd.DataFrame data: pandas DataFrame with open, high, low, close data
:return pd.Series: with indicator data calculation results
"""
fn = Function('CDLBELTHOLD')
return fn(data)
def __ta_look_back(self):
"""
获取所需回溯历史数据的长度，计算技术指标时需要n天前的数据，同时预测涨跌时又要windows_size的历史指标
:return:
"""
ta_fun_names = ta.get_functions()
lk_list = []
for j in self.dic_factors:
if j[0] in ta_fun_names:
ta_fun = Function(j[0])
if j[1] == {}:
continue
else:
dic_param = dict(ta_fun.parameters)
for key1 in dic_param:
dic_param[key1] = j[1][key1]
ta_fun.parameters = dic_param
lk = ta_fun.lookback
lk_list.append(lk)
else:
pass
ret = max(lk_list)
return ret
def abstract_example():
sma = Function('sma')
input_arrays = sma.get_input_arrays()
for key in input_arrays.keys():
input_arrays[key] = idata
sma.set_input_arrays(input_arrays)
odata = sma(30) # timePeriod=30, specified as an arg
bbands = Function('bbands', input_arrays)
bbands.set_function_parameters(timePeriod=20, nbDevUp=2, nbDevDown=2)
upper, middle, lower = bbands() # multiple output values unpacked (these will always have the correct order)
kama = Function('kama').run(input_arrays) # alternative run() calling method.
plot(odata, upper, middle, lower, kama)
def abstract_example():
sma = Function("sma")
input_arrays = sma.get_input_arrays()
for key in input_arrays.keys():
input_arrays[key] = idata
sma.set_input_arrays(input_arrays)
odata = sma(30) # timePeriod=30, specified as an arg
bbands = Function("bbands", input_arrays)
bbands.parameters = {"timeperiod": 20, "nbdevup": 2, "nbdevdn": 2}
upper, middle, lower = bbands() # multiple output values unpacked (these will always have the correct order)
kama = Function("kama").run(input_arrays) # alternative run() calling method.
plot(odata, upper, middle, lower, kama)
