def create_df(ticker):
delay = 2
max_period = 20
slope_period = 30
timeperiod = 14
bars_list = api.get_barset(symbols=ticker, timeframe='minute', limit=30)
ticker_bars = bars_list[ticker]
ohlc_df = pd.DataFrame(columns=['high', 'low', 'close', 'volume'])
high_list = []
low_list = []
close_list = []
volume_list = []
for i in range(len(ticker_bars)):
high_list.append(ticker_bars[i].h)
low_list.append(ticker_bars[i].l)
close_list.append(ticker_bars[i].c)
volume_list.append(ticker_bars[i].v)
ohlc_df['high'] = high_list
ohlc_df['low'] = low_list
ohlc_df['close'] = close_list
ohlc_df['volume'] = volume_list
ohlc_df['v_shift'] = ohlc_df['volume'].shift(delay)
ohlc_df['av'] = ohlc_df['volume'].rolling(window=delay).max()
ohlc_df['max'] = ohlc_df['v_shift'].rolling(window=(max_period -
delay)).max()
ohlc_df['adx'] = ta.ADX(ohlc_df['high'], ohlc_df['low'], ohlc_df['close'])
ohlc_df['slope'] = slope(ohlc_df['close'], slope_period)
return ohlc_df
def test_adx():
'''test TA.ADX'''
adx = TA.ADX(ohlc, period=12)
ta_adx = talib.ADX(ohlc["high"], ohlc["low"], ohlc["close"], timeperiod=12)
assert int(ta_adx[-1]) == int(adx.values[-1])
def double_top_double_bottom(key, dataList, time_frame):
price_action = pd.DataFrame(
dataList,
columns=[id.time, id.open, id.close, id.high, id.low, id.volume])
if price_action.empty:
return
window_size = constants.strategy_params[id.window_size]
# To determine up/down trend and the strength
upTrend = utils.__uptrend(
price_action.iloc[-2 * window_size - 3:-3][id.close].values,
window_size)
downTrend = utils.__downtrend(
price_action.iloc[-2 * window_size - 3:-3][id.close].values,
window_size)
# ADX to determine the strength of the trend and OBV to get volume of trades placed
adx = ta.ADX(price_action[id.high], price_action[id.low],
price_action[id.close], window_size)
obv = ta.OBV(price_action[id.close], price_action[id.volume])
# Calculate the local maxima and minima in the window frame
local_minima, local_maxima, indices_minima, indices_maxima = utils.__local_min_max(
np.array(price_action[id.high]))
notifier = {values.double_top: False, values.double_bottom: False}
if upTrend and adx[len(adx) -
1] >= constants.strategy_params[id.trend_strength]:
notifier[values.double_top] = check_double_top(price_action,
indices_maxima, obv)
if downTrend and adx[len(adx) -
1] >= constants.strategy_params[id.trend_strength]:
notifier[values.double_bottom] = check_double_bottom(
price_action, indices_minima, obv)
if notifier[values.double_top]:
try:
#db.insert_strategy(key, time_frame, values.double_top, price_action.iloc[-1][id.time])
return {
id.name: id.double_top,
id.key: key,
id.price_action: dataList
}
except:
print('Unable to add to database')
return {}
if notifier[values.double_bottom]:
try:
#db.insert_strategy(key, time_frame, values.double_bottom, price_action.iloc[-1][id.time])
return {
id.name: id.double_bottom,
id.key: key,
id.price_action: dataList
}
except:
print('Unable to add to database')
return {}
def talib_adx(stock_data, LENGTH=14):
''' Function to calculate ADX - Average Directional Movement Index
Explain
=======
calculate ADX
Input
=====
stock_data: DataFrame
with OHLC, 'volume' and 'code' in each row
Output
======
Return: DataFrame
with 'ADX' in each row, use the same index from Input stock_data
'''
# create a new empty output dataframe, sharing the same index
newdf = pd.DataFrame(index=stock_data.index.copy())
# calculate ADX
newdf['ADX'] = talib.ADX(stock_data['high'].values,
stock_data['low'].values,
stock_data['close'].values,
timeperiod=LENGTH)
return newdf
def signal_pair(self, symbol):
short_ema = self.params.get('short_ema')
long_ema = self.params.get('long_ema')
adx_period = self.params.get('adx')
rsi = self.params.get('rsi')
candles = self.data_reader.get_candle(symbol,
PERIOD_H1,
count=50,
fromTime=None,
toTime=None,
price_type='M',
smooth=False)
adx = ta.ADX(candles['askhigh'],
candles['bidlow'],
candles['bidclose'],
timeperiod=adx_period)
ema_short = ta.EMA(candles['bidclose'], timeperiod=short_ema)
ema_long = ta.EMA(candles['bidclose'], timeperiod=long_ema)
mean = (candles['askhigh'] + candles['bidlow']) / 2
rsi = ta.RSI(mean, timeperiod=rsi)
# upper, middle, lower = ta.BBANDS(h1_candles['close'], matype=MA_Type.T3)
if self.can_open():
self.open(symbol, ema_short, ema_long, adx, rsi)
self.close(symbol, ema_short, ema_long, adx, rsi)
def adx(candles: np.ndarray,
period: int = 14,
sequential: bool = False) -> Union[float, np.ndarray]:
"""
ADX - Average Directional Movement Index
: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.ADX(candles[:, 3],
candles[:, 4],
candles[:, 2],
timeperiod=period)
if sequential:
return res
else:
return None if np.isnan(res[-1]) else res[-1]
def getMomentumIndicators(df):
high = df['High']
low = df['Low']
close = df['Close']
open = df['Open']
volume = df['Volume']
df['ADX'] = ta.ADX(high, low, close, timeperiod=14)
df['SMA'] = ta.ADXR(high, low, close, timeperiod=14)
df['APO'] = ta.APO(close, fastperiod=12, slowperiod=26, matype=0)
df['AROONDOWN'], df['AROOONUP'] = ta.AROON(high, low, timeperiod=14)
df['AROONOSC'] = ta.AROONOSC(high, low, timeperiod=14)
df['BOP'] = ta.BOP(open, high, low, close)
df['CCI'] = ta.CCI(high, low, close, timeperiod=14)
df['CMO'] = ta.CMO(close, timeperiod=14)
df['DX'] = ta.DX(high, low, close, timeperiod=14)
df['MACD'], df['MACDSIGNAL'], df['MACDHIST'] = ta.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
df['MFI'] = ta.MFI(high, low, close, volume, timeperiod=14)
df['MINUS_DI'] = ta.MINUS_DI(high, low, close, timeperiod=14)
df['MINUS_DM']= ta.MINUS_DM(high, low, timeperiod=14)
df['MOM'] = ta.MOM(close, timeperiod=10)
df['PLUS_DM'] =ta.PLUS_DM(high, low, timeperiod=14)
df['PPO'] = ta.PPO(close, fastperiod=12, slowperiod=26, matype=0)
df['ROC'] = ta.ROC(close, timeperiod=10)
df['ROCP'] = ta.ROCP(close, timeperiod=10)
df['ROCR'] = ta.ROCR(close, timeperiod=10)
df['ROCR100'] = ta.ROCR100(close, timeperiod=10)
df['RSI'] = ta.RSI(close, timeperiod=14)
df['SLOWK'], df['SLOWD'] = ta.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
df['FASTK'], df['FASTD'] = ta.STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
df['FASTK2'], df['FASTD2'] = ta.STOCHRSI(close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
df['TRIX'] = ta.TRIX(close, timeperiod=30)
df['ULTOSC'] = ta.ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
df['WILLR'] = ta.WILLR(high, low, close, timeperiod=14)
def buildTAindicators(stock_df):
stock_df['REDORGREEN'] = stock_df.loc[:, 'Open'].subtract(
stock_df.loc[:, 'Close']).apply(lambda x: 1 if x > 0 else 0).values
stock_df['CANDLE_HEIGHT'] = stock_df.loc[:, 'Open'].subtract(
stock_df.loc[:, 'Close']).values
stock_df['NATR'] = ta.NATR(stock_df.loc[:, 'High'].values,
stock_df.loc[:, 'Low'].values,
stock_df.loc[:, 'Close'].values, 5)
close = stock_df.loc[:, 'Close'].values
high = stock_df.loc[:, 'High'].values
low = stock_df.loc[:, 'Low'].values
volume = pd.Series.astype(stock_df.loc[:, 'Volume'], dtype='double').values
adx = ta.ADX(high, low, close, timeperiod=14)
macd, macdsignal, macdhist = ta.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
mfi = ta.MFI(high, low, close, volume, timeperiod=14)
rsi = ta.RSI(close, timeperiod=14)
beta = ta.BETA(high, low, timeperiod=5)
stock_df['ADX'] = pd.Series(adx).values
stock_df['MFI'] = pd.Series(mfi).values
stock_df['RSI'] = pd.Series(rsi).values
stock_df['MACD'] = pd.Series(macd).values
stock_df['BETA'] = pd.Series(beta).values
stock_df = stock_df.iloc[33:, :]
return stock_df
def rebalance(context, data):
# 获取过去7天的收盘价
history = data.history(assets=context.asset,
fields=['close', 'high', 'low'],
bar_count=context.adx_window * 2,
frequency='1d')
date = history.index.values[-1]
high = history['high'].values
low = history['low'].values
close = history['close'].values
adx = ta.ADX(high, low, close, timeperiod=context.adx_window)
record(price=data.current(symbol('IBM'), 'close'),
adx=adx[-1])
buy_signal_triggered = False
sell_signal_triggered = False
if adx[-1] > context.adx_buy_line:
buy_signal_triggered = True
elif adx[-1] < context.adx_sell_line:
sell_signal_triggered = True
current_position = context.portfolio.positions[context.asset].amount
if buy_signal_triggered and current_position == 0:
print(str(date) + '==>买入')
order_target_percent(context.asset, 0.5)
elif sell_signal_triggered and current_position > 0:
print(str(date) + '==>卖出')
order_target_percent(context.asset, 0.0)
else:
print(str(date) + '==>无交易')
def get_stock_data(ticker, start_date, end_date):
print(end_date, type(ticker))
data = nse.get_history(symbol=ticker, start=start_date,
end= end_date)
#data = nse.get_history(symbol= ticker, start=start_date, end= end_date)
data = data.drop(['Prev Close','Symbol', 'Series', 'Deliverable Volume', '%Deliverble', 'Trades', 'Last'], axis = 1)
close = data['Close'].values
high = data['High'].values
low = data['Low'].values
#Computing technical indicators
data['upB'], data['midB'], data['lowB'] = talib.BBANDS(close, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0)
data['RSI'] = talib.RSI(close, timeperiod=10)
data['K'], d = talib.STOCH(high, low, close, fastk_period=14, slowk_period=14, slowk_matype=0, slowd_period=3,
slowd_matype=0)
macd, macdsignal, data['MACD'] = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
data['EMA'] = talib.EMA(close, timeperiod=30)
data['ADX'] = talib.ADX(high, low, close, timeperiod=14)
data['AroonUp'], data['AroonDown'] = talib.AROON(high, low, timeperiod=14)
data['diff'] = data['High'] - data['Low']
data = data.dropna()
#saving as a csv file
data.to_csv('stock_prices' + str(ticker) + '.csv', index=False)
def get_features(data):
tech_data = pd.DataFrame(index=data.index);
for t in periods_list:
tech_data[f'SMA_{t}'] = talib.SMA(data.close,timeperiod=t)
tech_data[f'MOM_{t}'] = talib.MOM(data.close, timeperiod=t)
tech_data[f'RSI_{t}'] = talib.RSI(data.close, timeperiod=t)
tech_data[f'MA_{t}'] = talib.MA(data.close, timeperiod=t)
tech_data[f'DX_{t}'] = talib.DX(data.high, data.low, data.close, timeperiod=t)
tech_data[f'volume_change_{t}'] = data.volume.pct_change(periods=t)
tech_data[f'volatility_{t}'] = data.close.pct_change(periods=t).std()
tech_data[f'ADX_{t}'] = talib.ADX(data.high, data.low, data.close, timeperiod=t)
tech_data[f'ADXR_{t}'] = talib.ADXR(data.high, data.low, data.close, timeperiod=t)
tech_data[f'AROONOSC_{t}'] = talib.AROONOSC(data.high, data.low, timeperiod=t)
tech_data[f'ROC_{t}'] = talib.ROC(data.close, timeperiod=t)
tech_data[f'BIAS_{t}'] = (data['close'] - data['close'].rolling(t, min_periods=1).mean())/ data['close'].rolling(t, min_periods=1).mean()*100
tech_data[f'BOLL_upper_{t}'], tech_data[f'BOLL_middle_{t}'], tech_data[f'BOLL_lower_{t}'] = talib.BBANDS(
data.close,
timeperiod=t,
nbdevup=2,
nbdevdn=2,
matype=0)
tech_data['SAR'] = talib.SAR(data.high, data.low)
tech_data['AD'] = talib.AD(data.high, data.low, data.close, data.volume)
tech_data['OBV'] = talib.OBV(data.close, data.volume)
tech_data['target'] = data.close.pct_change().shift(-1).apply(lambda x: 1 if x > 0 else -1).fillna(0)
tech_data['time'] = data.time
tech_data = tech_data.set_index('time')
reduce(lambda x, y: cross_over(x, y, tech_data), periods_list)
features = list(set(tech_data.columns) - set(data.columns) - set(['target']))
return tech_data.dropna(), features
def ADX5_AROON(self, df):
adx5_exLevel = 95
adx5_brLevel = 10
df.drop(df.last_valid_index(), axis=0, inplace=True)
df['PLUS_DI'] = talib.PLUS_DI(df['High'].values, df['Low'].values, df['Close'].values, timeperiod=5)
df['MINUS_DI'] = talib.MINUS_DI(df['High'].values, df['Low'].values, df['Close'].values, timeperiod=5)
df['ADX5'] = talib.ADX(df['High'].values, df['Low'].values, df['Close'].values, timeperiod=5)
df['ARDN'], df['ARUP'] = talib.AROON(df['High'].values, df['Low'].values, timeperiod=10)
df['ADX5SHIFTED'] = df['ADX5'].shift(1)
df['ARDNSHIFTED'] = df['ARDN'].shift(1)
df['ARUPSHIFTED'] = df['ARUP'].shift(1)
columns = ['PLUS_DI', 'MINUS_DI', 'ADX5', 'AROONDN', 'AROONUP', 'ADX5SHIFTED', 'ARDNSHIFTED', 'ARUPSHIFTED']
def adx5_aroon_cond(row, columns):
df1_adx5_cond = (row['ADX5'] > row['ADX5SHIFTED']) & (row['ADX5'] > adx5_brLevel) & (
row['ADX5'] < adx5_exLevel)
arbuy = (row['ARUPSHIFTED'] < 5) & (row['ARUP'] > 85) & (row['ARUP'] > row['ARDN'])
arsell = (row['ARDNSHIFTED'] < 5) & (row['ARDN'] > 85) & (row['ARUP'] < row['ARDN'])
buy = (row['PLUS_DI'] > row['MINUS_DI']) & df1_adx5_cond & arbuy
sell = (row['PLUS_DI'] < row['MINUS_DI']) & df1_adx5_cond & arsell
return buy, sell
df['BUY'], df['SELL'] = zip(*df.apply(lambda row: adx5_aroon_cond(row, columns), axis=1))
df2 = df.tail(self.withinBars)
df2['BUY'].any()
df2['SELL'].any()
#return [df['SELL'].iloc[-1], df['BUY'].iloc[-1], df['normal_time']]
return [df2['SELL'].any(), df2['BUY'].any(), df['normal_time']]
def technical_indicators_df(self):
o = self.daily_data['Open'].values
c = self.daily_data['Close'].values
h = self.daily_data['High'].values
l = self.daily_data['Low'].values
v = self.daily_data['Volume'].astype(float).values
# define the technical analysis matrix
ta = pd.DataFrame()
ta['MA5'] = tb.MA(c, timeperiod=5)
ta['MA10'] = tb.MA(c, timeperiod=10)
ta['MA20'] = tb.MA(c, timeperiod=20)
ta['MA60'] = tb.MA(c, timeperiod=60)
ta['MA120'] = tb.MA(c, timeperiod=120)
ta['MA5'] = tb.MA(v, timeperiod=5)
ta['MA10'] = tb.MA(v, timeperiod=10)
ta['MA20'] = tb.MA(v, timeperiod=20)
ta['ADX'] = tb.ADX(h, l, c, timeperiod=14)
ta['ADXR'] = tb.ADXR(h, l, c, timeperiod=14)
ta['MACD'] = tb.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0]
ta['RSI'] = tb.RSI(c, timeperiod=14)
ta['BBANDS_U'] = tb.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0]
ta['BBANDS_M'] = tb.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1]
ta['BBANDS_L'] = tb.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2]
ta['AD'] = tb.AD(h, l, c, v)
ta['ATR'] = tb.ATR(h, l, c, timeperiod=14)
ta['HT_DC'] = tb.HT_DCPERIOD(c)
self.ta = ta
def calculate_indicators(data):
close = data['Close'].values
high = data['High'].values
low = data['Low'].values
data['upB'], data['midB'], data['lowB'] = talib.BBANDS(close,
timeperiod=20,
nbdevup=2,
nbdevdn=2,
matype=0)
data['RSI'] = talib.RSI(close, timeperiod=10)
data['K'], d = talib.STOCH(high,
low,
close,
fastk_period=14,
slowk_period=14,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
macd, macdsignal, data['MACD'] = talib.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
data['EMA'] = talib.EMA(close, timeperiod=30)
data['ADX'] = talib.ADX(high, low, close, timeperiod=14)
data['AroonUp'], data['AroonDown'] = talib.AROON(high, low, timeperiod=14)
data['diff'] = data['High'] - data['Low']
return data
def ADX(df, n):
return pd.Series(talib.ADX(df['high'].values,
df['low'].values,
df['close'].values,
timeperiod=n),
index=df.index,
name='ADX_%s' % str(n))
def ADX(data, n=14):
"""
data: original data with open,high,low,close,vol
n: timeperiod
"""
data['adx'] = ta.ADX(
np.array(data.high), np.array(data.low), np.array(data.close),
n) #Average Directional Movement Index (Momentum Indicators)
data['mdi'] = ta.MINUS_DI(np.array(data.high), np.array(data.low),
np.array(data.close), n)
data['pdi'] = ta.PLUS_DI(np.array(data.high), np.array(data.low),
np.array(data.close), n)
signal = pd.DataFrame(index=data.index)
#strategy 1
"""
当+DI上穿-DI，买入，信号为1
当+DI下穿-DI，卖空，信号为-1
"""
signal['1'] = ((data['pdi'] > data['mdi']) &
(data['pdi'].shift(1) < data['mdi'].shift(1))) * 1 + (
(data['pdi'] <= data['mdi']) &
(data['pdi'].shift(1) < data['mdi'].shift(1))) * (-1)
signal['1'] = signal['1'][signal['1'].isin([1,
-1])].reindex(data.index,
method='ffill')
signal = signal.fillna(0)
return signal
def dmi(source, dmi_period, dmi_smooth): minus_name = "MINUS_DI_" + str(dmi_period) + "_" + str(dmi_smooth) plus_name = "PLUS_DI_" + str(dmi_period) + "_" + str(dmi_smooth) adx_name = "ADX_" + str(dmi_period) + "_" + str(dmi_smooth) source = source.join( pd.Series(talib.MINUS_DI(source['High'], source['Low'], source['Close'], timeperiod=dmi_period), name=minus_name)) source = source.join(pd.Series(talib.PLUS_DI(source['High'], source['Low'], source['Close'], timeperiod=dmi_period), name=plus_name)) source = source.join(pd.Series(talib.ADX(source['High'], source['Low'], source['Close'], timeperiod=dmi_smooth), name=adx_name)) # Trends source = do_uptrend(source, adx_name) source = do_uptrend(source, plus_name) source = do_uptrend(source, minus_name) # Overs source = do_over(source, adx_name, plus_name) source = do_over(source, adx_name, minus_name) source = do_over(source, plus_name, minus_name) # Aboves for level in range(5, 65, 5): source = do_above(source, adx_name, level) source = do_above(source, plus_name, level) source = do_above(source, minus_name, level) source = source.drop(columns=[adx_name, plus_name, minus_name]) return source
def get(self, df):
h, l, c = df['h'], df['l'], df['c']
adx = talib.ADX(h, l, c, timeperiod=self.time_period)
plus_di = talib.PLUS_DI(h, l, c, timeperiod=self.time_period)
minus_di = talib.MINUS_DI(h, l, c, timeperiod=self.time_period)
last_adx, last_plus_di, last_minus_di = adx.iloc[-1], plus_di.iloc[-1], minus_di.iloc[-1]
material = dict(adx=adx, plus_di=plus_di, minus_di=minus_di)
if last_adx > self.trend_threshold:
if last_plus_di > last_minus_di:
indicator_value = IndicatorValue(ADXIndicatorSign.TREND_PLUS.name, material=material)
else:
indicator_value = IndicatorValue(ADXIndicatorSign.TREND_MINUS.name, material=material)
else:
if last_plus_di > last_minus_di:
indicator_value = IndicatorValue(ADXIndicatorSign.NO_TREND_PLUS.name, material=material)
else:
indicator_value = IndicatorValue(ADXIndicatorSign.NO_TREND_MINUS.name, material=material)
if not self.is_test:
logging.info('sign=>%s ADX=>%s +DI=>%s -DI=>%s', indicator_value.value, last_adx, last_plus_di,
last_minus_di)
return indicator_value
def run_indicators(symbol, file):
try:
if os.path.exists(file):
# read file
df = np.genfromtxt(file, delimiter=',')
# run talib indicators using dataframe
# create additional columns in the datafarame
closePrice = df[:, 4]
openPrice = df[:, 1]
highPrice = df[:, 2]
lowPrice = df[:, 3]
volume = df[:, 5]
sma = talib.SMA(closePrice)
atr = talib.ATR(highPrice, lowPrice, closePrice)
natr = talib.NATR(highPrice, lowPrice, closePrice)
adx = talib.ADX(highPrice, lowPrice, closePrice)
mfi = talib.MFI(highPrice, lowPrice, closePrice, volume)
ppo = talib.PPO(closePrice, fastperiod=12, slowperiod=26, matype=0)
rsi = talib.RSI(closePrice)
slowk, slowd = talib.STOCH(highPrice,
lowPrice,
closePrice,
fastk_period=14,
slowk_period=3,
slowd_period=3)
macd, macdsignal, macdhist = talib.MACD(closePrice,
fastperiod=12,
slowperiod=26,
signalperiod=9)
# get ticker current price
client = Client(os.environ.get('BINANCE_API_KEY'),
os.environ.get('BINANCE_SECRET_KEY'),
{"timeout": 100})
closing_price = client.get_symbol_ticker(symbol=symbol)
# create crypto object
crypto = {}
crypto['ticker'] = symbol
crypto['price'] = closing_price['price']
crypto['SMA14'] = sma[-1]
crypto['ATR'] = atr[-1]
crypto['NATR'] = natr[-1]
crypto['ADX'] = adx[-1]
crypto['MFI'] = mfi[-1]
crypto['RSI'] = rsi[-1]
crypto['STO'] = slowk[-1], slowd[-1]
crypto['MACD'] = macd[-1]
crypto['PPO'] = ppo[-1]
else:
crypto = {}
crypto['ticker'] = symbol
return crypto
except Exception as e:
print(str(e))
def add_feature_analysis(df):
df['MA5'] = df['종가'].rolling(window=5).mean()
df['MA20'] = df['종가'].rolling(window=20).mean()
df['MADiff'] = df['MA5'] - df['MA20']
df['MA60'] = df['종가'].rolling(window=60).mean()
# Stochastic_slow_k, Stochastic_slow_d (12,3,3) 모멘텀지표 (상하한)
df['SlowK'], df['SlowD'] = ta.STOCH(np.array(df['고가'].astype(float)),
np.array(df['저가'].astype(float)),
np.array(df['종가'].astype(float)),
fastk_period=12,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
# MACD_12_26 , sign, diff 추세지표
df['MACD'], df['MACDsign'], df['MACDhist'] = ta.MACD(np.array(
df['종가'].astype(float)),
fastperiod=12,
slowperiod=26,
signalperiod=9)
# RSI_14 모멘텀지표 (상하한)
df['RSI14'] = ta.RSI(np.array(df['종가'].astype(float)), timeperiod=14)
#df['전일RSI']= df['RSI'].shift(1)
# Williams_percent_r_14 모멘텀지표 (상하한)
df['WILR14'] = ta.WILLR(np.array(df['고가'].astype(float)),
np.array(df['저가'].astype(float)),
np.array(df['종가'].astype(float)))
df['DEMA20'] = ta.DEMA(np.array(df['종가'].astype(float)), timeperiod=20)
df['ADX'] = ta.ADX(np.array(df['고가'].astype(float)),
np.array(df['저가'].astype(float)),
np.array(df['종가'].astype(float)),
timeperiod=14)
df['CCI'] = ta.CCI(np.array(df['고가'].astype(float)),
np.array(df['저가'].astype(float)),
np.array(df['종가'].astype(float)),
timeperiod=14)
df['ATR'] = ta.ATR(np.array(df['고가'].astype(float)),
np.array(df['저가'].astype(float)),
np.array(df['종가'].astype(float)),
timeperiod=14)
df['ROC'] = ta.ROC(np.array(df['종가'].astype(float)), timeperiod=10)
df['OBV'] = ta.OBV(np.array(df['종가'].astype(float)),
np.array(df['거래량'].astype(float)))
df.dropna(inplace=True) # 결측값 삭제
df.set_index('날짜', inplace=True) # 날짜를 index로 만든다.
return df
def dmi(self, df, index):
MINUS_DI = talib.MINUS_DI(df.high, df.low, df.close, timeperiod=14)
#DX = talib.DX(df.high,df.low,df.close,timeperiod=14)
PLUS_DI = talib.PLUS_DI(df.high, df.low, df.close, timeperiod=14)
#PLUS_DM = talib.PLUS_DM(df.high,df.low, timeperiod=14)
ADX = talib.ADX(df.high, df.low, df.close, timeperiod=6)
ADXR = talib.ADXR(df.high, df.low, df.close, timeperiod=6)
return MINUS_DI, PLUS_DI, ADX, ADXR
def getCustomData(df):
open = df['Open']
high = df['High']
low = df['Low']
close = df['Close']
volume = df['Volume']
df['TRENDMODE'] = ta.HT_TRENDMODE(close)
df['RSI'] = ta.RSI(close,timeperiod=14)
df['RSI2'] = ta.RSI(close,timeperiod=7)
df['RSI3'] = ta.RSI(close,timeperiod=28)
df['ADX1'] = ta.ADX(high,low,close,timeperiod=7)
df['ADX2'] = ta.ADX(high,low,close,timeperiod=28)
df['ADX'] = ta.ADX(high,low,close,timeperiod=14)
df['SLOWK'], df['SLOWD'] = ta.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
df['FASTK'], df['FASTD'] = ta.STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
df['ULTOSC'] = ta.ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
df['WILLR'] = ta.WILLR(high, low, close, timeperiod=14)
def adx(self, n: int, array: bool = False) -> Union[float, np.ndarray]:
"""
ADX.
"""
result = talib.ADX(self.high, self.low, self.close, n)
if array:
return result
return result[-1]
def adx(self, n, array=False):
"""
ADX.
"""
result = talib.ADX(self.high, self.low, self.close, n)
if array:
return result
return result[-1]
def add_adx_ft(df, daily_count, count):
for idx in range(1, count + 1):
col_name = 'ADX_' + str(idx)
df[col_name] = talib.ADX(df.high,
df.low,
df.close,
timeperiod=daily_count * idx)
return df
def AddADX(df, indicator_list, askbidmid, timeperiod=14):
df['adx'] = talib.ADX(df['{}_h'.format(askbidmid)].values,
df['{}_l'.format(askbidmid)].values,
df['{}_c'.format(askbidmid)].values,
timeperiod=timeperiod)
indicator_list.extend(['adx'])
return df, indicator_list
def IND_ADX(high, low, close, number):
t_high = numpy.array(high.getRawData())
t_low = numpy.array(low.getRawData())
t_close = numpy.array(close.getRawData())
adx = talib.ADX(t_high, t_low, t_close, number)
return adx
def etf_should_buy(li,l2):
for i in range(len(li)):
h = ts.pro_bar(li[i],asset="FD",start_date="20200101",end_date=get_now_time(),ma=[5,10]).iloc[::-1]
n = h.shape[0]
if n > 33:
# ----------- 获取kdj值 ---------------#
slowk, slowd = tb.STOCH(h['high'].values,
h['low'].values,
h['close'].values,
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
slowj = 3 * slowk - 2 * slowd
# ------------- 获取ma5 ma10 --------------- #
ma5 = h["ma5"].tolist()
ma10 = h["ma10"].tolist()
# -------------- 获取macd值 ----------------- #
macd,signal,hist = tb.MACD(h["close"].values, 12, 26, 9)
# -------------- 获取adx值 ----------------- #
adx = tb.ADX(h["high"].values,
h["low"].values,
h["close"].values,
timeperiod=14)
# -------------- 获取当前价格 ----------------- #
price = h["close"].tolist()
# ---------------- 格式化数据 ---------------------#
slowj[-1] = round(slowj[-1],3)
ma5[-1] = round(ma5[-1], 3)
ma10[-1] = round(ma10[-1],3)
macd[-1] = round(macd[-1],3)
adx[-1] = round(adx[-1],3)
if slowj[-1] > slowk[-1] > slowd[-1] and \
macd[-2] < macd[-1]:
if price[-1] < 10:
print(li[i],if_price_increase(price),if_ma5_big_ma10(ma5,ma10),if_macd_increase(macd),if_slowj_big_slowkd(slowj,slowk,slowd))
# 56#符合特征的
# if slowj[n-2] < 20 < slowj[n-1] and slowj[n-1] > slowk[n-1] > slowd[n-1]:
# print(li[i],"BUY++",get_now_time())
# if slowj[n-2] > 80 > slowj[n-1] and slowj[n-1] < slowk[n-1] < slowd[n-1] and slowj[n-2] > slowk[n-2] > slowd[n-2]:
# print(li[i],"SELL--",get_now_time())
#
# if slowj[n-1] > 80 > slowj[n - 2] and slowj[n-1] > slowk[n-1] > slowd[n-1] and slowj[n-2] < slowk[n-2] > slowd[n-2]:
# print(li[i],"BUY+",get_now_time())
#
# if 50 > slowj[n-1] and slowj[n-1] < slowk[n-1] < slowd[n-1] and slowj[n-2] > slowk[n-2] > slowd[n-2]:
# print(li[i], "SELL--",get_now_time())
time.sleep(0.2)
def create_technical_indicators(df, indicators=['MA_4'], only_close_colum=False):
if only_close_colum:
if isinstance(df, pd.DataFrame):
close = np.array(df['Close']).reshape(len(df), )
else:
if isinstance(df, pd.DataFrame):
close = np.array(df['Close']).reshape(len(df), )
# OPEN = np.array(df['Open']).reshape(len(df), )
high = np.array(df['High']).reshape(len(df), )
low = np.array(df['Low']).reshape(len(df), )
df_2_return = pd.DataFrame()
for indicator in indicators:
if indicator is None:
pass
else:
if indicator.split('_')[0].strip() == 'MA':
smavg = talib.MA(close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = smavg
if indicator.split('_')[0].strip() == 'BBANDS':
upperband, middleband, lowerband = talib.BBANDS(close, timeperiod=int(indicator.split('_')[1]))
df_2_return['lowerband'] = lowerband
df_2_return[indicator] = middleband
df_2_return['upperband'] = upperband
if indicator.split('_')[0].strip() == 'MACD':
indicator = indicator + '_12' + '_26' + '_9'
_, macdsignal, macdhist = talib.MACD(close,
fastperiod=int(indicator.split('_')[1]),
slowperiod=int(indicator.split('_')[2]),
signalperiod=int(indicator.split('_')[3]))
df_2_return['macdsignal'] = macdsignal
df_2_return['macdhist'] = macdhist
if indicator.split('_')[0].strip() == 'RSI':
real_RSI = talib.RSI(close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = real_RSI
if indicator.split('_')[0].strip() == 'CMO':
real_CMO = talib.CMO(close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = real_CMO
if indicator.split('_')[0].strip() == 'ADX':
if only_close_colum:
pass
else:
real_ADX = talib.ADX(high, low, close, timeperiod=int(indicator.split('_')[1]))
df_2_return[indicator] = real_ADX
if indicator.split('_')[0].strip() == 'STOCH':
if only_close_colum:
pass
else:
slowk, slowd = talib.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
df_2_return[indicator] = slowd - slowk
return(df_2_return)
def ADX(self, timeperiod=14):
real_data = np.array([self.df.high, self.df.low, self.df.close], dtype='f8')
adx = talib.ADX(real_data[0], real_data[1], real_data[2], timeperiod=timeperiod)
# return go.Scatter(
# x=self.df.index,
# y=adx,
# name='ADX'
# )
return adx
