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