def add_MIDPRICE(self, df, periods=[5, 10, 14, 20, 30, 60, 120]):
for i in periods:
period = str(i)
df['MIDPRICE_' + period] = ta.MIDPRICE(df['high'],
df['low'],
timeperiod=i)
return df
def compMidPrice(self):
mp = talib.MIDPRICE(self.high,self.low,timeperiod=self.lookback)
self.removeNullID(mp)
self.rawFeatures['MIDPRICE'] = mp
FEATURE_SIZE_DICT['MIDPRICE'] = 1
return
def mid_price(self, sym, frequency, *args, **kwargs):
if not self.kbars_ready(sym, frequency):
return []
highs = self.high(sym, frequency)
lows = self.low(sym, frequency)
v = ta.MIDPRICE(highs, lows, *args, **kwargs)
return v
def MIDPRICE(high, low, timeperiod=14):
''' Midpoint Price over period
分组: Overlap Studies 重叠研究
简介:
分析和应用:
real = MIDPRICE(high, low, timeperiod=14)
'''
return talib.MIDPRICE(high, low, timeperiod)
def test_midprice(self):
result = self.overlap.midprice(self.high, self.low)
self.assertIsInstance(result, Series)
self.assertEqual(result.name, 'MIDPRICE_2')
try:
expected = tal.MIDPRICE(self.high, self.low, 2)
pdt.assert_series_equal(result, expected, check_names=False)
except AssertionError as ae:
try:
corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION)
self.assertGreater(corr, CORRELATION_THRESHOLD)
except Exception as ex:
error_analysis(result, CORRELATION, ex)
def mid_price(self, df, period):
"""(highest high + lowest low)/2 over period
Args:
high, low: high, low price of instrument
period: number of time periods in the calculation
feature_dict: Dictionary of added features
Return:
midPrice: resulting signal
feature_dict
"""
col_name = 'Midprice_' + str(period)
current_feature['Latest'] = col_name
feature_dict[col_name] = 'Keep'
df[col_name] = ta.MIDPRICE(df.High, df.Low, period)
return df
def midprice(high, low, graph=False, **kwargs):
'''
MIDPRICE - Midpoint Price over period
'''
result = talib.MIDPRICE(high, low, **kwargs)
df = pd.concat(
[pd.DataFrame(high),
pd.DataFrame(low),
pd.DataFrame(result)], axis=1)
df.columns = ['high', 'low', 'midprice']
if graph:
title = 'MIDPRICE - Midpoint Price over period'
style = ['r-'] + ['g-'] + ['--'] * (len(df.columns) - 2)
fname = '10_midprice.png'
make_graph(title, df, style=style, fname=fname)
return df
def overlap(self): upper, middle, lower = talib.BBANDS(self.close,timeperiod=5,nbdevup=2,nbdevdn=2,matype=0) EMA = talib.EMA(self.close,self.period) HT_trendline = talib.HT_TRENDLINE(self.close) KAMA = talib.KAMA(self.close,self.period) MA = talib.MA(self.close,self.period,matype=0) mama, fama = talib.MAMA(self.close,fastlimit = 0.5,slowlimit = 0.05) mavp = talib.MAVP(self.close, minperiod = 5,maxperiod = 30,matype=0) midpoint = talib.MIDPOINT(self.close,self.period) midprice = talib.MIDPRICE(self.high,self.low,self.period) sar = talib.SAR(self.high,self.low,acceleration = 0, maximum = 0) sarext = talib.SAREXT(self.high,self.low,startvalue=0,offsetonreverse=0,accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0) sma = talib.SMA(self.close,self.period) t3 = talib.T3(self.close, self.period, vfactor = 0) tema = talib.TEMA(self.close,self.period) trima = talib.TRIMA(self.close,period) wma = talib.WMA(self.close, self.period)
def midprice(candles: np.ndarray,
period: int = 14,
sequential: bool = False) -> Union[float, np.ndarray]:
"""
MIDPRICE - Midpoint Price over period
:param candles: np.ndarray
:param period: int - default: 14
:param sequential: bool - default: False
:return: float | np.ndarray
"""
candles = slice_candles(candles, sequential)
res = talib.MIDPRICE(candles[:, 3], candles[:, 4], timeperiod=period)
return res if sequential else res[-1]
def midpice(client, symbol, timeframe="6m", col="close", period=14):
"""This will return a dataframe of midprice over period
for the given symbol across the given timeframe
Args:
client (pyEX.Client); Client
symbol (string); Ticker
timeframe (string); timeframe to use, for pyEX.chart
col (string); column to use to calculate
period (int); time period for kama
Returns:
DataFrame: result
"""
df = client.chartDF(symbol, timeframe)
build = {col: df[col].values}
build["kama-{}".format(col)] = t.MIDPRICE(df[col].values, period)
return pd.DataFrame(build)
def ta_MIDPRICE(MIDPRICE_conf, curr_high_price_seq, curr_low_price_seq):
MIDPRICE_seqs = []
curr_feature_list = []
MIDPRICE_period_num = len(MIDPRICE_conf["period"])
for i in range(MIDPRICE_period_num):
curr_period = MIDPRICE_conf["period"][0]
curr_feature_list.append("MIDPRICE_" + str(curr_period))
curr_MIDPRICE_seq = talib.MIDPRICE(curr_high_price_seq,
curr_low_price_seq,
timeperiod=curr_period)
MIDPRICE_seqs.append(curr_MIDPRICE_seq.copy())
return MIDPRICE_seqs, curr_feature_list
def midprice(candles: np.ndarray,
period: int = 14,
sequential: bool = False) -> Union[float, np.ndarray]:
"""
MIDPRICE - Midpoint Price over period
:param candles: np.ndarray
:param period: int - default=14
:param sequential: bool - default=False
:return: float | np.ndarray
"""
if not sequential and len(candles) > 240:
candles = candles[-240:]
res = talib.MIDPRICE(candles[:, 3], candles[:, 4], timeperiod=period)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
def midprice(candles: np.ndarray,
period: int = 14,
sequential: bool = False) -> Union[float, np.ndarray]:
"""
MIDPRICE - Midpoint Price over period
:param candles: np.ndarray
:param period: int - default=14
:param sequential: bool - default=False
:return: float | np.ndarray
"""
warmup_candles_num = get_config('env.data.warmup_candles_num', 240)
if not sequential and len(candles) > warmup_candles_num:
candles = candles[-warmup_candles_num:]
res = talib.MIDPRICE(candles[:, 3], candles[:, 4], timeperiod=period)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
def getOverlapFunctions(df):
high = df['High']
low = df['Low']
close = df['Close']
open = df['Open']
volume = df['Volume']
df['UPPERBB'],df['MIDDLEBB'],df['LOWERBB'] = ta.BBANDS(close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
df['DEMA'] = ta.DEMA(close,timeperiod=30)
df['EMA'] = ta.EMA(close, timeperiod=30)
df['HT_TREND'] = ta.HT_TRENDLINE(close)
df['KAMA'] = ta.KAMA(close, timeperiod=30)
df['MA'] = ta.MA(close, timeperiod=30, matype=0)
#df['MAMA'],df['FAMA'] = ta.MAMA(close, fastlimit=0, slowlimit=0)
#df['MAVP'] = ta.MAVP(close, periods, minperiod=2, maxperiod=30, matype=0)
df['MIDPOINT'] = ta.MIDPOINT(close, timeperiod=14)
df['MIDPRICE'] = ta.MIDPRICE(high, low, timeperiod=14)
df['SAR'] = ta.SAR(high, low, acceleration=0, maximum=0)
df['SAREXT'] = ta.SAREXT(high, low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)
df['SMA'] = ta.SMA(close, timeperiod=30)
df['T3'] = ta.T3(close, timeperiod=5, vfactor=0)
df['TEMA'] = ta.TEMA(close, timeperiod=30)
df['TRIMA'] = ta.TRIMA(close, timeperiod=30)
df['WMA'] = ta.WMA(close, timeperiod=30)
def get_average_studies(open, low, high, close, df):
# https://mrjbq7.github.io/ta-lib/func_groups/overlap_studies.html
# Bollinger bands
df['UP_BB'], df['MID_BB'], df['LOW_BB'] = talib.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
# HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
df["HT"] = talib.HT_TRENDLINE(close)
# SAR - Parabolic SAR
df["SAR"] = talib.SAR(high, low, acceleration=0, maximum=0)
#
periods = [5, 15, 30, 50, 100, 200]
for period in periods:
df['SMA-' + str(period)] = talib.SMA(close, timeperiod=period)
df['DEMA-' + str(period)] = talib.DEMA(close, timeperiod=period)
df['TEMA-' + str(period)] = talib.TEMA(close, timeperiod=period)
df['WMA-' + str(period)] = talib.WMA(close, timeperiod=period)
df['MIDPOINT-' + str(period)] = talib.MIDPOINT(close,
timeperiod=period)
df['MIDPRICE-' + str(period)] = talib.MIDPRICE(high,
low,
timeperiod=period)
def IndicateurTech(dataframe):
"""
Overlap Studies:
BBANDS Bollinger Bands
DEMA Double Exponential Moving Average
EMA Exponential Moving Average
HT_TRENDLINE Hilbert Transform - Instantaneous Trendline
KAMA Kaufman Adaptive Moving Average
MA Moving average
MAMA MESA Adaptive Moving Average
MAVP Moving average with variable period
MIDPOINT MidPoint over period
MIDPRICE Midpoint Price over period
SAR Parabolic SAR
SAREXT Parabolic SAR - Extended
SMA Simple Moving Average
T3 Triple Exponential Moving Average (T3)
TEMA Triple Exponential Moving Average
TRIMA Triangular Moving Average
WMA Weighted Moving Average
"""
# BBANDS - Bollinger Bands
upperband, middleband, Lowerband = talib.BBANDS(Close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
#DEMA - Double Exponential Moving Average
df[f'{ratio}_DEMA'] = talib.DEMA(Close, timeperiod=30)
#EMA - Exponential Moving Average
#NOTE: The EMA function has an unstable period.
df[f'{ratio}_EMA'] = talib.EMA(Close, timeperiod=30)
#HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
#NOTE: The HT_TRENDLINE function has an unstable period.
df[f'{ratio}_HT_TRENDLINE'] = talib.HT_TRENDLINE(Close)
#KAMA - Kaufman Adaptive Moving Average
#NOTE: The KAMA function has an unstable period.
df[f'{ratio}_KAMA'] = talib.KAMA(Close, timeperiod=30)
#MA - Moving average
df[f'{ratio}_MA'] = talib.MA(Close, timeperiod=30, matype=0)
#MAMA - MESA Adaptive Moving Average
#NOTE: The MAMA function has an unstable period.
#mama, fama = talib.MAMA(Close, fastlimit=0, sLowlimit=0)
#MAVP - Moving average with variable period
#df[f'{ratio}_MAVP'] = talib.MAVP(Close, periods, minperiod=2, maxperiod=30, matype=0)
#MIDPOINT - MidPoint over period
df[f'{ratio}_MIDPOINT'] = talib.MIDPOINT(Close, timeperiod=14)
#MIDPRICE - Midpoint Price over period
df[f'{ratio}_MIDPRICE'] = talib.MIDPRICE(High, Low, timeperiod=14)
#SAR - Parabolic SAR
df[f'{ratio}_SAR'] = talib.SAR(High, Low, acceleration=0, maximum=0)
#SAREXT - Parabolic SAR - Extended
df[f'{ratio}_SAREXT'] = talib.SAREXT(High, Low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)
#SMA - Simple Moving Average
df[f'{ratio}_SMA'] = talib.SMA(Close, timeperiod=30)
#T3 - Triple Exponential Moving Average (T3)
#NOTE: The T3 function has an unstable period.
df[f'{ratio}_T3'] = talib.T3(Close, timeperiod=5, vfactor=0)
#TEMA - Triple Exponential Moving Average
df[f'{ratio}_TEMA'] = talib.TEMA(Close, timeperiod=30)
#TRIMA - Triangular Moving Average
df[f'{ratio}_TRIMA'] = talib.TRIMA(Close, timeperiod=30)
#WMA - Weighted Moving Average
df[f'{ratio}_WMA'] = talib.WMA(Close, timeperiod=30)
def add_ta_features(df, ta_settings):
"""Add technial analysis features from typical financial dataset that
typically include columns such as "open", "high", "low", "price" and
"volume".
http://mrjbq7.github.io/ta-lib/
Args:
df(pandas.DataFrame): original DataFrame.
ta_settings(dict): configuration.
Returns:
pandas.DataFrame: DataFrame with new features included.
"""
open = df['open']
high = df['high']
low = df['low']
close = df['price']
volume = df['volume']
if ta_settings['overlap']:
df['ta_overlap_bbands_upper'], df['ta_overlap_bbands_middle'], df[
'ta_overlap_bbands_lower'] = ta.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
df['ta_overlap_dema'] = ta.DEMA(
close, timeperiod=15) # NOTE: Changed to avoid a lot of Nan values
df['ta_overlap_ema'] = ta.EMA(close, timeperiod=30)
df['ta_overlap_kama'] = ta.KAMA(close, timeperiod=30)
df['ta_overlap_ma'] = ta.MA(close, timeperiod=30, matype=0)
df['ta_overlap_mama_mama'], df['ta_overlap_mama_fama'] = ta.MAMA(close)
period = np.random.randint(10, 20, size=len(close)).astype(float)
df['ta_overlap_mavp'] = ta.MAVP(close,
period,
minperiod=2,
maxperiod=30,
matype=0)
df['ta_overlap_midpoint'] = ta.MIDPOINT(close, timeperiod=14)
df['ta_overlap_midprice'] = ta.MIDPRICE(high, low, timeperiod=14)
df['ta_overlap_sar'] = ta.SAR(high, low, acceleration=0, maximum=0)
df['ta_overlap_sarext'] = ta.SAREXT(high,
low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
df['ta_overlap_sma'] = ta.SMA(close, timeperiod=30)
df['ta_overlap_t3'] = ta.T3(close, timeperiod=5, vfactor=0)
df['ta_overlap_tema'] = ta.TEMA(
close, timeperiod=12) # NOTE: Changed to avoid a lot of Nan values
df['ta_overlap_trima'] = ta.TRIMA(close, timeperiod=30)
df['ta_overlap_wma'] = ta.WMA(close, timeperiod=30)
# NOTE: Commented to avoid a lot of Nan values
# df['ta_overlap_ht_trendline'] = ta.HT_TRENDLINE(close)
if ta_settings['momentum']:
df['ta_momentum_adx'] = ta.ADX(high, low, close, timeperiod=14)
df['ta_momentum_adxr'] = ta.ADXR(high, low, close, timeperiod=14)
df['ta_momentum_apo'] = ta.APO(close,
fastperiod=12,
slowperiod=26,
matype=0)
df['ta_momentum_aroondown'], df['ta_momentum_aroonup'] = ta.AROON(
high, low, timeperiod=14)
df['ta_momentum_aroonosc'] = ta.AROONOSC(high, low, timeperiod=14)
df['ta_momentum_bop'] = ta.BOP(open, high, low, close)
df['ta_momentum_cci'] = ta.CCI(high, low, close, timeperiod=14)
df['ta_momentum_cmo'] = ta.CMO(close, timeperiod=14)
df['ta_momentum_dx'] = ta.DX(high, low, close, timeperiod=14)
df['ta_momentum_macd_macd'], df['ta_momentum_macd_signal'], df[
'ta_momentum_macd_hist'] = ta.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df['ta_momentum_macdext_macd'], df['ta_momentum_macdext_signal'], df[
'ta_momentum_macdext_hist'] = ta.MACDEXT(close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
df['ta_momentum_macdfix_macd'], df['ta_momentum_macdfix_signal'], df[
'ta_momentum_macdfix_hist'] = ta.MACDFIX(close, signalperiod=9)
df['ta_momentum_mfi'] = ta.MFI(high, low, close, volume, timeperiod=14)
df['ta_momentum_minus_di'] = ta.MINUS_DI(high,
low,
close,
timeperiod=14)
df['ta_momentum_minus_dm'] = ta.MINUS_DM(high, low, timeperiod=14)
df['ta_momentum_mom'] = ta.MOM(close, timeperiod=10)
df['ta_momentum_plus_di'] = ta.PLUS_DI(high, low, close, timeperiod=14)
df['ta_momentum_plus_dm'] = ta.PLUS_DM(high, low, timeperiod=14)
df['ta_momentum_ppo'] = ta.PPO(close,
fastperiod=12,
slowperiod=26,
matype=0)
df['ta_momentum_roc'] = ta.ROC(close, timeperiod=10)
df['ta_momentum_rocp'] = ta.ROCP(close, timeperiod=10)
df['ta_momentum_rocr'] = ta.ROCR(close, timeperiod=10)
df['ta_momentum_rocr100'] = ta.ROCR100(close, timeperiod=10)
df['ta_momentum_rsi'] = ta.RSI(close, timeperiod=14)
df['ta_momentum_slowk'], df['ta_momentum_slowd'] = ta.STOCH(
high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df['ta_momentum_fastk'], df['ta_momentum_fastd'] = ta.STOCHF(
high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
df['ta_momentum_fastk'], df['ta_momentum_fastd'] = ta.STOCHRSI(
close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
df['ta_momentum_trix'] = ta.TRIX(
close, timeperiod=12) # NOTE: Changed to avoid a lot of Nan values
df['ta_momentum_ultosc'] = ta.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
df['ta_momentum_willr'] = ta.WILLR(high, low, close, timeperiod=14)
if ta_settings['volume']:
df['ta_volume_ad'] = ta.AD(high, low, close, volume)
df['ta_volume_adosc'] = ta.ADOSC(high,
low,
close,
volume,
fastperiod=3,
slowperiod=10)
df['ta_volume_obv'] = ta.OBV(close, volume)
if ta_settings['volatility']:
df['ta_volatility_atr'] = ta.ATR(high, low, close, timeperiod=14)
df['ta_volatility_natr'] = ta.NATR(high, low, close, timeperiod=14)
df['ta_volatility_trange'] = ta.TRANGE(high, low, close)
if ta_settings['price']:
df['ta_price_avgprice'] = ta.AVGPRICE(open, high, low, close)
df['ta_price_medprice'] = ta.MEDPRICE(high, low)
df['ta_price_typprice'] = ta.TYPPRICE(high, low, close)
df['ta_price_wclprice'] = ta.WCLPRICE(high, low, close)
if ta_settings['cycle']:
df['ta_cycle_ht_dcperiod'] = ta.HT_DCPERIOD(close)
df['ta_cycle_ht_phasor_inphase'], df[
'ta_cycle_ht_phasor_quadrature'] = ta.HT_PHASOR(close)
df['ta_cycle_ht_trendmode'] = ta.HT_TRENDMODE(close)
# NOTE: Commented to avoid a lot of Nan values
# df['ta_cycle_ht_dcphase'] = ta.HT_DCPHASE(close)
# df['ta_cycle_ht_sine_sine'], df['ta_cycle_ht_sine_leadsine'] = ta.HT_SINE(close)
if ta_settings['pattern']:
df['ta_pattern_cdl2crows'] = ta.CDL2CROWS(open, high, low, close)
df['ta_pattern_cdl3blackrows'] = ta.CDL3BLACKCROWS(
open, high, low, close)
df['ta_pattern_cdl3inside'] = ta.CDL3INSIDE(open, high, low, close)
df['ta_pattern_cdl3linestrike'] = ta.CDL3LINESTRIKE(
open, high, low, close)
df['ta_pattern_cdl3outside'] = ta.CDL3OUTSIDE(open, high, low, close)
df['ta_pattern_cdl3starsinsouth'] = ta.CDL3STARSINSOUTH(
open, high, low, close)
df['ta_pattern_cdl3whitesoldiers'] = ta.CDL3WHITESOLDIERS(
open, high, low, close)
df['ta_pattern_cdlabandonedbaby'] = ta.CDLABANDONEDBABY(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdladvanceblock'] = ta.CDLADVANCEBLOCK(
open, high, low, close)
df['ta_pattern_cdlbelthold'] = ta.CDLBELTHOLD(open, high, low, close)
df['ta_pattern_cdlbreakaway'] = ta.CDLBREAKAWAY(open, high, low, close)
df['ta_pattern_cdlclosingmarubozu'] = ta.CDLCLOSINGMARUBOZU(
open, high, low, close)
df['ta_pattern_cdlconcealbabyswall'] = ta.CDLCONCEALBABYSWALL(
open, high, low, close)
df['ta_pattern_cdlcounterattack'] = ta.CDLCOUNTERATTACK(
open, high, low, close)
df['ta_pattern_cdldarkcloudcover'] = ta.CDLDARKCLOUDCOVER(
open, high, low, close, penetration=0)
df['ta_pattern_cdldoji'] = ta.CDLDOJI(open, high, low, close)
df['ta_pattern_cdldojistar'] = ta.CDLDOJISTAR(open, high, low, close)
df['ta_pattern_cdldragonflydoji'] = ta.CDLDRAGONFLYDOJI(
open, high, low, close)
df['ta_pattern_cdlengulfing'] = ta.CDLENGULFING(open, high, low, close)
df['ta_pattern_cdleveningdojistar'] = ta.CDLEVENINGDOJISTAR(
open, high, low, close, penetration=0)
df['ta_pattern_cdleveningstar'] = ta.CDLEVENINGSTAR(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdlgapsidesidewhite'] = ta.CDLGAPSIDESIDEWHITE(
open, high, low, close)
df['ta_pattern_cdlgravestonedoji'] = ta.CDLGRAVESTONEDOJI(
open, high, low, close)
df['ta_pattern_cdlhammer'] = ta.CDLHAMMER(open, high, low, close)
df['ta_pattern_cdlhangingman'] = ta.CDLHANGINGMAN(
open, high, low, close)
df['ta_pattern_cdlharami'] = ta.CDLHARAMI(open, high, low, close)
df['ta_pattern_cdlharamicross'] = ta.CDLHARAMICROSS(
open, high, low, close)
df['ta_pattern_cdlhighwave'] = ta.CDLHIGHWAVE(open, high, low, close)
df['ta_pattern_cdlhikkake'] = ta.CDLHIKKAKE(open, high, low, close)
df['ta_pattern_cdlhikkakemod'] = ta.CDLHIKKAKEMOD(
open, high, low, close)
df['ta_pattern_cdlhomingpigeon'] = ta.CDLHOMINGPIGEON(
open, high, low, close)
df['ta_pattern_cdlidentical3crows'] = ta.CDLIDENTICAL3CROWS(
open, high, low, close)
df['ta_pattern_cdlinneck'] = ta.CDLINNECK(open, high, low, close)
df['ta_pattern_cdlinvertedhammer'] = ta.CDLINVERTEDHAMMER(
open, high, low, close)
df['ta_pattern_cdlkicking'] = ta.CDLKICKING(open, high, low, close)
df['ta_pattern_cdlkickingbylength'] = ta.CDLKICKINGBYLENGTH(
open, high, low, close)
df['ta_pattern_cdlladderbottom'] = ta.CDLLADDERBOTTOM(
open, high, low, close)
df['ta_pattern_cdllongleggeddoji'] = ta.CDLLONGLEGGEDDOJI(
open, high, low, close)
df['ta_pattern_cdllongline'] = ta.CDLLONGLINE(open, high, low, close)
df['ta_pattern_cdlmarubozu'] = ta.CDLMARUBOZU(open, high, low, close)
df['ta_pattern_cdlmatchinglow'] = ta.CDLMATCHINGLOW(
open, high, low, close)
df['ta_pattern_cdlmathold'] = ta.CDLMATHOLD(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdlmorningdojistar'] = ta.CDLMORNINGDOJISTAR(
open, high, low, close, penetration=0)
df['ta_pattern_cdlmorningstar'] = ta.CDLMORNINGSTAR(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdllonneck'] = ta.CDLONNECK(open, high, low, close)
df['ta_pattern_cdlpiercing'] = ta.CDLPIERCING(open, high, low, close)
df['ta_pattern_cdlrickshawman'] = ta.CDLRICKSHAWMAN(
open, high, low, close)
df['ta_pattern_cdlrisefall3methods'] = ta.CDLRISEFALL3METHODS(
open, high, low, close)
df['ta_pattern_cdlseparatinglines'] = ta.CDLSEPARATINGLINES(
open, high, low, close)
df['ta_pattern_cdlshootingstar'] = ta.CDLSHOOTINGSTAR(
open, high, low, close)
df['ta_pattern_cdlshortline'] = ta.CDLSHORTLINE(open, high, low, close)
df['ta_pattern_cdlspinningtop'] = ta.CDLSPINNINGTOP(
open, high, low, close)
df['ta_pattern_cdlstalledpattern'] = ta.CDLSTALLEDPATTERN(
open, high, low, close)
df['ta_pattern_cdlsticksandwich'] = ta.CDLSTICKSANDWICH(
open, high, low, close)
df['ta_pattern_cdltakuri'] = ta.CDLTAKURI(open, high, low, close)
df['ta_pattern_cdltasukigap'] = ta.CDLTASUKIGAP(open, high, low, close)
df['ta_pattern_cdlthrusting'] = ta.CDLTHRUSTING(open, high, low, close)
df['ta_pattern_cdltristar'] = ta.CDLTRISTAR(open, high, low, close)
df['ta_pattern_cdlunique3river'] = ta.CDLUNIQUE3RIVER(
open, high, low, close)
df['ta_pattern_cdlupsidegap2crows'] = ta.CDLUPSIDEGAP2CROWS(
open, high, low, close)
df['ta_pattern_cdlxsidegap3methods'] = ta.CDLXSIDEGAP3METHODS(
open, high, low, close)
if ta_settings['statistic']:
df['ta_statistic_beta'] = ta.BETA(high, low, timeperiod=5)
df['ta_statistic_correl'] = ta.CORREL(high, low, timeperiod=30)
df['ta_statistic_linearreg'] = ta.LINEARREG(close, timeperiod=14)
df['ta_statistic_linearreg_angle'] = ta.LINEARREG_ANGLE(close,
timeperiod=14)
df['ta_statistic_linearreg_intercept'] = ta.LINEARREG_INTERCEPT(
close, timeperiod=14)
df['ta_statistic_linearreg_slope'] = ta.LINEARREG_SLOPE(close,
timeperiod=14)
df['ta_statistic_stddev'] = ta.STDDEV(close, timeperiod=5, nbdev=1)
df['ta_statistic_tsf'] = ta.TSF(close, timeperiod=14)
df['ta_statistic_var'] = ta.VAR(close, timeperiod=5, nbdev=1)
if ta_settings['math_transforms']:
df['ta_math_transforms_atan'] = ta.ATAN(close)
df['ta_math_transforms_ceil'] = ta.CEIL(close)
df['ta_math_transforms_cos'] = ta.COS(close)
df['ta_math_transforms_floor'] = ta.FLOOR(close)
df['ta_math_transforms_ln'] = ta.LN(close)
df['ta_math_transforms_log10'] = ta.LOG10(close)
df['ta_math_transforms_sin'] = ta.SIN(close)
df['ta_math_transforms_sqrt'] = ta.SQRT(close)
df['ta_math_transforms_tan'] = ta.TAN(close)
if ta_settings['math_operators']:
df['ta_math_operators_add'] = ta.ADD(high, low)
df['ta_math_operators_div'] = ta.DIV(high, low)
df['ta_math_operators_min'], df['ta_math_operators_max'] = ta.MINMAX(
close, timeperiod=30)
df['ta_math_operators_minidx'], df[
'ta_math_operators_maxidx'] = ta.MINMAXINDEX(close, timeperiod=30)
df['ta_math_operators_mult'] = ta.MULT(high, low)
df['ta_math_operators_sub'] = ta.SUB(high, low)
df['ta_math_operators_sum'] = ta.SUM(close, timeperiod=30)
return df
def talib_MIDPRICE(DataFrame, N=14):
res = talib.MIDPRICE(DataFrame.high.values,
DataFrame.low.values,
timeperiod=N)
return pd.DataFrame({'MIDPRICE': res}, index=DataFrame.index)
df['upperband'], df['middleband'], df['lowerband'] = ta.BBANDS(np.array(
df['Adj Close'].shift(1)),
timeperiod=n,
nbdevup=2,
nbdevdn=2,
matype=0)
df['DEMA'] = ta.DEMA(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['EMA'] = ta.EMA(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['HT_TRENDLINE'] = ta.HT_TRENDLINE(np.array(df['Adj Close'].shift(1)))
df['KAMA'] = ta.KAMA(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['MA'] = ta.MA(np.array(df['Adj Close'].shift(1)), timeperiod=n, matype=0)
# df['mama'],df['fama'] = ta.MAMA(np.array(df['Adj Close'].shift(1)), fastlimit=0, slowlimit=0)
# df['MAVP'] =ta.MAVP(np.array(df['Adj Close'].shift(1)),periods=14, minperiod=2, maxperiod=30, matype=0)
df['MIDPOINT'] = ta.MIDPOINT(np.array(df['Adj Close'].shift(1)), timeperiod=n)
df['MIDPRICE'] = ta.MIDPRICE(np.array(df['High'].shift(1)),
np.array(df['Low'].shift(1)),
timeperiod=n)
df['SAR'] = ta.SAR(np.array(df['High'].shift(1)),
np.array(df['Low'].shift(1)),
acceleration=0,
maximum=0)
df['SAREXT'] = ta.SAREXT(np.array(df['High'].shift(1)),
np.array(df['Low'].shift(1)),
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
def MIDPRICE(data, **kwargs):
_check_talib_presence()
popen, phigh, plow, pclose, pvolume = _extract_ohlc(data)
return talib.MIDPRICE(phigh, plow, **kwargs)
def MIDPRICE(raw_df, timeperiod=14):
# extract necessary data from raw dataframe (high, low)
return ta.MIDPRICE(raw_df.High.values, raw_df.Low.values, timeperiod)
def data_cleaning(df_temp):
################################# 计算各种指标 ##################################
################# close high low volume is "pandas.core.series.Series" #######################
################# output MACD_5 is"numpy.ndarray" ############################################
df=pd.DataFrame.copy(df_temp)
close = df['close']
volume= np.array(df['volume'],dtype='float64')
high = df['high']
low = df['low']
######################## input is "numpy.ndarray" use .values to convert ###################
############## https://zhuanlan.zhihu.com/p/25407061 中文解析 Talib 指标使用 #################
ma5 = tb.MA(close.values, timeperiod=5, matype=0)
ma10 = tb.MA(close.values, timeperiod=10, matype=0)
ma20 = tb.MA(close.values, timeperiod=20, matype=0)
v_ma5 = tb.MA(volume, timeperiod=5, matype=0)
v_ma10 = tb.MA(volume, timeperiod=10, matype=0)
v_ma20 = tb.MA(volume, timeperiod=20, matype=0)
price_change = get_price_change(close)
p_change = get_p_change(close)
MACD_5, MACD_Singal, hist = tb.MACD(close.values,fastperiod=12,slowperiod=26,signalperiod=9)
EMA_12 = tb.EMA(close.values,timeperiod=12)
EMA_5 = tb.EMA(close.values,timeperiod=5)
EMA_20 = tb.EMA(close.values,timeperiod=20)
RSI_6 = tb.RSI(close.values,timeperiod=6)
RSI_12 = tb.RSI(close.values,timeperiod=12)
SMA = tb.SMA(close.values,timeperiod=5)
upper, middle, lower =tb.BBANDS(close.values,timeperiod=5,nbdevup=2,nbdevdn=2,matype=0)
#matype:
# 0 SMA – Simple Moving Average
# 1 EMA – Exponential Average
# 2 WMA – Weighted Moving Average
# 3 DEMA – Double Exponential Moving Average
# 4 TEMA – Triple Exponential Moving Average
# 5 TRIMA – Triangular Moving Average
# 6 KAMA – Kaufman Adaptive Moving Average
# 7 MAMA – MESA Adaptive Moving Average
# 8 T3 – Triple Exponential Moving Average
KAMA = tb.KAMA(close.values,timeperiod=5)
OBV = tb.OBV(close.values, volume)
CCI = tb.CCI(high.values, low.values, close.values, timeperiod=5)
DEMA = tb.DEMA(close.values,timeperiod=5)
HT_TRENDLINE = tb.HT_TRENDLINE(close.values)
MIDPOINT = tb.MIDPOINT(close.values,timeperiod=5)
MIDPRICE = tb.MIDPRICE(high.values, low.values, timeperiod=5)
CMO = tb.CMO(close.values, timeperiod=5)
ADX =tb.ADX(high.values, low.values, close.values, timeperiod=5)
ADXR = tb.ADXR(high.values, low.values, close.values, timeperiod=5)
AROON_D, AROON_U = tb.AROON(high.values, low.values, timeperiod=5)
ROC = tb.ROC(close.values, timeperiod=5)
CMO = tb.CMO(close.values, timeperiod= 5)
PPO = tb.PPO(close.values, fastperiod=3, slowperiod=5, matype=0)
features=['ma5','ma10','ma20','v_ma5','v_ma10','v_ma20','price_change','p_change','EMA_5','EMA_12','EMA_20','MACD_5','MACD_Singal',
'hist','RSI_6','RSI_12','SMA',
'upper','middle','lower','KAMA','OBV','CCI','DEMA','HT_TRENDLINE','MIDPOINT','MIDPRICE',
'CMO','ADX','ADXR','AROON_D','AROON_U','ROC','CMO','PPO']
######################计算各种指标#############################
###### 将以上获得的features通过时间平移，将前五天的历史数据作为今天的features 建立一个235维的数据集。#####
for f in features:
df[f]=locals()[f]
indicators = list(df.columns.values)
for i in range(1,6):
for indicator in indicators:
name= "{0}".format(i) +'_'+indicator
df[name] = df[indicator].shift(i)
df.dropna(inplace=True) #只要有NaN的行，全部删出以免出错
print('Cleaning Completed')
return df
upperband, middleband, lowerband = talib.BBANDS(vm, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
print(upperband,middleband,lowerband)
print("-----jigsaw-----")
print(list(talib.WMA(vm, timeperiod=30)))
print(list(talib.TRIMA(vm, timeperiod=30)))
print(list(talib.TEMA(vm, timeperiod=30)))
print(list(talib.T3(vm, timeperiod=5, vfactor=0)))
print(list(talib.SMA(vm, timeperiod=30)))
print(list(talib.MIDPOINT(vm, timeperiod=14)))
# print(list(talib.MAMA(vm, fastlimit=0, slowlimit=0)))
print(list(talib.MA(vm, timeperiod=30, matype=0)))
print(list(talib.KAMA(vm, timeperiod=30)))
print(list(talib.HT_TRENDLINE(vm)))
# you have the trend here?
print(list(talib.EMA(vm, timeperiod=30)))
print(list(talib.DEMA(vm, timeperiod=30)))
# reading is like a survey, so as the stock market.
if len(k)>3:
# we have got some variable periods here, how do we see this?
# only if we can conclude.
high0=derivative(k)
high=wrap(high0[:-1])
low=wrap(derivative(high0))
print(list(talib.SAREXT(high,low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)))
print(list(talib.SAR(high, low, acceleration=0, maximum=0)))
print(list(talib.MIDPRICE(high, low, timeperiod=14)))
# put it all over here.
# i use finance functions to shoot your head off!
else:
pass
def create_tas(bars,
verbose=False,
ohlcv_cols=['Adj_High', 'Adj_Low', 'Adj_Open', 'Adj_Close', 'Adj_Volume'],
return_df=False,
cl=True,
tp=True):
"""
This is basically set up for daily stock data. Other time frames would need adapting probably.
:param bars: resampled pandas dataframe with open, high, low, close, volume, and typical_price columns
:param verbose: boolean, if true, prints more debug
:param ohlcv_cols: list of strings; the column names for high, low, open, close, and volume
:param cl: use the close price to make TAs
:param tp: calcuclate typical price and use it for TAs
:returns: pandas dataframe with TA signals calculated (modifies dataframe in place)
"""
h, l, o, c, v = ohlcv_cols
if 'typical_price' not in bars.columns and tp:
bars['typical_price'] = bars[[h, l, c]].mean(axis=1)
# bollinger bands
# strange bug, if values are small, need to multiply to larger value for some reason
mult = 1
last_close = bars.iloc[0][c]
lc_m = last_close * mult
while lc_m < 1:
mult *= 10
lc_m = last_close * mult
if verbose:
print('using multiplier of', mult)
if tp:
mult_tp = bars['typical_price'].values * mult
mult_close = bars[c].values * mult
mult_open = bars[o].values * mult
mult_high = bars[h].values * mult
mult_low = bars[l].values * mult
# for IB data, the volume is integer, but needs to be float for talib
volume = bars[v].astype('float').values
# ADR - average daily range
# http://forextraininggroup.com/using-adr-average-daily-range-find-short-term-trading-opportunities/
# TODO
### overlap studies
# bollinger bands -- should probably put these into another indicator
if cl:
upper_cl, middle_cl, lower_cl = talib.BBANDS(mult_close,
timeperiod=10,
nbdevup=2,
nbdevdn=2)
bars['bband_u_cl'] = upper_cl / mult
bars['bband_m_cl'] = middle_cl / mult
bars['bband_l_cl'] = lower_cl / mult
bars['bband_u_cl_diff'] = bars['bband_u_cl'] - bars[c]
bars['bband_m_cl_diff'] = bars['bband_m_cl'] - bars[c]
bars['bband_l_cl_diff'] = bars['bband_l_cl'] - bars[c]
bars['bband_u_cl_diff_hi'] = bars['bband_u_cl'] - bars[h]
bars['bband_l_cl_diff_lo'] = bars['bband_l_cl'] - bars[l]
# bars['bband_u_cl'].fillna(method='bfill', inplace=True)
# bars['bband_m_cl'].fillna(method='bfill', inplace=True)
# bars['bband_l_cl'].fillna(method='bfill', inplace=True)
if tp:
upper_tp, middle_tp, lower_tp = talib.BBANDS(mult_tp,
timeperiod=10,
nbdevup=2,
nbdevdn=2)
bars['bband_u_tp'] = upper_tp / mult
bars['bband_m_tp'] = middle_tp / mult
bars['bband_l_tp'] = lower_tp / mult
bars['bband_u_tp_diff'] = bars['bband_u_tp'] - bars['typical_price']
bars['bband_m_tp_diff'] = bars['bband_m_tp'] - bars['typical_price']
bars['bband_l_tp_diff'] = bars['bband_l_tp'] - bars['typical_price']
bars['bband_u_tp_diff_hi'] = bars['bband_u_tp'] - bars[h]
bars['bband_l_tp_diff_lo'] = bars['bband_l_tp'] - bars[l]
# think this is already taken care of at the end...check
# bars['bband_u_tp'].fillna(method='bfill', inplace=True)
# bars['bband_m_tp'].fillna(method='bfill', inplace=True)
# bars['bband_l_tp'].fillna(method='bfill', inplace=True)
# Double Exponential Moving Average
if cl:
bars['dema_cl'] = talib.DEMA(mult_close, timeperiod=30) / mult
bars['dema_cl_diff'] = bars['dema_cl'] - bars[c]
if tp:
bars['dema_tp'] = talib.DEMA(mult_tp, timeperiod=30) / mult
bars['dema_tp_diff'] = bars['dema_tp'] - bars['typical_price']
# exponential moving Average
if cl:
bars['ema_cl'] = talib.EMA(mult_close, timeperiod=30) / mult
bars['ema_cl_diff'] = bars['ema_cl'] - bars[c]
if tp:
bars['ema_tp'] = talib.EMA(mult_tp, timeperiod=30) / mult
bars['ema_tp_diff'] = bars['ema_tp'] - bars['typical_price']
# Hilbert Transform - Instantaneous Trendline - like a mva but a bit different, should probably take slope or
# use in another indicator
if cl:
bars['ht_tl_cl'] = talib.HT_TRENDLINE(mult_close) / mult
bars['ht_tl_cl_diff'] = bars['ht_tl_cl'] - bars[c]
if tp:
bars['ht_tl_tp'] = talib.HT_TRENDLINE(mult_tp) / mult
bars['ht_tl_tp_diff'] = bars['ht_tl_tp'] - bars['typical_price']
# KAMA - Kaufman's Adaptative Moving Average -- need to take slope or something
if cl:
bars['kama_cl'] = talib.KAMA(mult_close, timeperiod=30) / mult
bars['kama_cl_diff'] = bars['kama_cl'] - bars[c]
if tp:
bars['kama_tp'] = talib.KAMA(mult_tp, timeperiod=30) / mult
bars['kama_tp_diff'] = bars['kama_tp'] - bars['typical_price']
# MESA Adaptive Moving Average -- getting TA_BAD_PARAM error
# mama_cl, fama_cl = talib.MAMA(mult_close, fastlimit=100, slowlimit=100) / mult
# mama_tp, fama_tp = talib.MAMA(mult_tp, fastlimit=100, slowlimit=100) / mult
# mama_cl_osc = (mama_cl - fama_cl) / mama_cl
# mama_tp_osc = (mama_tp - fama_tp) / mama_tp
# bars['mama_cl'] = mama_cl
# bars['mama_tp'] = mama_tp
# bars['fama_cl'] = fama_cl
# bars['fama_tp'] = fama_tp
# bars['mama_cl_osc'] = mama_cl_osc
# bars['mama_tp_osc'] = mama_tp_osc
# Moving average with variable period
if cl:
bars['mavp_cl'] = talib.MAVP(mult_close, np.arange(mult_close.shape[0]).astype(np.float64), minperiod=2, maxperiod=30, matype=0) / mult
bars['mavp_cl_diff'] = bars['mavp_cl'] - bars[c]
if tp:
bars['mavp_tp'] = talib.MAVP(mult_tp, np.arange(mult_tp.shape[0]).astype(np.float64), minperiod=2, maxperiod=30, matype=0) / mult
bars['mavp_tp_diff'] = bars['mavp_tp'] - bars['typical_price']
# midpoint over period
if cl:
bars['midp_cl'] = talib.MIDPOINT(mult_close, timeperiod=14) / mult
bars['midp_cl_diff'] = bars['midp_cl'] - bars[c]
if tp:
bars['midp_tp'] = talib.MIDPOINT(mult_tp, timeperiod=14) / mult
bars['midp_tp_diff'] = bars['midp_tp'] - bars['typical_price']
# midpoint price over period
bars['midpr'] = talib.MIDPRICE(mult_high, mult_low, timeperiod=14) / mult
if cl:
bars['midpr_diff_cl'] = bars['midpr'] - bars[c]
if tp:
bars['midpr_diff_tp'] = bars['midpr'] - bars['typical_price']
# parabolic sar
bars['sar'] = talib.SAR(mult_high, mult_low, acceleration=0.02, maximum=0.2) / mult
if cl:
bars['sar_diff_cl'] = bars['sar'] - bars[c]
if tp:
bars['sar_diff_tp'] = bars['sar'] - bars['typical_price']
# need to make an oscillator for this
# simple moving average
# 10, 20, 30, 40 day
if cl:
bars['sma_10_cl'] = talib.SMA(mult_close, timeperiod=10) / mult
bars['sma_20_cl'] = talib.SMA(mult_close, timeperiod=20) / mult
bars['sma_30_cl'] = talib.SMA(mult_close, timeperiod=30) / mult
bars['sma_40_cl'] = talib.SMA(mult_close, timeperiod=40) / mult
if tp:
bars['sma_10_tp'] = talib.SMA(mult_tp, timeperiod=10) / mult
bars['sma_20_tp'] = talib.SMA(mult_tp, timeperiod=20) / mult
bars['sma_30_tp'] = talib.SMA(mult_tp, timeperiod=30) / mult
bars['sma_40_tp'] = talib.SMA(mult_tp, timeperiod=40) / mult
# triple exponential moving average
if cl:
bars['tema_cl'] = talib.TEMA(mult_close, timeperiod=30) / mult
bars['tema_cl_diff'] = bars['tema_cl'] - bars[c]
if tp:
bars['tema_tp'] = talib.TEMA(mult_tp, timeperiod=30) / mult
bars['tema_tp_diff'] = bars['tema_tp'] - bars['typical_price']
# triangular ma
if cl:
bars['trima_cl'] = talib.TRIMA(mult_close, timeperiod=30) / mult
bars['trima_cl_diff'] = bars['trima_cl'] - bars[c]
if tp:
bars['trima_tp'] = talib.TRIMA(mult_tp, timeperiod=30) / mult
bars['trima_tp_diff'] = bars['trima_tp'] - bars['typical_price']
# weighted moving average
if cl:
bars['wma_cl'] = talib.WMA(mult_close, timeperiod=30) / mult
bars['wma_cl_diff'] = bars['wma_cl'] - bars[c]
if tp:
bars['wma_tp'] = talib.WMA(mult_tp, timeperiod=30) / mult
bars['wma_tp_diff'] = bars['wma_tp'] - bars['typical_price']
#### momentum indicators -- for now left out some of those with unstable periods (maybe update and included them, not sure)
# Average Directional Movement Index - 0 to 100 I think
bars['adx_14'] = talib.ADX(mult_high, mult_low, mult_close, timeperiod=14)
bars['adx_5'] = talib.ADX(mult_high, mult_low, mult_close, timeperiod=5)
# Average Directional Movement Index Rating
bars['adxr'] = talib.ADXR(mult_high, mult_low, mult_close, timeperiod=14)
# Absolute Price Oscillator
# values around -100 to +100
if cl:
bars['apo_cl'] = talib.APO(mult_close, fastperiod=12, slowperiod=26, matype=0)
if tp:
bars['apo_tp'] = talib.APO(mult_tp, fastperiod=12, slowperiod=26, matype=0)
# Aroon and Aroon Oscillator 0-100, so don't need to renormalize
arup, ardn = talib.AROON(mult_high, mult_low, timeperiod=14)
bars['arup'] = arup
bars['ardn'] = ardn
# linearly related to aroon, just aroon up - aroon down
bars['aroonosc'] = talib.AROONOSC(mult_high, mult_low, timeperiod=14)
# balance of power - ratio of values so don't need to re-normalize
bars['bop'] = talib.BOP(mult_open, mult_high, mult_low, mult_close)
# Commodity Channel Index
# around -100 to + 100
bars['cci'] = talib.CCI(mult_high, mult_low, mult_close, timeperiod=14)
# Chande Momentum Oscillator
if cl:
bars['cmo_cl'] = talib.CMO(mult_close, timeperiod=14)
if tp:
bars['cmo_tp'] = talib.CMO(mult_tp, timeperiod=14)
# dx - Directional Movement Index
bars['dx'] = talib.DX(mult_high, mult_low, mult_close, timeperiod=14)
# Moving Average Convergence/Divergence
# https://www.quantopian.com/posts/how-does-the-talib-compute-macd-why-the-value-is-different
# macd diff btw fast and slow EMA
if cl:
macd_cl, macdsignal_cl, macdhist_cl = talib.MACD(mult_close, fastperiod=12, slowperiod=26, signalperiod=9)
bars['macd_cl'] = macd_cl / mult
bars['macdsignal_cl'] = macdsignal_cl / mult
bars['macdhist_cl'] = macdhist_cl / mult
if tp:
macd_tp, macdsignal_tp, macdhist_tp = talib.MACD(mult_tp, fastperiod=12, slowperiod=26, signalperiod=9)
bars['macd_tp'] = macd_tp / mult
bars['macdsignal_tp'] = macdsignal_tp / mult
bars['macdhist_tp'] = macdhist_tp / mult
# mfi - Money Flow Index
bars['mfi'] = talib.MFI(mult_high, mult_low, mult_close, volume, timeperiod=14)
# minus di - Minus Directional Indicator
bars['mdi'] = talib.MINUS_DI(mult_high, mult_low, mult_close, timeperiod=14)
# Minus Directional Movement
bars['mdm'] = talib.MINUS_DM(mult_high, mult_low, timeperiod=14)
# note: too small of a timeperiod will result in junk data...I think. or at least very discretized
if cl:
bars['mom_cl'] = talib.MOM(mult_close, timeperiod=14) / mult
# bars['mom_cl'].fillna(method='bfill', inplace=True)
if tp:
bars['mom_tp'] = talib.MOM(mult_tp, timeperiod=14) / mult
# bars['mom_tp'].fillna(method='bfill', inplace=True)
# plus di - Plus Directional Indicator
bars['pldi'] = talib.PLUS_DI(mult_high, mult_low, mult_close, timeperiod=14)
# Plus Directional Movement
bars['pldm'] = talib.PLUS_DM(mult_high, mult_low, timeperiod=14)
# percentage price Oscillator
# matype explanation: https://www.quantopian.com/posts/moving-averages
if cl:
bars['ppo_cl'] = talib.PPO(mult_close, fastperiod=12, slowperiod=26, matype=1)
if bars['ppo_cl'].isnull().all():
bars['ppo_cl_signal'] = 0
else:
bars['ppo_cl_signal'] = talib.EMA(bars['ppo_cl'].bfill().values, timeperiod=9)
if tp:
bars['ppo_tp'] = talib.PPO(mult_tp, fastperiod=12, slowperiod=26, matype=1)
# rate of change -- really only need one
# if cl:
# bars['roc_cl'] = talib.ROC(mult_close, timeperiod=10)
#
# if tp:
# bars['roc_tp'] = talib.ROC(mult_tp, timeperiod=10)
# rocp - Rate of change Percentage: (price-prevPrice)/prevPrice
if cl:
bars['rocp_cl'] = talib.ROCP(mult_close, timeperiod=10)
if tp:
bars['rocp_tp'] = talib.ROCP(mult_tp, timeperiod=10)
# rocr - Rate of change ratio: (price/prevPrice)
# bars['rocr_cl'] = talib.ROCR(mult_close, timeperiod=10)
# bars['rocr_tp'] = talib.ROCR(mult_tp, timeperiod=10)
#
# # Rate of change ratio 100 scale: (price/prevPrice)*100
# bars['rocr_cl_100'] = talib.ROCR100(mult_close, timeperiod=10)
# bars['rocr_tp_100'] = talib.ROCR100(mult_tp, timeperiod=10)
# Relative Strength Index
if cl:
bars['rsi_cl_14'] = talib.RSI(mult_close, timeperiod=14)
bars['rsi_cl_5'] = talib.RSI(mult_close, timeperiod=5)
if tp:
bars['rsi_tp'] = talib.RSI(mult_tp, timeperiod=14)
# stochastic oscillator - % of price diffs, so no need to rescale
slowk, slowd = talib.STOCH(mult_high, mult_low, mult_close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
fastk, fastd = talib.STOCHF(mult_high, mult_low, mult_close, fastk_period=5, fastd_period=3, fastd_matype=0)
bars['slowk'] = slowk
bars['slowd'] = slowd
bars['fastk'] = fastk
bars['fastd'] = fastd
# Stochastic Relative Strength Index
if cl:
fastk_cl, fastd_cl = talib.STOCHRSI(mult_close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
bars['strsi_cl_k'] = fastk_cl
bars['strsi_cl_d'] = fastd_cl
if tp:
fastk_tp, fastd_tp = talib.STOCHRSI(mult_tp, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
bars['strsi_tp_k'] = fastk_tp
bars['strsi_tp_d'] = fastd_tp
# trix - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
if cl:
if bars.shape[0] > 90:
bars['trix_cl_30'] = talib.TRIX(mult_close, timeperiod=30)
bars['trix_cl_30_signal'] = talib.EMA(bars['trix_cl_30'].bfill().values, timeperiod=20)
bars['trix_cl_14'] = talib.TRIX(mult_close, timeperiod=14)
if bars['trix_cl_14'].isnull().all():
bars['trix_cl_14_signal'] = 0
else:
bars['trix_cl_14_signal'] = talib.EMA(bars['trix_cl_14'].bfill().values, timeperiod=9)
bars['trix_cl_12'] = talib.TRIX(mult_close, timeperiod=12)
if bars['trix_cl_12'].isnull().all():
bars['trix_cl_12_signal'] = 0
else:
bars['trix_cl_12_signal'] = talib.EMA(bars['trix_cl_12'].bfill().values, timeperiod=9)
bars['trix_cl_5'] = talib.TRIX(mult_close, timeperiod=5)
if bars['trix_cl_5'].isnull().all():
bars['trix_cl_5_signal'] = 0
else:
bars['trix_cl_5_signal'] = talib.EMA(bars['trix_cl_5'].bfill().values, timeperiod=3)
if tp:
bars['trix_tp'] = talib.TRIX(mult_tp, timeperiod=30)
# ultimate Oscillator - between 0 and 100
bars['ultosc'] = talib.ULTOSC(mult_high, mult_low, mult_close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
# williams % r -- 0 to 100
bars['willr'] = talib.WILLR(mult_high, mult_low, mult_close, timeperiod=14)
### volume indicators
# Chaikin A/D Line
bars['ad'] = talib.AD(mult_high, mult_low, mult_close, volume)
# Chaikin A/D Oscillator
bars['adosc'] = talib.ADOSC(mult_high, mult_low, mult_close, volume, fastperiod=3, slowperiod=10)
# on balance volume
if cl:
bars['obv_cl'] = talib.OBV(mult_close, volume)
if bars['obv_cl'].isnull().all():
bars['obv_cl_ema_14'] = 0
else:
bars['obv_cl_ema_14'] = talib.EMA(bars['obv_cl'].values, timeperiod=14)
if tp:
bars['obv_tp'] = talib.OBV(mult_tp, volume)
### volatility indicators
# average true range
# Large or increasing ranges suggest traders prepared to continue to bid up or sell down a stock through the course of the day. Decreasing range suggests waning interest.
# https://en.wikipedia.org/wiki/Average_true_range
bars['atr_65'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=65)
bars['atr_20'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=20)
bars['atr_14'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=14)
bars['atr_5'] = talib.ATR(mult_high, mult_low, mult_close, timeperiod=5)
# Normalized Average True Range
bars['natr_14'] = talib.NATR(mult_high, mult_low, mult_close, timeperiod=14)
bars['natr_5'] = talib.NATR(mult_high, mult_low, mult_close, timeperiod=5)
# true range
bars['trange'] = talib.TRANGE(mult_high, mult_low, mult_close) / mult
### Cycle indicators
# Hilbert Transform - Dominant Cycle Period
if cl:
bars['ht_dcp_cl'] = talib.HT_DCPERIOD(mult_close)
if tp:
bars['ht_dcp_tp'] = talib.HT_DCPERIOD(mult_tp)
# Hilbert Transform - Dominant Cycle Phase
if cl:
bars['ht_dcph_cl'] = talib.HT_DCPHASE(mult_close)
if tp:
bars['ht_dcph_tp'] = talib.HT_DCPHASE(mult_tp)
# Hilbert Transform - Phasor Components
if cl:
inphase_cl, quadrature_cl = talib.HT_PHASOR(mult_close)
bars['ht_ph_cl'] = inphase_cl
bars['ht_q_cl'] = quadrature_cl
if tp:
inphase_tp, quadrature_tp = talib.HT_PHASOR(mult_tp)
bars['ht_ph_tp'] = inphase_tp
bars['ht_q_tp'] = quadrature_tp
# Hilbert Transform - SineWave
if cl:
sine_cl, leadsine_cl = talib.HT_SINE(mult_close)
bars['ht_s_cl'] = sine_cl
bars['ht_ls_cl'] = leadsine_cl
if tp:
sine_tp, leadsine_tp = talib.HT_SINE(mult_tp)
bars['ht_s_tp'] = sine_tp
bars['ht_ls_tp'] = leadsine_tp
# Hilbert Transform - Trend vs Cycle Mode
if cl:
bars['ht_tr_cl'] = talib.HT_TRENDMODE(mult_close)
if tp:
bars['ht_tr_tp'] = talib.HT_TRENDMODE(mult_tp)
bars.fillna(method='bfill', inplace=True)
if return_df:
return bars
def handle_overlap_studies(args, kax, klines_df, close_times, display_count):
all_name = ""
if args.ABANDS: # ATR BANDS
name = 'ABANDS'
real = talib.ATR(klines_df["high"],
klines_df["low"],
klines_df["close"],
timeperiod=14)
emas = talib.EMA(klines_df["close"], timeperiod=26)
kax.plot(close_times, emas[-display_count:], "b--", label=name)
#cs = ['y', 'c', 'm', 'k']
for idx, n in enumerate(args.ABANDS):
"""
if idx >= len(cs):
break
c = cs[idx]
"""
c = 'y'
cl = c + '--'
n = int(n)
kax.plot(close_times, (emas + n * real)[-display_count:],
cl,
label=name + ' upperband')
kax.plot(close_times, (emas - n * real)[-display_count:],
cl,
label=name + ' lowerband')
if args.BANDS: # BANDS
name = 'BANDS'
emas = talib.EMA(klines_df["close"], timeperiod=26)
kax.plot(close_times, emas[-display_count:], "b--", label=name)
r = args.BANDS
kax.plot(close_times, (1 + r) * emas[-display_count:],
'y--',
label=name + ' upperband')
kax.plot(close_times, (1 - r) * emas[-display_count:],
'y--',
label=name + ' lowerband')
# talib
os_key = 'BBANDS'
if args.BBANDS:
upperband, middleband, lowerband = talib.BBANDS(klines_df["close"],
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
kax.plot(close_times,
upperband[-display_count:],
"y",
label=os_key + ' upperband')
kax.plot(close_times,
middleband[-display_count:],
"b",
label=os_key + ' middleband')
kax.plot(close_times,
lowerband[-display_count:],
"y",
label=os_key + ' lowerband')
os_key = 'DEMA'
if args.DEMA:
real = talib.DEMA(klines_df["close"], timeperiod=args.DEMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
if args.EMA:
name = 'EMA'
all_name += " %s%s" % (name, args.EMA)
for idx, e_p in enumerate(args.EMA):
if idx >= len(plot_colors):
break
e_p = int(e_p)
emas = talib.EMA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
emas[-display_count:],
plot_colors[idx] + '--',
label="%sEMA" % (e_p))
os_key = 'HT_TRENDLINE'
if args.HT_TRENDLINE:
real = talib.HT_TRENDLINE(klines_df["close"])
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'KAMA'
if args.KAMA:
real = talib.KAMA(klines_df["close"], timeperiod=args.KAMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
if args.MA:
name = 'MA'
all_name += " %s%s" % (name, args.MA)
for idx, e_p in enumerate(args.MA):
if idx >= len(plot_colors):
break
e_p = int(e_p)
emas = talib.MA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
emas[-display_count:],
plot_colors[idx],
label="%sMA" % (e_p))
os_key = 'MAMA'
if args.MAMA:
mama, fama = talib.MAMA(klines_df["close"], fastlimit=0, slowlimit=0)
kax.plot(close_times, mama[-display_count:], "b", label=os_key)
kax.plot(close_times, fama[-display_count:], "c", label=os_key)
os_key = 'MIDPOINT'
if args.MIDPOINT:
real = talib.MIDPOINT(klines_df["close"], timeperiod=args.MIDPOINT)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'MIDPRICE'
if args.MIDPRICE:
real = talib.MIDPRICE(klines_df["high"],
klines_df["low"],
timeperiod=args.MIDPRICE)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'SAR'
if args.SAR:
real = talib.SAR(klines_df["high"],
klines_df["low"],
acceleration=0,
maximum=0)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'SAREXT'
if args.SAREXT:
real = talib.SAREXT(klines_df["high"],
klines_df["low"],
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'SMA'
if args.SMA:
real = talib.SMA(klines_df["close"], timeperiod=args.SMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'T3'
if args.T3:
real = talib.T3(klines_df["close"], timeperiod=args.T3, vfactor=0)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'TEMA'
if args.TEMA:
real = talib.TEMA(klines_df["close"], timeperiod=args.TEMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'TRIMA'
if args.TRIMA:
real = talib.TRIMA(klines_df["close"], timeperiod=args.TRIMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
os_key = 'WMA'
if args.WMA:
real = talib.WMA(klines_df["close"], timeperiod=args.WMA)
kax.plot(close_times, real[-display_count:], "y", label=os_key)
return all_name
def calculate(self, para):
self.t = self.inputdata[:, 0]
self.op = self.inputdata[:, 1]
self.high = self.inputdata[:, 2]
self.low = self.inputdata[:, 3]
self.close = self.inputdata[:, 4]
#adjusted close
self.close1 = self.inputdata[:, 5]
self.volume = self.inputdata[:, 6]
#Overlap study
#Overlap Studies
#Overlap Studies
if para is 'BBANDS': #Bollinger Bands
upperband, middleband, lowerband = ta.BBANDS(self.close,
timeperiod=self.tp,
nbdevup=2,
nbdevdn=2,
matype=0)
self.output = [upperband, middleband, lowerband]
elif para is 'DEMA': #Double Exponential Moving Average
self.output = ta.DEMA(self.close, timeperiod=self.tp)
elif para is 'EMA': #Exponential Moving Average
self.output = ta.EMA(self.close, timeperiod=self.tp)
elif para is 'HT_TRENDLINE': #Hilbert Transform - Instantaneous Trendline
self.output = ta.HT_TRENDLINE(self.close)
elif para is 'KAMA': #Kaufman Adaptive Moving Average
self.output = ta.KAMA(self.close, timeperiod=self.tp)
elif para is 'MA': #Moving average
self.output = ta.MA(self.close, timeperiod=self.tp, matype=0)
elif para is 'MAMA': #MESA Adaptive Moving Average
mama, fama = ta.MAMA(self.close, fastlimit=0, slowlimit=0)
elif para is 'MAVP': #Moving average with variable period
self.output = ta.MAVP(self.close,
periods=10,
minperiod=self.tp,
maxperiod=self.tp1,
matype=0)
elif para is 'MIDPOINT': #MidPoint over period
self.output = ta.MIDPOINT(self.close, timeperiod=self.tp)
elif para is 'MIDPRICE': #Midpoint Price over period
self.output = ta.MIDPRICE(self.high, self.low, timeperiod=self.tp)
elif para is 'SAR': #Parabolic SAR
self.output = ta.SAR(self.high,
self.low,
acceleration=0,
maximum=0)
elif para is 'SAREXT': #Parabolic SAR - Extended
self.output = ta.SAREXT(self.high,
self.low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
elif para is 'SMA': #Simple Moving Average
self.output = ta.SMA(self.close, timeperiod=self.tp)
elif para is 'T3': #Triple Exponential Moving Average (T3)
self.output = ta.T3(self.close, timeperiod=self.tp, vfactor=0)
elif para is 'TEMA': #Triple Exponential Moving Average
self.output = ta.TEMA(self.close, timeperiod=self.tp)
elif para is 'TRIMA': #Triangular Moving Average
self.output = ta.TRIMA(self.close, timeperiod=self.tp)
elif para is 'WMA': #Weighted Moving Average
self.output = ta.WMA(self.close, timeperiod=self.tp)
#Momentum Indicators
elif para is 'ADX': #Average Directional Movement Index
self.output = ta.ADX(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'ADXR': #Average Directional Movement Index Rating
self.output = ta.ADXR(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'APO': #Absolute Price Oscillator
self.output = ta.APO(self.close,
fastperiod=12,
slowperiod=26,
matype=0)
elif para is 'AROON': #Aroon
aroondown, aroonup = ta.AROON(self.high,
self.low,
timeperiod=self.tp)
self.output = [aroondown, aroonup]
elif para is 'AROONOSC': #Aroon Oscillator
self.output = ta.AROONOSC(self.high, self.low, timeperiod=self.tp)
elif para is 'BOP': #Balance Of Power
self.output = ta.BOP(self.op, self.high, self.low, self.close)
elif para is 'CCI': #Commodity Channel Index
self.output = ta.CCI(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'CMO': #Chande Momentum Oscillator
self.output = ta.CMO(self.close, timeperiod=self.tp)
elif para is 'DX': #Directional Movement Index
self.output = ta.DX(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'MACD': #Moving Average Convergence/Divergence
macd, macdsignal, macdhist = ta.MACD(self.close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
self.output = [macd, macdsignal, macdhist]
elif para is 'MACDEXT': #MACD with controllable MA type
macd, macdsignal, macdhist = ta.MACDEXT(self.close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
self.output = [macd, macdsignal, macdhist]
elif para is 'MACDFIX': #Moving Average Convergence/Divergence Fix 12/26
macd, macdsignal, macdhist = ta.MACDFIX(self.close, signalperiod=9)
self.output = [macd, macdsignal, macdhist]
elif para is 'MFI': #Money Flow Index
self.output = ta.MFI(self.high,
self.low,
self.close,
self.volume,
timeperiod=self.tp)
elif para is 'MINUS_DI': #Minus Directional Indicator
self.output = ta.MINUS_DI(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'MINUS_DM': #Minus Directional Movement
self.output = ta.MINUS_DM(self.high, self.low, timeperiod=self.tp)
elif para is 'MOM': #Momentum
self.output = ta.MOM(self.close, timeperiod=10)
elif para is 'PLUS_DI': #Plus Directional Indicator
self.output = ta.PLUS_DI(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'PLUS_DM': #Plus Directional Movement
self.output = ta.PLUS_DM(self.high, self.low, timeperiod=self.tp)
elif para is 'PPO': #Percentage Price Oscillator
self.output = ta.PPO(self.close,
fastperiod=12,
slowperiod=26,
matype=0)
elif para is 'ROC': #Rate of change : ((price/prevPrice)-1)*100
self.output = ta.ROC(self.close, timeperiod=10)
elif para is 'ROCP': #Rate of change Percentage: (price-prevPrice)/prevPrice
self.output = ta.ROCP(self.close, timeperiod=10)
elif para is 'ROCR': #Rate of change ratio: (price/prevPrice)
self.output = ta.ROCR(self.close, timeperiod=10)
elif para is 'ROCR100': #Rate of change ratio 100 scale: (price/prevPrice)*100
self.output = ta.ROCR100(self.close, timeperiod=10)
elif para is 'RSI': #Relative Strength Index
self.output = ta.RSI(self.close, timeperiod=self.tp)
elif para is 'STOCH': #Stochastic
slowk, slowd = ta.STOCH(self.high,
self.low,
self.close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
self.output = [slowk, slowd]
elif para is 'STOCHF': #Stochastic Fast
fastk, fastd = ta.STOCHF(self.high,
self.low,
self.close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
self.output = [fastk, fastd]
elif para is 'STOCHRSI': #Stochastic Relative Strength Index
fastk, fastd = ta.STOCHRSI(self.close,
timeperiod=self.tp,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
self.output = [fastk, fastd]
elif para is 'TRIX': #1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
self.output = ta.TRIX(self.close, timeperiod=self.tp)
elif para is 'ULTOSC': #Ultimate Oscillator
self.output = ta.ULTOSC(self.high,
self.low,
self.close,
timeperiod1=self.tp,
timeperiod2=self.tp1,
timeperiod3=self.tp2)
elif para is 'WILLR': #Williams' %R
self.output = ta.WILLR(self.high,
self.low,
self.close,
timeperiod=self.tp)
# Volume Indicators : #
elif para is 'AD': #Chaikin A/D Line
self.output = ta.AD(self.high, self.low, self.close, self.volume)
elif para is 'ADOSC': #Chaikin A/D Oscillator
self.output = ta.ADOSC(self.high,
self.low,
self.close,
self.volume,
fastperiod=3,
slowperiod=10)
elif para is 'OBV': #On Balance Volume
self.output = ta.OBV(self.close, self.volume)
# Volatility Indicators: #
elif para is 'ATR': #Average True Range
self.output = ta.ATR(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'NATR': #Normalized Average True Range
self.output = ta.NATR(self.high,
self.low,
self.close,
timeperiod=self.tp)
elif para is 'TRANGE': #True Range
self.output = ta.TRANGE(self.high, self.low, self.close)
#Price Transform : #
elif para is 'AVGPRICE': #Average Price
self.output = ta.AVGPRICE(self.op, self.high, self.low, self.close)
elif para is 'MEDPRICE': #Median Price
self.output = ta.MEDPRICE(self.high, self.low)
elif para is 'TYPPRICE': #Typical Price
self.output = ta.TYPPRICE(self.high, self.low, self.close)
elif para is 'WCLPRICE': #Weighted Close Price
self.output = ta.WCLPRICE(self.high, self.low, self.close)
#Cycle Indicators : #
elif para is 'HT_DCPERIOD': #Hilbert Transform - Dominant Cycle Period
self.output = ta.HT_DCPERIOD(self.close)
elif para is 'HT_DCPHASE': #Hilbert Transform - Dominant Cycle Phase
self.output = ta.HT_DCPHASE(self.close)
elif para is 'HT_PHASOR': #Hilbert Transform - Phasor Components
inphase, quadrature = ta.HT_PHASOR(self.close)
self.output = [inphase, quadrature]
elif para is 'HT_SINE': #Hilbert Transform - SineWave #2
sine, leadsine = ta.HT_SINE(self.close)
self.output = [sine, leadsine]
elif para is 'HT_TRENDMODE': #Hilbert Transform - Trend vs Cycle Mode
self.integer = ta.HT_TRENDMODE(self.close)
#Pattern Recognition : #
elif para is 'CDL2CROWS': #Two Crows
self.integer = ta.CDL2CROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDL3BLACKCROWS': #Three Black Crows
self.integer = ta.CDL3BLACKCROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDL3INSIDE': #Three Inside Up/Down
self.integer = ta.CDL3INSIDE(self.op, self.high, self.low,
self.close)
elif para is 'CDL3LINESTRIKE': #Three-Line Strike
self.integer = ta.CDL3LINESTRIKE(self.op, self.high, self.low,
self.close)
elif para is 'CDL3OUTSIDE': #Three Outside Up/Down
self.integer = ta.CDL3OUTSIDE(self.op, self.high, self.low,
self.close)
elif para is 'CDL3STARSINSOUTH': #Three Stars In The South
self.integer = ta.CDL3STARSINSOUTH(self.op, self.high, self.low,
self.close)
elif para is 'CDL3WHITESOLDIERS': #Three Advancing White Soldiers
self.integer = ta.CDL3WHITESOLDIERS(self.op, self.high, self.low,
self.close)
elif para is 'CDLABANDONEDBABY': #Abandoned Baby
self.integer = ta.CDLABANDONEDBABY(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLBELTHOLD': #Belt-hold
self.integer = ta.CDLBELTHOLD(self.op, self.high, self.low,
self.close)
elif para is 'CDLBREAKAWAY': #Breakaway
self.integer = ta.CDLBREAKAWAY(self.op, self.high, self.low,
self.close)
elif para is 'CDLCLOSINGMARUBOZU': #Closing Marubozu
self.integer = ta.CDLCLOSINGMARUBOZU(self.op, self.high, self.low,
self.close)
elif para is 'CDLCONCEALBABYSWALL': #Concealing Baby Swallow
self.integer = ta.CDLCONCEALBABYSWALL(self.op, self.high, self.low,
self.close)
elif para is 'CDLCOUNTERATTACK': #Counterattack
self.integer = ta.CDLCOUNTERATTACK(self.op, self.high, self.low,
self.close)
elif para is 'CDLDARKCLOUDCOVER': #Dark Cloud Cover
self.integer = ta.CDLDARKCLOUDCOVER(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLDOJI': #Doji
self.integer = ta.CDLDOJI(self.op, self.high, self.low, self.close)
elif para is 'CDLDOJISTAR': #Doji Star
self.integer = ta.CDLDOJISTAR(self.op, self.high, self.low,
self.close)
elif para is 'CDLDRAGONFLYDOJI': #Dragonfly Doji
self.integer = ta.CDLDRAGONFLYDOJI(self.op, self.high, self.low,
self.close)
elif para is 'CDLENGULFING': #Engulfing Pattern
self.integer = ta.CDLENGULFING(self.op, self.high, self.low,
self.close)
elif para is 'CDLEVENINGDOJISTAR': #Evening Doji Star
self.integer = ta.CDLEVENINGDOJISTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLEVENINGSTAR': #Evening Star
self.integer = ta.CDLEVENINGSTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLGAPSIDESIDEWHITE': #Up/Down-gap side-by-side white lines
self.integer = ta.CDLGAPSIDESIDEWHITE(self.op, self.high, self.low,
self.close)
elif para is 'CDLGRAVESTONEDOJI': #Gravestone Doji
self.integer = ta.CDLGRAVESTONEDOJI(self.op, self.high, self.low,
self.close)
elif para is 'CDLHAMMER': #Hammer
self.integer = ta.CDLHAMMER(self.op, self.high, self.low,
self.close)
elif para is 'CDLHANGINGMAN': #Hanging Man
self.integer = ta.CDLHANGINGMAN(self.op, self.high, self.low,
self.close)
elif para is 'CDLHARAMI': #Harami Pattern
self.integer = ta.CDLHARAMI(self.op, self.high, self.low,
self.close)
elif para is 'CDLHARAMICROSS': #Harami Cross Pattern
self.integer = ta.CDLHARAMICROSS(self.op, self.high, self.low,
self.close)
elif para is 'CDLHIGHWAVE': #High-Wave Candle
self.integer = ta.CDLHIGHWAVE(self.op, self.high, self.low,
self.close)
elif para is 'CDLHIKKAKE': #Hikkake Pattern
self.integer = ta.CDLHIKKAKE(self.op, self.high, self.low,
self.close)
elif para is 'CDLHIKKAKEMOD': #Modified Hikkake Pattern
self.integer = ta.CDLHIKKAKEMOD(self.op, self.high, self.low,
self.close)
elif para is 'CDLHOMINGPIGEON': #Homing Pigeon
self.integer = ta.CDLHOMINGPIGEON(self.op, self.high, self.low,
self.close)
elif para is 'CDLIDENTICAL3CROWS': #Identical Three Crows
self.integer = ta.CDLIDENTICAL3CROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDLINNECK': #In-Neck Pattern
self.integer = ta.CDLINNECK(self.op, self.high, self.low,
self.close)
elif para is 'CDLINVERTEDHAMMER': #Inverted Hammer
self.integer = ta.CDLINVERTEDHAMMER(self.op, self.high, self.low,
self.close)
elif para is 'CDLKICKING': #Kicking
self.integer = ta.CDLKICKING(self.op, self.high, self.low,
self.close)
elif para is 'CDLKICKINGBYLENGTH': #Kicking - bull/bear determined by the longer marubozu
self.integer = ta.CDLKICKINGBYLENGTH(self.op, self.high, self.low,
self.close)
elif para is 'CDLLADDERBOTTOM': #Ladder Bottom
self.integer = ta.CDLLADDERBOTTOM(self.op, self.high, self.low,
self.close)
elif para is 'CDLLONGLEGGEDDOJI': #Long Legged Doji
self.integer = ta.CDLLONGLEGGEDDOJI(self.op, self.high, self.low,
self.close)
elif para is 'CDLLONGLINE': #Long Line Candle
self.integer = ta.CDLLONGLINE(self.op, self.high, self.low,
self.close)
elif para is 'CDLMARUBOZU': #Marubozu
self.integer = ta.CDLMARUBOZU(self.op, self.high, self.low,
self.close)
elif para is 'CDLMATCHINGLOW': #Matching Low
self.integer = ta.CDLMATCHINGLOW(self.op, self.high, self.low,
self.close)
elif para is 'CDLMATHOLD': #Mat Hold
self.integer = ta.CDLMATHOLD(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLMORNINGDOJISTAR': #Morning Doji Star
self.integer = ta.CDLMORNINGDOJISTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLMORNINGSTAR': #Morning Star
self.integer = ta.CDLMORNINGSTAR(self.op,
self.high,
self.low,
self.close,
penetration=0)
elif para is 'CDLONNECK': #On-Neck Pattern
self.integer = ta.CDLONNECK(self.op, self.high, self.low,
self.close)
elif para is 'CDLPIERCING': #Piercing Pattern
self.integer = ta.CDLPIERCING(self.op, self.high, self.low,
self.close)
elif para is 'CDLRICKSHAWMAN': #Rickshaw Man
self.integer = ta.CDLRICKSHAWMAN(self.op, self.high, self.low,
self.close)
elif para is 'CDLRISEFALL3METHODS': #Rising/Falling Three Methods
self.integer = ta.CDLRISEFALL3METHODS(self.op, self.high, self.low,
self.close)
elif para is 'CDLSEPARATINGLINES': #Separating Lines
self.integer = ta.CDLSEPARATINGLINES(self.op, self.high, self.low,
self.close)
elif para is 'CDLSHOOTINGSTAR': #Shooting Star
self.integer = ta.CDLSHOOTINGSTAR(self.op, self.high, self.low,
self.close)
elif para is 'CDLSHORTLINE': #Short Line Candle
self.integer = ta.CDLSHORTLINE(self.op, self.high, self.low,
self.close)
elif para is 'CDLSPINNINGTOP': #Spinning Top
self.integer = ta.CDLSPINNINGTOP(self.op, self.high, self.low,
self.close)
elif para is 'CDLSTALLEDPATTERN': #Stalled Pattern
self.integer = ta.CDLSTALLEDPATTERN(self.op, self.high, self.low,
self.close)
elif para is 'CDLSTICKSANDWICH': #Stick Sandwich
self.integer = ta.CDLSTICKSANDWICH(self.op, self.high, self.low,
self.close)
elif para is 'CDLTAKURI': #Takuri (Dragonfly Doji with very long lower shadow)
self.integer = ta.CDLTAKURI(self.op, self.high, self.low,
self.close)
elif para is 'CDLTASUKIGAP': #Tasuki Gap
self.integer = ta.CDLTASUKIGAP(self.op, self.high, self.low,
self.close)
elif para is 'CDLTHRUSTING': #Thrusting Pattern
self.integer = ta.CDLTHRUSTING(self.op, self.high, self.low,
self.close)
elif para is 'CDLTRISTAR': #Tristar Pattern
self.integer = ta.CDLTRISTAR(self.op, self.high, self.low,
self.close)
elif para is 'CDLUNIQUE3RIVER': #Unique 3 River
self.integer = ta.CDLUNIQUE3RIVER(self.op, self.high, self.low,
self.close)
elif para is 'CDLUPSIDEGAP2CROWS': #Upside Gap Two Crows
self.integer = ta.CDLUPSIDEGAP2CROWS(self.op, self.high, self.low,
self.close)
elif para is 'CDLXSIDEGAP3METHODS': #Upside/Downside Gap Three Methods
self.integer = ta.CDLXSIDEGAP3METHODS(self.op, self.high, self.low,
self.close)
#Statistic Functions : #
elif para is 'BETA': #Beta
self.output = ta.BETA(self.high, self.low, timeperiod=5)
elif para is 'CORREL': #Pearson's Correlation Coefficient (r)
self.output = ta.CORREL(self.high, self.low, timeperiod=self.tp)
elif para is 'LINEARREG': #Linear Regression
self.output = ta.LINEARREG(self.close, timeperiod=self.tp)
elif para is 'LINEARREG_ANGLE': #Linear Regression Angle
self.output = ta.LINEARREG_ANGLE(self.close, timeperiod=self.tp)
elif para is 'LINEARREG_INTERCEPT': #Linear Regression Intercept
self.output = ta.LINEARREG_INTERCEPT(self.close,
timeperiod=self.tp)
elif para is 'LINEARREG_SLOPE': #Linear Regression Slope
self.output = ta.LINEARREG_SLOPE(self.close, timeperiod=self.tp)
elif para is 'STDDEV': #Standard Deviation
self.output = ta.STDDEV(self.close, timeperiod=5, nbdev=1)
elif para is 'TSF': #Time Series Forecast
self.output = ta.TSF(self.close, timeperiod=self.tp)
elif para is 'VAR': #Variance
self.output = ta.VAR(self.close, timeperiod=5, nbdev=1)
else:
print('You issued command:' + para)
def TALIB_MIDPRICE(close, timeperiod=14):
'''00361,2,1'''
return talib.MIDPRICE(close, timeperiod)
def main():
# read csv file and transform it to datafeed (df):
df = pd.read_csv(current_dir+"/"+base_dir+"/"+in_dir+"/"+in_dir+'_'+stock_symbol+'.csv')
# set numpy datafeed from df:
df_numpy = {
'date': np.array(df['date']),
'open': np.array(df['open'], dtype='float'),
'high': np.array(df['high'], dtype='float'),
'low': np.array(df['low'], dtype='float'),
'close': np.array(df['close'], dtype='float'),
'volume': np.array(df['volume'], dtype='float')
}
date = df_numpy['date']
openp = df_numpy['open']
high = df_numpy['high']
low = df_numpy['low']
close = df_numpy['close']
volume = df_numpy['volume']
#########################################
####### Overlap Study Function ##########
#########################################
#Bollinger Band Indicator
upperBB, middleBB, lowerBB = ta.BBANDS(close, matype=MA_Type.T3)
#Double Exponential Moving Average
dema = ta.DEMA(close, timeperiod=30)
#Exponential Moving Average
ema = ta.EMA(close, timeperiod=30)
#HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
ht = ta.HT_TRENDLINE(close)
#KAMA - Kaufman Adaptive Moving Average
kama = ta.KAMA(close, timeperiod=30)
#MA10 - Moving average 10
ma10 = ta.MA(close, timeperiod=10, matype=0)
#MA100 - Moving average
ma100 = ta.MA(close, timeperiod=100, matype=0)
#MAMA - MESA Adaptive Moving Average
#mama, fama = ta.MAMA(close, fastlimit=0, slowlimit=0)
#MAVP - Moving average with variable period
#mavp = ta.MAVP(close, periods, minperiod=2, maxperiod=30, matype=0)
#MIDPOINT - MidPoint over period
midpoint = ta.MIDPOINT(close, timeperiod=14)
#MIDPRICE - Midpoint Price over period
midprice = ta.MIDPRICE(high, low, timeperiod=14)
#SAR - Parabolic SAR
sar = ta.SAR(high, low, acceleration=0, maximum=0)
#SAREXT - Parabolic SAR - Extended
sarext = ta.SAREXT(high, low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)
#Simple Moving Average indicator sample 10
sma10 = ta.SMA(close, 10)
#T3 - Triple Exponential Moving Average (T3)
t3 = ta.T3(close, timeperiod=5, vfactor=0)
#TEMA - Triple Exponential Moving Average
tema = ta.TEMA(close, timeperiod=30)
#TRIMA - Triangular Moving Average
trima = ta.TRIMA(close, timeperiod=30)
#WMA - Weighted Moving Average
wma = ta.WMA(close, timeperiod=30)
df_save = pd.DataFrame(data ={
'date': date,
'upperBB': upperBB,
'middleBB': middleBB,
'lowerBB': lowerBB,
'dema':dema,
'ema':ema,
'ht':ht,
'kama':kama,
'ma10':ma10,
'ma100':ma100,
#'mama':mama,
#'fama':fama,
'midpoint':midpoint,
'midprice':midprice,
'sar':sar,
'sarext':sarext,
'sma10':sma10,
't3':t3,
'tema':tema,
'trima':trima,
'wma':wma,
'close':close
})
#df_save = df_save.dropna()
df_save.to_csv(current_dir+"/"+base_dir+"/"+out_dir+'/'+stock_symbol+"/"+out_dir+'_ta_overlap_studies_'+stock_symbol+'.csv',index=False)
def main():
ohlcv = api_ohlcv('20191017')
open, high, low, close, volume, timestamp = [], [], [], [], [], []
for i in ohlcv:
open.append(int(i[0]))
high.append(int(i[1]))
low.append(int(i[2]))
close.append(int(i[3]))
volume.append(float(i[4]))
time_str = str(i[5])
timestamp.append(
datetime.fromtimestamp(int(
time_str[:10])).strftime('%Y/%m/%d %H:%M:%M'))
date_time_index = pd.to_datetime(
timestamp) # convert to DateTimeIndex type
df = pd.DataFrame(
{
'open': open,
'high': high,
'low': low,
'close': close,
'volume': volume
},
index=date_time_index)
# df.index += pd.offsets.Hour(9) # adjustment for JST if required
print(df.shape)
print(df.columns)
# pct_change
f = lambda x: 1 if x > 0.0001 else -1 if x < -0.0001 else 0 if -0.0001 <= x <= 0.0001 else np.nan
y = df.rename(columns={
'close': 'y'
}).loc[:, 'y'].pct_change(1).shift(-1).fillna(0)
X = df.copy()
y_ = pd.DataFrame(y.map(f), columns=['y'])
y = df.rename(columns={'close': 'y'}).loc[:, 'y'].pct_change(1).fillna(0)
df_ = pd.concat([X, y_], axis=1)
# check the shape
print(
'----------------------------------------------------------------------------------------'
)
print('X shape: (%i,%i)' % X.shape)
print('y shape: (%i,%i)' % y_.shape)
print(
'----------------------------------------------------------------------------------------'
)
print(y_.groupby('y').size())
print('y=1 up, y=0 stay, y=-1 down')
print(
'----------------------------------------------------------------------------------------'
)
# feature calculation
open = pd.Series(df['open'])
high = pd.Series(df['high'])
low = pd.Series(df['low'])
close = pd.Series(df['close'])
volume = pd.Series(df['volume'])
# pct_change for new column
X['diff'] = y
# Exponential Moving Average
ema = talib.EMA(close, timeperiod=3)
ema = ema.fillna(ema.mean())
# Momentum
momentum = talib.MOM(close, timeperiod=5)
momentum = momentum.fillna(momentum.mean())
# RSI
rsi = talib.RSI(close, timeperiod=14)
rsi = rsi.fillna(rsi.mean())
# ADX
adx = talib.ADX(high, low, close, timeperiod=14)
adx = adx.fillna(adx.mean())
# ADX change
adx_change = adx.pct_change(1).shift(-1)
adx_change = adx_change.fillna(adx_change.mean())
# AD
ad = talib.AD(high, low, close, volume)
ad = ad.fillna(ad.mean())
X_ = pd.concat([X, ema, momentum, rsi, adx_change, ad],
axis=1).drop(['open', 'high', 'low', 'close'], axis=1)
X_.columns = ['volume', 'diff', 'ema', 'momentum', 'rsi', 'adx', 'ad']
X_.join(y_).head(10)
# default parameter models
X_train, X_test, y_train, y_test = train_test_split(X_,
y_,
test_size=0.33,
random_state=42)
print('X_train shape: {}'.format(X_train.shape))
print('X_test shape: {}'.format(X_test.shape))
print('y_train shape: {}'.format(y_train.shape))
print('y_test shape: {}'.format(y_test.shape))
pipe_knn = Pipeline([('scl', StandardScaler()),
('est', KNeighborsClassifier(n_neighbors=3))])
pipe_logistic = Pipeline([('scl', StandardScaler()),
('est',
LogisticRegression(solver='lbfgs',
multi_class='multinomial',
random_state=39))])
pipe_rf = Pipeline([('scl', StandardScaler()),
('est', RandomForestClassifier(random_state=39))])
pipe_gb = Pipeline([('scl', StandardScaler()),
('est', GradientBoostingClassifier(random_state=39))])
pipe_names = ['KNN', 'Logistic', 'RandomForest', 'GradientBoosting']
pipe_lines = [pipe_knn, pipe_logistic, pipe_rf, pipe_gb]
for (i, pipe) in enumerate(pipe_lines):
pipe.fit(X_train, y_train.values.ravel())
print(pipe)
print('%s: %.3f' %
(pipe_names[i] + ' Train Accuracy',
accuracy_score(y_train.values.ravel(), pipe.predict(X_train))))
print('%s: %.3f' %
(pipe_names[i] + ' Test Accuracy',
accuracy_score(y_test.values.ravel(), pipe.predict(X_test))))
print('%s: %.3f' % (pipe_names[i] + ' Train F1 Score',
f1_score(y_train.values.ravel(),
pipe.predict(X_train),
average='micro')))
print('%s: %.3f' % (pipe_names[i] + ' Test F1 Score',
f1_score(y_test.values.ravel(),
pipe.predict(X_test),
average='micro')))
for (i, pipe) in enumerate(pipe_lines):
predict = pipe.predict(X_test)
cm = confusion_matrix(y_test.values.ravel(),
predict,
labels=[-1, 0, 1])
print('{} Confusion Matrix'.format(pipe_names[i]))
print(cm)
## Overlap Studies Functions
# DEMA - Double Exponential Moving Average
dema = talib.DEMA(close, timeperiod=3)
dema = dema.fillna(dema.mean())
print('DEMA - Double Exponential Moving Average shape: {}'.format(
dema.shape))
# EMA - Exponential Moving Average
ema = talib.EMA(close, timeperiod=3)
ema = ema.fillna(ema.mean())
print('EMA - Exponential Moving Average shape: {}'.format(ema.shape))
# HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
hilbert = talib.HT_TRENDLINE(close)
hilbert = hilbert.fillna(hilbert.mean())
print(
'HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline shape: {}'.
format(hilbert.shape))
# KAMA - Kaufman Adaptive Moving Average
kama = talib.KAMA(close, timeperiod=3)
kama = kama.fillna(kama.mean())
print('KAMA - Kaufman Adaptive Moving Average shape: {}'.format(
kama.shape))
# MA - Moving average
ma = talib.MA(close, timeperiod=3, matype=0)
ma = ma.fillna(ma.mean())
print('MA - Moving average shape: {}'.format(kama.shape))
# MIDPOINT - MidPoint over period
midpoint = talib.MIDPOINT(close, timeperiod=7)
midpoint = midpoint.fillna(midpoint.mean())
print('MIDPOINT - MidPoint over period shape: {}'.format(midpoint.shape))
# MIDPRICE - Midpoint Price over period
midprice = talib.MIDPRICE(high, low, timeperiod=7)
midprice = midprice.fillna(midprice.mean())
print('MIDPRICE - Midpoint Price over period shape: {}'.format(
midprice.shape))
# SAR - Parabolic SAR
sar = talib.SAR(high, low, acceleration=0, maximum=0)
sar = sar.fillna(sar.mean())
print('SAR - Parabolic SAR shape: {}'.format(sar.shape))
# SAREXT - Parabolic SAR - Extended
sarext = talib.SAREXT(high,
low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
sarext = sarext.fillna(sarext.mean())
print('SAREXT - Parabolic SAR - Extended shape: {}'.format(sarext.shape))
# SMA - Simple Moving Average
sma = talib.SMA(close, timeperiod=3)
sma = sma.fillna(sma.mean())
print('SMA - Simple Moving Average shape: {}'.format(sma.shape))
# T3 - Triple Exponential Moving Average (T3)
t3 = talib.T3(close, timeperiod=5, vfactor=0)
t3 = t3.fillna(t3.mean())
print('T3 - Triple Exponential Moving Average shape: {}'.format(t3.shape))
# TEMA - Triple Exponential Moving Average
tema = talib.TEMA(close, timeperiod=3)
tema = tema.fillna(tema.mean())
print('TEMA - Triple Exponential Moving Average shape: {}'.format(
tema.shape))
# TRIMA - Triangular Moving Average
trima = talib.TRIMA(close, timeperiod=3)
trima = trima.fillna(trima.mean())
print('TRIMA - Triangular Moving Average shape: {}'.format(trima.shape))
# WMA - Weighted Moving Average
wma = talib.WMA(close, timeperiod=3)
wma = wma.fillna(wma.mean())
print('WMA - Weighted Moving Average shape: {}'.format(wma.shape))
## Momentum Indicator Functions
# ADX - Average Directional Movement Index
adx = talib.ADX(high, low, close, timeperiod=14)
adx = adx.fillna(adx.mean())
print('ADX - Average Directional Movement Index shape: {}'.format(
adx.shape))
# ADXR - Average Directional Movement Index Rating
adxr = talib.ADXR(high, low, close, timeperiod=7)
adxr = adxr.fillna(adxr.mean())
print('ADXR - Average Directional Movement Index Rating shape: {}'.format(
adxr.shape))
# APO - Absolute Price Oscillator
apo = talib.APO(close, fastperiod=12, slowperiod=26, matype=0)
apo = apo.fillna(apo.mean())
print('APO - Absolute Price Oscillator shape: {}'.format(apo.shape))
# AROONOSC - Aroon Oscillator
aroon = talib.AROONOSC(high, low, timeperiod=14)
aroon = aroon.fillna(aroon.mean())
print('AROONOSC - Aroon Oscillator shape: {}'.format(apo.shape))
# BOP - Balance Of Power
bop = talib.BOP(open, high, low, close)
bop = bop.fillna(bop.mean())
print('BOP - Balance Of Power shape: {}'.format(apo.shape))
# CCI - Commodity Channel Index
cci = talib.CCI(high, low, close, timeperiod=7)
cci = cci.fillna(cci.mean())
print('CCI - Commodity Channel Index shape: {}'.format(cci.shape))
# CMO - Chande Momentum Oscillator
cmo = talib.CMO(close, timeperiod=7)
cmo = cmo.fillna(cmo.mean())
print('CMO - Chande Momentum Oscillator shape: {}'.format(cmo.shape))
# DX - Directional Movement Index
dx = talib.DX(high, low, close, timeperiod=7)
dx = dx.fillna(dx.mean())
print('DX - Directional Movement Index shape: {}'.format(dx.shape))
# MFI - Money Flow Index
mfi = talib.MFI(high, low, close, volume, timeperiod=7)
mfi = mfi.fillna(mfi.mean())
print('MFI - Money Flow Index shape: {}'.format(mfi.shape))
# MINUS_DI - Minus Directional Indicator
minusdi = talib.MINUS_DI(high, low, close, timeperiod=14)
minusdi = minusdi.fillna(minusdi.mean())
print('MINUS_DI - Minus Directional Indicator shape: {}'.format(
minusdi.shape))
# MINUS_DM - Minus Directional Movement
minusdm = talib.MINUS_DM(high, low, timeperiod=14)
minusdm = minusdm.fillna(minusdm.mean())
print('MINUS_DM - Minus Directional Movement shape: {}'.format(
minusdm.shape))
# MOM - Momentum
mom = talib.MOM(close, timeperiod=5)
mom = mom.fillna(mom.mean())
print('MOM - Momentum shape: {}'.format(mom.shape))
# PLUS_DI - Plus Directional Indicator
plusdi = talib.PLUS_DI(high, low, close, timeperiod=14)
plusdi = plusdi.fillna(plusdi.mean())
print('PLUS_DI - Plus Directional Indicator shape: {}'.format(
plusdi.shape))
# PLUS_DM - Plus Directional Movement
plusdm = talib.PLUS_DM(high, low, timeperiod=14)
plusdm = plusdm.fillna(plusdm.mean())
print('PLUS_DM - Plus Directional Movement shape: {}'.format(plusdi.shape))
# PPO - Percentage Price Oscillator
ppo = talib.PPO(close, fastperiod=12, slowperiod=26, matype=0)
ppo = ppo.fillna(ppo.mean())
print('PPO - Percentage Price Oscillator shape: {}'.format(ppo.shape))
# ROC - Rate of change:((price/prevPrice)-1)*100
roc = talib.ROC(close, timeperiod=10)
roc = roc.fillna(roc.mean())
print('ROC - Rate of change : ((price/prevPrice)-1)*100 shape: {}'.format(
roc.shape))
# RSI - Relative Strength Index
rsi = talib.RSI(close, timeperiod=14)
rsi = rsi.fillna(rsi.mean())
print('RSI - Relative Strength Index shape: {}'.format(rsi.shape))
# TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
trix = talib.TRIX(close, timeperiod=30)
trix = trix.fillna(trix.mean())
print('TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA shape: {}'.
format(trix.shape))
# ULTOSC - Ultimate Oscillator
ultosc = talib.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
ultosc = ultosc.fillna(ultosc.mean())
print('ULTOSC - Ultimate Oscillator shape: {}'.format(ultosc.shape))
# WILLR - Williams'%R
willr = talib.WILLR(high, low, close, timeperiod=7)
willr = willr.fillna(willr.mean())
print("WILLR - Williams'%R shape: {}".format(willr.shape))
## Volume Indicator Functions
# AD - Chaikin A/D Line
ad = talib.AD(high, low, close, volume)
ad = ad.fillna(ad.mean())
print('AD - Chaikin A/D Line shape: {}'.format(ad.shape))
# ADOSC - Chaikin A/D Oscillator
adosc = talib.ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
adosc = adosc.fillna(adosc.mean())
print('ADOSC - Chaikin A/D Oscillator shape: {}'.format(adosc.shape))
# OBV - On Balance Volume
obv = talib.OBV(close, volume)
obv = obv.fillna(obv.mean())
print('OBV - On Balance Volume shape: {}'.format(obv.shape))
## Volatility Indicator Functions
# ATR - Average True Range
atr = talib.ATR(high, low, close, timeperiod=7)
atr = atr.fillna(atr.mean())
print('ATR - Average True Range shape: {}'.format(atr.shape))
# NATR - Normalized Average True Range
natr = talib.NATR(high, low, close, timeperiod=7)
natr = natr.fillna(natr.mean())
print('NATR - Normalized Average True Range shape: {}'.format(natr.shape))
# TRANGE - True Range
trange = talib.TRANGE(high, low, close)
trange = trange.fillna(trange.mean())
print('TRANGE - True Range shape: {}'.format(natr.shape))
## Price Transform Functions
# AVGPRICE - Average Price
avg = talib.AVGPRICE(open, high, low, close)
avg = avg.fillna(avg.mean())
print('AVGPRICE - Average Price shape: {}'.format(natr.shape))
# MEDPRICE - Median Price
medprice = talib.MEDPRICE(high, low)
medprice = medprice.fillna(medprice.mean())
print('MEDPRICE - Median Price shape: {}'.format(medprice.shape))
# TYPPRICE - Typical Price
typ = talib.TYPPRICE(high, low, close)
typ = typ.fillna(typ.mean())
print('TYPPRICE - Typical Price shape: {}'.format(typ.shape))
# WCLPRICE - Weighted Close Price
wcl = talib.WCLPRICE(high, low, close)
wcl = wcl.fillna(wcl.mean())
print('WCLPRICE - Weighted Close Price shape: {}'.format(wcl.shape))
## Cycle Indicator Functions
# HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period
dcperiod = talib.HT_DCPERIOD(close)
dcperiod = dcperiod.fillna(dcperiod.mean())
print('HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period shape: {}'.
format(dcperiod.shape))
# HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase
dcphase = talib.HT_DCPHASE(close)
dcphase = dcphase.fillna(dcphase.mean())
print('HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase shape: {}'.
format(dcperiod.shape))
## Statistic Functions
# BETA - Beta
beta = talib.BETA(high, low, timeperiod=3)
beta = beta.fillna(beta.mean())
print('BETA - Beta shape: {}'.format(beta.shape))
# CORREL - Pearson's Correlation Coefficient(r)
correl = talib.CORREL(high, low, timeperiod=30)
correl = correl.fillna(correl.mean())
print("CORREL - Pearson's Correlation Coefficient(r) shape: {}".format(
beta.shape))
# LINEARREG - Linear Regression
linreg = talib.LINEARREG(close, timeperiod=7)
linreg = linreg.fillna(linreg.mean())
print("LINEARREG - Linear Regression shape: {}".format(linreg.shape))
# STDDEV - Standard Deviation
stddev = talib.STDDEV(close, timeperiod=5, nbdev=1)
stddev = stddev.fillna(stddev.mean())
print("STDDEV - Standard Deviation shape: {}".format(stddev.shape))
# TSF - Time Series Forecast
tsf = talib.TSF(close, timeperiod=7)
tsf = tsf.fillna(tsf.mean())
print("TSF - Time Series Forecast shape: {}".format(tsf.shape))
# VAR - Variance
var = talib.VAR(close, timeperiod=5, nbdev=1)
var = var.fillna(var.mean())
print("VAR - Variance shape: {}".format(var.shape))
## Feature DataFrame
X_full = pd.concat([
X, dema, ema, hilbert, kama, ma, midpoint, midprice, sar, sarext, sma,
t3, tema, trima, wma, adx, adxr, apo, aroon, bop, cci, cmo, mfi,
minusdi, minusdm, mom, plusdi, plusdm, ppo, roc, rsi, trix, ultosc,
willr, ad, adosc, obv, atr, natr, trange, avg, medprice, typ, wcl,
dcperiod, dcphase, beta, correl, linreg, stddev, tsf, var
],
axis=1).drop(['open', 'high', 'low', 'close'], axis=1)
X_full.columns = [
'volume', 'diff', 'dema', 'ema', 'hilbert', 'kama', 'ma', 'midpoint',
'midprice', 'sar', 'sarext', 'sma', 't3', 'tema', 'trima', 'wma',
'adx', 'adxr', 'apo', 'aroon', 'bop', 'cci', 'cmo', 'mfi', 'minusdi',
'minusdm', 'mom', 'plusdi', 'plusdm', 'ppo', 'roc', 'rsi', 'trix',
'ultosc', 'willr', 'ad', 'adosc', 'obv', 'atr', 'natr', 'trange',
'avg', 'medprice', 'typ', 'wcl', 'dcperiod', 'dcphase', 'beta',
'correl', 'linreg', 'stddev', 'tsf', 'var'
]
X_full.join(y_).head(10)
# full feature models
X_train_full, X_test_full, y_train_full, y_test_full = train_test_split(
X_full, y_, test_size=0.33, random_state=42)
print('X_train shape: {}'.format(X_train_full.shape))
print('X_test shape: {}'.format(X_test_full.shape))
print('y_train shape: {}'.format(y_train_full.shape))
print('y_test shape: {}'.format(y_test_full.shape))
pipe_knn_full = Pipeline([('scl', StandardScaler()),
('est', KNeighborsClassifier(n_neighbors=3))])
pipe_logistic_full = Pipeline([
('scl', StandardScaler()),
('est',
LogisticRegression(solver='lbfgs',
multi_class='multinomial',
random_state=39))
])
pipe_rf_full = Pipeline([('scl', StandardScaler()),
('est', RandomForestClassifier(random_state=39))])
pipe_gb_full = Pipeline([('scl', StandardScaler()),
('est',
GradientBoostingClassifier(random_state=39))])
pipe_names = ['KNN', 'Logistic', 'RandomForest', 'GradientBoosting']
pipe_lines_full = [
pipe_knn_full, pipe_logistic_full, pipe_rf_full, pipe_gb_full
]
for (i, pipe) in enumerate(pipe_lines_full):
pipe.fit(X_train_full, y_train_full.values.ravel())
print(pipe)
print('%s: %.3f' % (pipe_names[i] + ' Train Accuracy',
accuracy_score(y_train_full.values.ravel(),
pipe.predict(X_train_full))))
print('%s: %.3f' % (pipe_names[i] + ' Test Accuracy',
accuracy_score(y_test_full.values.ravel(),
pipe.predict(X_test_full))))
print('%s: %.3f' % (pipe_names[i] + ' Train F1 Score',
f1_score(y_train_full.values.ravel(),
pipe.predict(X_train_full),
average='micro')))
print('%s: %.3f' % (pipe_names[i] + ' Test F1 Score',
f1_score(y_test_full.values.ravel(),
pipe.predict(X_test_full),
average='micro')))
# Univariate Statistics
select = SelectPercentile(percentile=25)
select.fit(X_train_full, y_train_full.values.ravel())
X_train_selected = select.transform(X_train_full)
X_test_selected = select.transform(X_test_full)
# GradientBoost Classifier
print(
'--------------------------Without Univariate Statistics-------------------------------------'
)
pipe_gb = Pipeline([('scl', StandardScaler()),
('est', GradientBoostingClassifier(random_state=39))])
pipe_gb.fit(X_train_full, y_train_full.values.ravel())
print('Train Accuracy: {:.3f}'.format(
accuracy_score(y_train_full.values.ravel(),
pipe_gb.predict(X_train_full))))
print('Test Accuracy: {:.3f}'.format(
accuracy_score(y_test_full.values.ravel(),
pipe_gb.predict(X_test_full))))
print('Train F1 Score: {:.3f}'.format(
f1_score(y_train_full.values.ravel(),
pipe_gb.predict(X_train_full),
average='micro')))
print('Test F1 Score: {:.3f}'.format(
f1_score(y_test_full.values.ravel(),
pipe_gb.predict(X_test_full),
average='micro')))
# GradientBoost Cllassifier with Univariate Statistics
print(
'---------------------------With Univariate Statistics--------------------------------------'
)
pipe_gb_percentile = Pipeline([
('scl', StandardScaler()),
('est', GradientBoostingClassifier(random_state=39))
])
pipe_gb_percentile.fit(X_train_selected, y_train_full.values.ravel())
print('Train Accuracy: {:.3f}'.format(
accuracy_score(y_train_full.values.ravel(),
pipe_gb_percentile.predict(X_train_selected))))
print('Test Accuracy: {:.3f}'.format(
accuracy_score(y_test_full.values.ravel(),
pipe_gb_percentile.predict(X_test_selected))))
print('Train F1 Score: {:.3f}'.format(
f1_score(y_train_full.values.ravel(),
pipe_gb_percentile.predict(X_train_selected),
average='micro')))
print('Test F1 Score: {:.3f}'.format(
f1_score(y_test_full.values.ravel(),
pipe_gb_percentile.predict(X_test_selected),
average='micro')))
# Model-based Selection
select = SelectFromModel(RandomForestClassifier(n_estimators=100,
random_state=42),
threshold="1.25*mean")
select.fit(X_train_full, y_train_full.values.ravel())
X_train_model = select.transform(X_train_full)
X_test_model = select.transform(X_test_full)
# GradientBoost Classifier
print(
'--------------------------Without Model-based Selection--------------------------------------'
)
pipe_gb = Pipeline([('scl', StandardScaler()),
('est', GradientBoostingClassifier(random_state=39))])
pipe_gb.fit(X_train_full, y_train_full.values.ravel())
print('Train Accuracy: {:.3f}'.format(
accuracy_score(y_train_full.values.ravel(),
pipe_gb.predict(X_train_full))))
print('Test Accuracy: {:.3f}'.format(
accuracy_score(y_test_full.values.ravel(),
pipe_gb.predict(X_test_full))))
print('Train F1 Score: {:.3f}'.format(
f1_score(y_train_full.values.ravel(),
pipe_gb.predict(X_train_full),
average='micro')))
print('Test F1 Score: {:.3f}'.format(
f1_score(y_test_full.values.ravel(),
pipe_gb.predict(X_test_full),
average='micro')))
# GradientBoost Classifier with Model-based Selection
print(
'----------------------------With Model-based Selection--------------------------------------'
)
pipe_gb_model = Pipeline([('scl', StandardScaler()),
('est',
GradientBoostingClassifier(random_state=39))])
pipe_gb_model.fit(X_train_model, y_train_full.values.ravel())
print('Train Accuracy: {:.3f}'.format(
accuracy_score(y_train_full.values.ravel(),
pipe_gb_model.predict(X_train_model))))
print('Test Accuracy: {:.3f}'.format(
accuracy_score(y_test_full.values.ravel(),
pipe_gb_model.predict(X_test_model))))
print('Train F1 Score: {:.3f}'.format(
f1_score(y_train_full.values.ravel(),
pipe_gb_model.predict(X_train_model),
average='micro')))
print('Test F1 Score: {:.3f}'.format(
f1_score(y_test_full.values.ravel(),
pipe_gb_model.predict(X_test_model),
average='micro')))
# Recursive Feature Elimination
select = RFE(RandomForestClassifier(n_estimators=100, random_state=42),
n_features_to_select=15)
select.fit(X_train_full, y_train_full.values.ravel())
X_train_rfe = select.transform(X_train_full)
X_test_rfe = select.transform(X_test_full)
# GradientBoost Classifier
print(
'--------------------------Without Recursive Feature Elimination-------------------------------------'
)
pipe_gb = Pipeline([('scl', StandardScaler()),
('est', GradientBoostingClassifier(random_state=39))])
pipe_gb.fit(X_train_full, y_train_full.values.ravel())
print('Train Accuracy: {:.3f}'.format(
accuracy_score(y_train_full.values.ravel(),
pipe_gb.predict(X_train_full))))
print('Test Accuracy: {:.3f}'.format(
accuracy_score(y_test_full.values.ravel(),
pipe_gb.predict(X_test_full))))
print('Train F1 Score: {:.3f}'.format(
f1_score(y_train_full.values.ravel(),
pipe_gb.predict(X_train_full),
average='micro')))
print('Test F1 Score: {:.3f}'.format(
f1_score(y_test_full.values.ravel(),
pipe_gb.predict(X_test_full),
average='micro')))
# GradientBoost Classifier with Recursive Feature Elimination
print(
'----------------------------With Recursive Feature Elimination--------------------------------------'
)
pipe_gb_rfe = Pipeline([('scl', StandardScaler()),
('est',
GradientBoostingClassifier(random_state=39))])
pipe_gb_rfe.fit(X_train_rfe, y_train_full.values.ravel())
print('Train Accuracy: {:.3f}'.format(
accuracy_score(y_train_full.values.ravel(),
pipe_gb_rfe.predict(X_train_rfe))))
print('Test Accuracy: {:.3f}'.format(
accuracy_score(y_test_full.values.ravel(),
pipe_gb_rfe.predict(X_test_rfe))))
print('Train F1 Score: {:.3f}'.format(
f1_score(y_train_full.values.ravel(),
pipe_gb_rfe.predict(X_train_rfe),
average='micro')))
print('Test F1 Score: {:.3f}'.format(
f1_score(y_test_full.values.ravel(),
pipe_gb_rfe.predict(X_test_rfe),
average='micro')))
cv = cross_val_score(pipe_gb,
X_,
y_.values.ravel(),
cv=StratifiedKFold(n_splits=10,
shuffle=True,
random_state=39))
print('Cross validation with StratifiedKFold scores: {}'.format(cv))
print('Cross Validation with StatifiedKFold mean: {}'.format(cv.mean()))
# GridSearch
n_features = len(df.columns)
param_grid = {
'learning_rate': [0.01, 0.1, 1, 10],
'n_estimators': [1, 10, 100, 200, 300],
'max_depth': [1, 2, 3, 4, 5]
}
stratifiedcv = StratifiedKFold(n_splits=10, shuffle=True, random_state=39)
X_train, X_test, y_train, y_test = train_test_split(X_,
y_,
test_size=0.33,
random_state=42)
grid_search = GridSearchCV(GradientBoostingClassifier(),
param_grid,
cv=stratifiedcv)
grid_search.fit(X_train, y_train.values.ravel())
print('GridSearch Train Accuracy: {:.3f}'.format(
accuracy_score(y_train.values.ravel(), grid_search.predict(X_train))))
print('GridSearch Test Accuracy: {:.3f}'.format(
accuracy_score(y_test.values.ravel(), grid_search.predict(X_test))))
print('GridSearch Train F1 Score: {:.3f}'.format(
f1_score(y_train.values.ravel(),
grid_search.predict(X_train),
average='micro')))
print('GridSearch Test F1 Score: {:.3f}'.format(
f1_score(y_test.values.ravel(),
grid_search.predict(X_test),
average='micro')))
# GridSearch results
print("Best params:\n{}".format(grid_search.best_params_))
print("Best cross-validation score: {:.2f}".format(
grid_search.best_score_))
results = pd.DataFrame(grid_search.cv_results_)
corr_params = results.drop(results.columns[[
0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20
]],
axis=1)
corr_params.head()
# GridSearch in nested
cv_gb = cross_val_score(grid_search,
X_,
y_.values.ravel(),
cv=StratifiedKFold(n_splits=3,
shuffle=True,
random_state=39))
print('Grid Search with nested cross validation scores: {}'.format(cv_gb))
print('Grid Search with nested cross validation mean: {}'.format(
cv_gb.mean()))
def get_talib_stock_daily(
stock_code,
s,
e,
append_ori_close=False,
norms=['volume', 'amount', 'ht_dcphase', 'obv', 'adosc', 'ad', 'cci']):
"""获取经过talib处理后的股票日线数据"""
stock_data = QA.QA_fetch_stock_day_adv(stock_code, s, e)
stock_df = stock_data.to_qfq().data
if append_ori_close:
stock_df['o_close'] = stock_data.data['close']
# stock_df['high_qfq'] = stock_data.to_qfq().data['high']
# stock_df['low_hfq'] = stock_data.to_hfq().data['low']
close = np.array(stock_df['close'])
high = np.array(stock_df['high'])
low = np.array(stock_df['low'])
_open = np.array(stock_df['open'])
_volume = np.array(stock_df['volume'])
stock_df['dema'] = talib.DEMA(close)
stock_df['ema'] = talib.EMA(close)
stock_df['ht_tradeline'] = talib.HT_TRENDLINE(close)
stock_df['kama'] = talib.KAMA(close)
stock_df['ma'] = talib.MA(close)
stock_df['mama'], stock_df['fama'] = talib.MAMA(close)
# MAVP
stock_df['midpoint'] = talib.MIDPOINT(close)
stock_df['midprice'] = talib.MIDPRICE(high, low)
stock_df['sar'] = talib.SAR(high, low)
stock_df['sarext'] = talib.SAREXT(high, low)
stock_df['sma'] = talib.SMA(close)
stock_df['t3'] = talib.T3(close)
stock_df['tema'] = talib.TEMA(close)
stock_df['trima'] = talib.TRIMA(close)
stock_df['wma'] = talib.WMA(close)
stock_df['adx'] = talib.ADX(high, low, close)
stock_df['adxr'] = talib.ADXR(high, low, close)
stock_df['apo'] = talib.APO(close)
stock_df['aroondown'], stock_df['aroonup'] = talib.AROON(high, low)
stock_df['aroonosc'] = talib.AROONOSC(high, low)
stock_df['bop'] = talib.BOP(_open, high, low, close)
stock_df['cci'] = talib.CCI(high, low, close)
stock_df['cmo'] = talib.CMO(close)
stock_df['dx'] = talib.DX(high, low, close)
# MACD
stock_df['macd'], stock_df['macdsignal'], stock_df[
'macdhist'] = talib.MACDEXT(close)
# MACDFIX
stock_df['mfi'] = talib.MFI(high, low, close, _volume)
stock_df['minus_di'] = talib.MINUS_DI(high, low, close)
stock_df['minus_dm'] = talib.MINUS_DM(high, low)
stock_df['mom'] = talib.MOM(close)
stock_df['plus_di'] = talib.PLUS_DI(high, low, close)
stock_df['plus_dm'] = talib.PLUS_DM(high, low)
stock_df['ppo'] = talib.PPO(close)
stock_df['roc'] = talib.ROC(close)
stock_df['rocp'] = talib.ROCP(close)
stock_df['rocr'] = talib.ROCR(close)
stock_df['rocr100'] = talib.ROCR100(close)
stock_df['rsi'] = talib.RSI(close)
stock_df['slowk'], stock_df['slowd'] = talib.STOCH(high, low, close)
stock_df['fastk'], stock_df['fastd'] = talib.STOCHF(high, low, close)
# STOCHRSI - Stochastic Relative Strength Index
stock_df['trix'] = talib.TRIX(close)
stock_df['ultosc'] = talib.ULTOSC(high, low, close)
stock_df['willr'] = talib.WILLR(high, low, close)
stock_df['ad'] = talib.AD(high, low, close, _volume)
stock_df['adosc'] = talib.ADOSC(high, low, close, _volume)
stock_df['obv'] = talib.OBV(close, _volume)
stock_df['ht_dcperiod'] = talib.HT_DCPERIOD(close)
stock_df['ht_dcphase'] = talib.HT_DCPHASE(close)
stock_df['inphase'], stock_df['quadrature'] = talib.HT_PHASOR(close)
stock_df['sine'], stock_df['leadsine'] = talib.HT_PHASOR(close)
stock_df['ht_trendmode'] = talib.HT_TRENDMODE(close)
stock_df['avgprice'] = talib.AVGPRICE(_open, high, low, close)
stock_df['medprice'] = talib.MEDPRICE(high, low)
stock_df['typprice'] = talib.TYPPRICE(high, low, close)
stock_df['wclprice'] = talib.WCLPRICE(high, low, close)
stock_df['atr'] = talib.ATR(high, low, close)
stock_df['natr'] = talib.NATR(high, low, close)
stock_df['trange'] = talib.TRANGE(high, low, close)
stock_df['beta'] = talib.BETA(high, low)
stock_df['correl'] = talib.CORREL(high, low)
stock_df['linearreg'] = talib.LINEARREG(close)
stock_df['linearreg_angle'] = talib.LINEARREG_ANGLE(close)
stock_df['linearreg_intercept'] = talib.LINEARREG_INTERCEPT(close)
stock_df['linearreg_slope'] = talib.LINEARREG_SLOPE(close)
stock_df['stddev'] = talib.STDDEV(close)
stock_df['tsf'] = talib.TSF(close)
stock_df['var'] = talib.VAR(close)
stock_df = stock_df.reset_index().set_index('date')
if norms:
x = stock_df[norms].values # returns a numpy array
x_scaled = MinMaxScaler().fit_transform(x)
stock_df = stock_df.drop(columns=norms).join(
pd.DataFrame(x_scaled, columns=norms, index=stock_df.index))
# stock_df = stock_df.drop(columns=['code', 'open', 'high', 'low'])
stock_df = stock_df.dropna()
stock_df = stock_df.drop(columns=['code'])
return stock_df
