def init(self, base_data):
base_data = base_data.sort_values("date")
kd = StochasticOscillator(
high=base_data["max"],
low=base_data["min"],
close=base_data["close"],
n=self.kdays,
)
rsv_ = kd.stoch().fillna(50)
_k = np.zeros(base_data.shape[0])
_d = np.zeros(base_data.shape[0])
for i, r in enumerate(rsv_):
if i == 0:
_k[i] = 50
_d[i] = 50
else:
_k[i] = _k[i - 1] * 2 / 3 + r / 3
_d[i] = _d[i - 1] * 2 / 3 + _k[i] / 3
base_data["K"] = _k
base_data["D"] = _d
base_data.index = range(len(base_data))
base_data["signal"] = 0
base_data.loc[base_data["K"] <= self.kd_lower, "signal"] = 1
base_data.loc[base_data["K"] >= self.kd_upper, "signal"] = -1
return base_data
def create_trade_sign(self, stock_price: pd.DataFrame) -> pd.DataFrame:
stock_price = stock_price.sort_values("date")
kd = StochasticOscillator(
high=stock_price["max"],
low=stock_price["min"],
close=stock_price["close"],
n=self.kdays,
)
rsv_ = kd.stoch().fillna(50)
_k = np.zeros(stock_price.shape[0])
_d = np.zeros(stock_price.shape[0])
for i, r in enumerate(rsv_):
if i == 0:
_k[i] = 50
_d[i] = 50
else:
_k[i] = _k[i - 1] * 2 / 3 + r / 3
_d[i] = _d[i - 1] * 2 / 3 + _k[i] / 3
stock_price["K"] = _k
stock_price["D"] = _d
stock_price.index = range(len(stock_price))
stock_price["signal"] = 0
stock_price.loc[stock_price["K"] <= self.kd_lower, "signal"] = 1
stock_price.loc[stock_price["K"] >= self.kd_upper, "signal"] = -1
return stock_price
def get_indicators(df):
"""
Add set of technical indicators to the dataframe, return original data frame with new features
"""
feature_df = df.copy()
feature_df['RSI'] = RSIIndicator(close=df[CLOSE]).rsi()
feature_df['Stochastic'] = StochasticOscillator(high=df[HIGH],
low=df[LOW],
close=df[CLOSE]).stoch()
feature_df['Stochastic_signal'] = StochasticOscillator(
high=df[HIGH], low=df[LOW], close=df[CLOSE]).stoch_signal()
feature_df['ADI'] = AccDistIndexIndicator(
high=df[HIGH], low=df[LOW], close=df[CLOSE],
volume=df[VOLUME]).acc_dist_index()
feature_df['OBV'] = OnBalanceVolumeIndicator(
close=df[CLOSE], volume=df[VOLUME]).on_balance_volume()
feature_df['ATR'] = AverageTrueRange(high=df[HIGH],
low=df[LOW],
close=df[CLOSE]).average_true_range()
feature_df['ADX'] = ADXIndicator(high=df[HIGH],
low=df[LOW],
close=df[CLOSE]).adx()
feature_df['ADX_pos'] = ADXIndicator(high=df[HIGH],
low=df[LOW],
close=df[CLOSE]).adx_pos()
feature_df['ADX_neg'] = ADXIndicator(high=df[HIGH],
low=df[LOW],
close=df[CLOSE]).adx_neg()
feature_df['MACD'] = MACD(close=df[CLOSE]).macd()
feature_df['MACD_diff'] = MACD(close=df[CLOSE]).macd_diff()
feature_df['MACD_signal'] = MACD(close=df[CLOSE]).macd_signal()
return feature_df
def create_trade_sign(self, stock_price: pd.DataFrame) -> pd.DataFrame:
stock_price = stock_price.sort_values("date")
kd = StochasticOscillator(
high=stock_price["max"],
low=stock_price["min"],
close=stock_price["close"],
n=self.k_days,
)
rsv_ = kd.stoch().fillna(50)
_k = np.zeros(stock_price.shape[0])
_d = np.zeros(stock_price.shape[0])
for i, r in enumerate(rsv_):
if i == 0:
_k[i] = 50
_d[i] = 50
else:
_k[i] = _k[i - 1] * 2 / 3 + r / 3
_d[i] = _d[i - 1] * 2 / 3 + _k[i] / 3
stock_price["K"] = _k
stock_price["D"] = _d
stock_price.index = range(len(stock_price))
stock_price["diff"] = stock_price["K"] - stock_price["D"]
stock_price.loc[(stock_price.index < self.k_days), "diff"] = np.nan
stock_price["diff_sign"] = stock_price["diff"].map(
lambda x: 1 if x >= 0 else (-1 if x < 0 else 0))
stock_price["diff_sign_yesterday"] = (
stock_price["diff_sign"].shift(1).fillna(0).astype(int))
stock_price["signal"] = 0
stock_price.loc[((stock_price["diff_sign"] > 0)
& (stock_price["diff_sign_yesterday"] < 0)),
"signal", ] = 1
stock_price.loc[((stock_price["diff_sign"] < 0)
& (stock_price["diff_sign_yesterday"] > 0)),
"signal", ] = -1
return stock_price
def calc(self, dataframe):
stoch = StochasticOscillator(close=dataframe.close,
low=dataframe.low,
high=dataframe.high,
n=self.params.get("period"),
d_n=self.params.get("d_period"))
dataframe["{}_k".format(self.col_name())] = stoch.stoch()
return dataframe
def create_trade_sign(self, stock_price: pd.DataFrame) -> pd.DataFrame:
stock_price = stock_price.sort_values("date")
kd = StochasticOscillator(
high=stock_price["max"],
low=stock_price["min"],
close=stock_price["close"],
n=self.kdays,
d_n=self.ddays,
)
stock_price["K"] = kd.stoch()
stock_price["D"] = kd.stoch_signal()
stock_price.index = range(len(stock_price))
stock_price["signal"] = 0
stock_price.loc[stock_price["K"] <= self.kd_lower, "signal"] = 1
stock_price.loc[stock_price["K"] >= self.kd_upper, "signal"] = -1
return stock_price
def analyze(self):
stochastic_df = StochasticOscillator(self.df.high,
self.df.low,
self.df.close,
n=5)
self.df["stoch_k"] = stochastic_df.stoch()
self.df["stoch_d"] = stochastic_df.stoch_signal()
self.df["high_close"] = ((self.df.high - self.df.close) /
(self.df.high + self.df.close / 2) * 100)
self.df["buy_signal"] = (
((self.df['stoch_k'] > self.df['stoch_d']) &
(self.df['stoch_k'].shift(1) < self.df['stoch_d'].shift(1))) &
(self.df['stoch_d'] < 26))
self.df["stoch_buy_signal_early"] = (
(self.df['stoch_k'] < self.df['stoch_d']) &
((self.df["stoch_d"]) - self.df["stoch_k"] < 3) &
(self.df['stoch_d'] < 26))
def setUpClass(cls):
cls._df = pd.read_csv(cls._filename, sep=',')
cls._params = dict(high=cls._df['High'],
low=cls._df['Low'],
close=cls._df['Close'],
n=14,
d_n=3,
fillna=False)
cls._indicator = StochasticOscillator(**cls._params)
def init(self, base_data):
base_data = base_data.sort_values("date")
kd = StochasticOscillator(
high=base_data["max"],
low=base_data["min"],
close=base_data["close"],
n=self.kdays,
d_n=self.ddays,
)
base_data["K"] = kd.stoch()
base_data["D"] = kd.stoch_signal()
base_data.index = range(len(base_data))
base_data["signal"] = 0
base_data.loc[base_data["K"] <= self.kd_lower, "signal"] = 1
base_data.loc[base_data["K"] >= self.kd_upper, "signal"] = -1
return base_data
def setUpClass(cls):
cls._df = pd.read_csv(cls._filename, sep=",")
cls._params = dict(
high=cls._df["High"],
low=cls._df["Low"],
close=cls._df["Close"],
window=14,
smooth_window=3,
fillna=False,
)
cls._indicator = StochasticOscillator(**cls._params)
def init(self, base_data):
base_data = base_data.sort_values("date")
kd = StochasticOscillator(
high=base_data["max"],
low=base_data["min"],
close=base_data["close"],
n=self.kdays,
)
rsv_ = kd.stoch().fillna(50)
_k = np.zeros(base_data.shape[0])
_d = np.zeros(base_data.shape[0])
for i, r in enumerate(rsv_):
if i == 0:
_k[i] = 50
_d[i] = 50
else:
_k[i] = _k[i - 1] * 2 / 3 + r / 3
_d[i] = _d[i - 1] * 2 / 3 + _k[i] / 3
base_data["K"] = _k
base_data["D"] = _d
base_data.index = range(len(base_data))
base_data["diff"] = base_data["K"] - base_data["D"]
base_data.loc[(base_data.index < self.kdays), "diff"] = np.nan
base_data["bool_diff"] = base_data["diff"].map(
lambda x: 1 if x >= 0 else (-1 if x < 0 else 0))
base_data["bool_diff_shift1"] = (
base_data["bool_diff"].shift(1).fillna(0).astype(int))
base_data["signal"] = 0
base_data.loc[((base_data["bool_diff"] > 0)
& (base_data["bool_diff_shift1"] < 0)), "signal", ] = 1
base_data.loc[((base_data["bool_diff"] < 0)
& (base_data["bool_diff_shift1"] > 0)), "signal", ] = -1
return base_data
def add_momentum_indicators(data: pd.DataFrame) -> pd.DataFrame:
"""Adds the momentum indicators.
Parameters
----------
data : pd.DataFrame
A dataframe with daily stock values. Must include: open, high,
low, close and volume. It should also be sorted in a descending
manner.
Returns
-------
pd.DataFrame
The input dataframe with the indicators added.
"""
rsi = RSIIndicator(data['close'])
stoch_osc = StochasticOscillator(data['high'], data['low'], data['close'])
data.loc[:, 'rsi'] = rsi.rsi()
data.loc[:, 'stoch_osc'] = stoch_osc.stoch()
data.loc[:, 'stoch_osc_signal'] = stoch_osc.stoch_signal()
return data
class TestStochasticOscillator(unittest.TestCase):
"""
https://school.stockcharts.com/doku.php?id=technical_indicators:stochastic_oscillator_fast_slow_and_full
"""
_filename = 'ta/tests/data/cs-soo.csv'
def setUp(self):
self._df = pd.read_csv(self._filename, sep=',')
self._indicator = StochasticOscillator(
high=self._df['High'], low=self._df['Low'], close=self._df['Close'], n=14, d_n=3, fillna=False)
def tearDown(self):
del(self._df)
def test_so(self):
target = 'SO'
result = self._indicator.stoch()
pd.testing.assert_series_equal(self._df[target].tail(), result.tail(), check_names=False)
def test_so_signal(self):
target = 'SO_SIG'
result = self._indicator.stoch_signal()
pd.testing.assert_series_equal(self._df[target].tail(), result.tail(), check_names=False)
def add_momentum_ta(
df: pd.DataFrame,
high: str,
low: str,
close: str,
volume: str,
fillna: bool = False,
colprefix: str = "",
vectorized: bool = False,
) -> pd.DataFrame:
"""Add trend technical analysis features to dataframe.
Args:
df (pandas.core.frame.DataFrame): Dataframe base.
high (str): Name of 'high' column.
low (str): Name of 'low' column.
close (str): Name of 'close' column.
volume (str): Name of 'volume' column.
fillna(bool): if True, fill nan values.
colprefix(str): Prefix column names inserted
vectorized(bool): if True, use only vectorized functions indicators
Returns:
pandas.core.frame.DataFrame: Dataframe with new features.
"""
# Relative Strength Index (RSI)
df[f"{colprefix}momentum_rsi"] = RSIIndicator(close=df[close],
window=14,
fillna=fillna).rsi()
# Stoch RSI (StochRSI)
indicator_srsi = StochRSIIndicator(close=df[close],
window=14,
smooth1=3,
smooth2=3,
fillna=fillna)
df[f"{colprefix}momentum_stoch_rsi"] = indicator_srsi.stochrsi()
df[f"{colprefix}momentum_stoch_rsi_k"] = indicator_srsi.stochrsi_k()
df[f"{colprefix}momentum_stoch_rsi_d"] = indicator_srsi.stochrsi_d()
# TSI Indicator
df[f"{colprefix}momentum_tsi"] = TSIIndicator(close=df[close],
window_slow=25,
window_fast=13,
fillna=fillna).tsi()
# Ultimate Oscillator
df[f"{colprefix}momentum_uo"] = UltimateOscillator(
high=df[high],
low=df[low],
close=df[close],
window1=7,
window2=14,
window3=28,
weight1=4.0,
weight2=2.0,
weight3=1.0,
fillna=fillna,
).ultimate_oscillator()
# Stoch Indicator
indicator_so = StochasticOscillator(
high=df[high],
low=df[low],
close=df[close],
window=14,
smooth_window=3,
fillna=fillna,
)
df[f"{colprefix}momentum_stoch"] = indicator_so.stoch()
df[f"{colprefix}momentum_stoch_signal"] = indicator_so.stoch_signal()
# Williams R Indicator
df[f"{colprefix}momentum_wr"] = WilliamsRIndicator(
high=df[high], low=df[low], close=df[close], lbp=14,
fillna=fillna).williams_r()
# Awesome Oscillator
df[f"{colprefix}momentum_ao"] = AwesomeOscillatorIndicator(
high=df[high], low=df[low], window1=5, window2=34,
fillna=fillna).awesome_oscillator()
# Rate Of Change
df[f"{colprefix}momentum_roc"] = ROCIndicator(close=df[close],
window=12,
fillna=fillna).roc()
# Percentage Price Oscillator
indicator_ppo = PercentagePriceOscillator(close=df[close],
window_slow=26,
window_fast=12,
window_sign=9,
fillna=fillna)
df[f"{colprefix}momentum_ppo"] = indicator_ppo.ppo()
df[f"{colprefix}momentum_ppo_signal"] = indicator_ppo.ppo_signal()
df[f"{colprefix}momentum_ppo_hist"] = indicator_ppo.ppo_hist()
# Percentage Volume Oscillator
indicator_pvo = PercentageVolumeOscillator(volume=df[volume],
window_slow=26,
window_fast=12,
window_sign=9,
fillna=fillna)
df[f"{colprefix}momentum_pvo"] = indicator_pvo.pvo()
df[f"{colprefix}momentum_pvo_signal"] = indicator_pvo.pvo_signal()
df[f"{colprefix}momentum_pvo_hist"] = indicator_pvo.pvo_hist()
if not vectorized:
# KAMA
df[f"{colprefix}momentum_kama"] = KAMAIndicator(close=df[close],
window=10,
pow1=2,
pow2=30,
fillna=fillna).kama()
return df
n_fast=12,
n_sign=9,
fillna=False)
MACD_INDICATOR = "MACD_indicator"
# print(indicator)
df[MACD_INDICATOR] = indicator.macd()
df["MACD_SIGNAL_indicator"] = indicator.macd_signal()
# print(df)
"""For Relative Strength: Stochastics (14,7,3)"""
indicator = StochasticOscillator(close=df["close_price"],
high=df["high_price"],
low=df["low_price"],
n=14,
d_n=3,
fillna=False)
#print(indicator)
df["STOCH_indicator"] = indicator.stoch()
df["STOCH_SIGNAL_indicator"] = indicator.stoch_signal()
#print(df)
#print(df.columns)
try:
indicator = ADXIndicator(high=df["high_price"],
low=df["low_price"],
close=df["close_price"],
n=14,
def get_stock_predictions():
start = time.time()
ticker = request.args.get('ticker')
date = -1
np.random.seed(312)
try:
df = stocks[ticker].copy()
df['return'] = df['PRC'].pct_change()
df.drop( columns = ['COMNAM'], inplace = True)
df.set_index('date', inplace=True, drop=True)
df['1_day_return'] = df['return'].shift(-1)
df['1_day_return'] = np.where(df['1_day_return'] > 0, 1, 0)
ewma = pd.Series.ewm
df['Fast_Exp_Moving_Avg'] = df['PRC'].transform(lambda x: ewma(x, span = 12).mean())
df['Slow_Exp_Moving_Avg'] = df['PRC'].transform(lambda x: ewma(x, span = 26).mean())
df['Momentum_Factor'] = df['Fast_Exp_Moving_Avg']/df['Slow_Exp_Moving_Avg']
df['Moving_Avg'] = df['PRC'].transform(lambda x: x.rolling(window=20).mean())
df['Moving_Std_Deviation'] = df['PRC'].transform(lambda x: x.rolling(window=20).std())
df['Ultimate_Oscillator'] = UltimateOscillator(df['ASKHI'], df['BIDLO'], df['PRC'], fillna = True).uo()
df['RSI_Indicator'] = RSIIndicator(df['PRC'], 14, False).rsi()
df['Stochastic_Oscillator'] = StochasticOscillator(df['ASKHI'], df['BIDLO'], df['PRC'], 14, 3, True).stoch()
# print("3")
n_fast = 12
n_slow = 26
df['MACD'] = df['Slow_Exp_Moving_Avg'] - df['Fast_Exp_Moving_Avg']
# Bollinger Bands
df['BollingerB_UP'] = df['Moving_Avg'] + df['Moving_Std_Deviation']*2
df['BollingerB_DOWN'] = df['Moving_Avg'] - df['Moving_Std_Deviation']*2
if stocks_industry.get(ticker) != None:
industry = stocks_industry.get(ticker).lower().replace(" ", "_")
industry_df = pd.read_csv(f'../database/industry_info/{industry}_returns.csv')
industry_df.set_index('date', inplace=True, drop=True)
df['avg_industry_return'] = industry_df['avg_return']
df.dropna(inplace = True)
X = df[df.columns[~df.columns.isin(['1_day_return','TICKER'])]]
y = df.loc[:, '1_day_return']
except:
return jsonify({})
xgb = XGBClassifier(random_state=0, seed = 312)
xgb.fit(X.iloc[:-1], y.iloc[:-1])
predict_for = pd.DataFrame(X.iloc[date]).T
print(predict_for)
# print(xgb.predict(X))
answer = xgb.predict_proba(predict_for)[0]
prediction = xgb.predict(predict_for)[0]
confidence = max(answer) * 100
feature_scores = xgb._Booster.get_score()
descriptors = {'OPENPRC': 'The open price',
'SHROUT': 'The number of shares outstanding',
'Moving_Avg': 'The average price of the stock over a rolling window of 20 days',
'Ultimate_Oscillator': 'Larry Williams’ (1976) signal, a momentum oscillator designed to capture momentum across three different timeframes.',
'VOL': 'The volume traded today',
'Stochastic_Oscillator': 'Developed in the late 1950s by George Lane. The stochastic oscillator presents the location of the closing price of a stock in relation to the high and low range of the price of a stock over a period of time, typically a 14-day period.',
'BIDLO': 'The lowest bid price today',
'ASKHI': 'The highest asking price today',
'Slow_Exp_Moving_Avg': 'This is a first-order infinite impulse response filter that applies weighting factors which decrease exponentially. Basically, a fancy moving average.',
'return': 'The return of the stock today, i.e. perentage change from the price yesterday to the price today',
'RSI_Indicator': 'Compares the magnitude of recent gains and losses over a specified time period to measure speed and change of price movements of a security. It is primarily used to attempt to identify overbought or oversold conditions in the trading of an asset.',
'BollingerB_DOWN': 'Developed by John Bollinger, Bollinger Bands® are volatility bands placed above and below a moving average. Volatility is based on the standard deviation, which changes as volatility increases and decreases',
'BollingerB_UP': 'Developed by John Bollinger, Bollinger Bands® are volatility bands placed above and below a moving average. Volatility is based on the standard deviation, which changes as volatility increases and decreases',
'Momentum_Factor': 'Simple Momentum of the stock',
'PRC': 'The closing price of the stock',
'MACD': 'A trend-following momentum indicator that shows the relationship between two moving averages of prices. The MACD is calculated by subtracting the 26-day exponential moving average (EMA) from the 12-day EMA',
'Fast_Exp_Moving_Avg': 'This is a first-order infinite impulse response filter that applies weighting factors which decrease exponentially. Basically, a fancy moving average.',
'avg_industry_return': 'The Average returns of the industry the stock is a part of.',
'Moving_Std_Deviation': 'The standard deviation over a period of 20-days'
}
links = {'OPENPRC': '',
'SHROUT': '',
'Moving_Avg': 'https://en.wikipedia.org/wiki/Moving_average',
'Ultimate_Oscillator': 'http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:ultimate_oscillator',
'VOL': '',
'Stochastic_Oscillator': 'https://school.stockcharts.com/doku.php?id=technical_indicators:stochastic_oscillator_fast_slow_and_full',
'BIDLO': '',
'ASKHI': '',
'Slow_Exp_Moving_Avg': 'https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average',
'return': '',
'RSI_Indicator': 'https://www.investopedia.com/terms/r/rsi.asp',
'BollingerB_DOWN': 'https://school.stockcharts.com/doku.php?id=technical_indicators:bollinger_bands',
'BollingerB_UP': 'https://school.stockcharts.com/doku.php?id=technical_indicators:bollinger_bands',
'Momentum_Factor': 'https://school.stockcharts.com/doku.php?id=technical_indicators:rate_of_change_roc_and_momentum',
'PRC': '',
'MACD': 'https://www.investopedia.com/terms/m/macd.asp',
'Fast_Exp_Moving_Avg': 'https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average',
'avg_industry_return': '',
'Moving_Std_Deviation': 'https://en.wikipedia.org/wiki/Moving_average'
}
classes = ['High', 'High', 'High', 'Medium', 'Medium', 'Medium', 'Medium', 'Medium', 'Low', 'Low', 'Low', 'Low', 'Low', 'Low', 'Almost None', 'Almost None', 'Almost None', 'Almost None', 'Almost None', 'Almost None']
scores = [[feature, weight]for feature, weight in feature_scores.items()]
scores.sort(key = lambda x: x[1], reverse = True)
for i, score in enumerate(scores):
feature = score[0]
score[1] = str(score[1])
score.append(classes[i])
score.append(descriptors[feature])
score.append(links[feature])
results = {
'prediction' : str(prediction),
'confidence' : str(confidence),
'feature_importance': feature_scores,
'descriptions' : scores
}
end = time.time()
print(end - start)
return jsonify(results)
def STOCHASTIC(self, df):
df_STOCH = df.copy()
stoch = StochasticOscillator(df['High'], df['Low'], df['Close'])
df['%K'] = stoch.stoch()
df['%D'] = stoch.stoch_signal()
return df
iloc is primarily integer position based (from 0 to length-1 of the axis), but may also be used with a boolean array.
'''
period = 30
df['SMA_Close'] = talib.SMA(df["Close"], timeperiod=period)
print('Time #1 batch TI: ' + str(time.time() - start_time) + ' seconds')
start_time = time.time()
# Stochastic Oscillator (SO)
period = 14
sma_period = 3
StochasticOscillator = ta.momentum.StochasticOscillator(high=df["High"],
low=df["Low"],
close=df["Close"],
n=period,
d_n=sma_period,
fillna=False)
df['SO'] = StochasticOscillator.stoch()
# Momentum (M)
period = 3
df['Momentum'] = talib.MOM(df["Close"], timeperiod=period)
# Price Rate Of Change (ROC)
'''
Description:
is a pure momentum oscillator that measures the percent change in price from one period to the next
The ROC calculation compares the current price with the price “n” periods ago
'''
period = 12
RateOfChange = ta.momentum.ROCIndicator(close=df["Close"],
n=period,
fillna=False)
def ta(self):
self.df = self.data
# print(self.df)
# dfh = self.datah
# CCI Indicator
# low
try:
self.avoid = False
difff = float(self.df.tail(1)["high"]) - float(
self.df.tail(1)["low"])
iin = 1
high1 = 0
high2 = 0
low1 = 1000000
low2 = 1000000
self.golong = False
self.goshort = False
# self.dfm2 = self.df.iloc[1:, ]
# self.dfm1 = self.df.iloc[1:30, ]
# column1 = self.dfm1["high"]
# high1 = column1.max()
#
# column2 = self.dfm2["high"]
# high2 = column2.max()
#
# column3 = self.dfm1["low"]
# low1 = column3.min()
#
# column4 = self.dfm2["low"]
# low2 = column4.min()
# while iin<251:
# if(float(self.df.iloc[iin]["high"])>high2):
# high2=float(self.df.iloc[iin]["high"])
# if(float(self.df.iloc[iin]["low"])<low2):
# low2=float(self.df.iloc[iin]["low"])
#
# if (float(self.df.iloc[iin]["high"]) > high1) and (iin>220):
# high1 = float(self.df.iloc[iin]["high"])
# if (float(self.df.iloc[iin]["low"]) < low1) and (iin>220):
# low1 = float(self.df.iloc[iin]["low"])
#
# iin += 1
#
# if (float(self.df.iloc[0]["high"]) > high1) and (float(self.df.iloc[0]["high"]) < high2):
# self.goshort = True
# if (float(self.df.iloc[0]["low"]) < low1) and (float(self.df.iloc[0]["low"]) > low2):
# self.golong = True
# RSI
self.df["rsi"] = RSIIndicator(
close=self.df['close'],
window=20,
fillna=False,
).rsi()
# Stoch
self.df["stoch"] = StochasticOscillator(
high=self.df['high'],
low=self.df['low'],
close=self.df['close'],
window=20,
fillna=False,
).stoch()
# Stoch Signal
self.df["stoch_signal"] = StochasticOscillator(
high=self.df['high'],
low=self.df['low'],
close=self.df['close'],
window=20,
smooth_window=3,
fillna=False,
).stoch_signal()
# CCI
self.df["trend_cci"] = CCIIndicator(
high=self.df['high'],
low=self.df['low'],
close=self.df['close'],
window=20,
constant=0.015,
fillna=False,
).cci()
# normal 1h
# dfh["trend_cci"] = CCIIndicator(
# high=dfh['high'],
# low=dfh['low'],
# close=dfh['close'],
# window=20,
# constant=0.015,
# fillna=False,
# ).cci()
# print(self.df["rsi"])
except:
print("some errors here")
try:
self.rsi = float(self.df.tail(1)["rsi"])
self.stoch = float(self.df.tail(1)["stoch"])
self.stoch_signal = float(self.df.tail(1)["stoch_signal"])
self.cci = float(self.df.tail(1)["trend_cci"])
# print(self.cc5l)
# print(self.cc5n)
# print(self.cc5h)
# self.cch = float(self.datah.tail(1)["trend_cci"])
except:
print("some errors in convert...")
def applyIndicator(self, full_company_price):
self.data = full_company_price
high = self.data['high']
low = self.data['low']
close = self.data['close']
volume = self.data['volume']
EMA12 = EMAIndicator(close, 12, fillna=False)
EMA30 = EMAIndicator(close, 20, fillna=False)
EMA60 = EMAIndicator(close, 60, fillna=False)
MACD1226 = MACD(close, 26, 12, 9, fillna=False)
MACD2452 = MACD(close, 52, 24, 18, fillna=False)
ROC12 = ROCIndicator(close, 12, fillna=False)
ROC30 = ROCIndicator(close, 30, fillna=False)
ROC60 = ROCIndicator(close, 60, fillna=False)
RSI14 = RSIIndicator(close, 14, fillna=False)
RSI28 = RSIIndicator(close, 28, fillna=False)
RSI60 = RSIIndicator(close, 60, fillna=False)
AROON25 = AroonIndicator(close, 25, fillna=False)
AROON50 = AroonIndicator(close, 50, fillna=False)
AROON80 = AroonIndicator(close, 80, fillna=False)
MFI14 = MFIIndicator(high, low, close, volume, 14, fillna=False)
MFI28 = MFIIndicator(high, low, close, volume, 28, fillna=False)
MFI80 = MFIIndicator(high, low, close, volume, 80, fillna=False)
CCI20 = CCIIndicator(high, low, close, 20, 0.015, fillna=False)
CCI40 = CCIIndicator(high, low, close, 40, 0.015, fillna=False)
CCI100 = CCIIndicator(high, low, close, 100, 0.015, fillna=False)
WILLR14 = WilliamsRIndicator(high, low, close, 14, fillna=False)
WILLR28 = WilliamsRIndicator(high, low, close, 28, fillna=False)
WILLR60 = WilliamsRIndicator(high, low, close, 60, fillna=False)
BBANDS20 = BollingerBands(close, 20, 2, fillna=False)
KC20 = KeltnerChannel(high, low, close, 20, 10, fillna=False)
STOCH14 = StochasticOscillator(high, low, close, 14, 3, fillna=False)
STOCH28 = StochasticOscillator(high, low, close, 28, 6, fillna=False)
STOCH60 = StochasticOscillator(high, low, close, 60, 12, fillna=False)
CMI20 = ChaikinMoneyFlowIndicator(high,
low,
close,
volume,
20,
fillna=False)
CMI40 = ChaikinMoneyFlowIndicator(high,
low,
close,
volume,
40,
fillna=False)
CMI100 = ChaikinMoneyFlowIndicator(high,
low,
close,
volume,
100,
fillna=False)
self.data['ema12'] = (close - EMA12.ema_indicator()) / close
self.data['ema30'] = (close - EMA30.ema_indicator()) / close
self.data['ema60'] = (close - EMA60.ema_indicator()) / close
self.data['macd1226'] = MACD1226.macd() - MACD1226.macd_signal()
self.data['macd2452'] = MACD2452.macd() - MACD2452.macd_signal()
self.data['roc12'] = ROC12.roc()
self.data['roc30'] = ROC30.roc()
self.data['roc60'] = ROC60.roc()
self.data['rsi14'] = RSI14.rsi()
self.data['rsi28'] = RSI28.rsi()
self.data['rsi60'] = RSI60.rsi()
self.data['aroon25'] = AROON25.aroon_indicator()
self.data['aroon50'] = AROON50.aroon_indicator()
self.data['aroon80'] = AROON80.aroon_indicator()
self.data['mfi14'] = MFI14.money_flow_index()
self.data['mfi28'] = MFI28.money_flow_index()
self.data['mfi80'] = MFI80.money_flow_index()
self.data['cci20'] = CCI20.cci()
self.data['cci40'] = CCI40.cci()
self.data['cci100'] = CCI100.cci()
self.data['willr14'] = WILLR14.wr()
self.data['willr28'] = WILLR28.wr()
self.data['willr60'] = WILLR60.wr()
self.data['bband20up'] = (BBANDS20.bollinger_hband() - close) / close
self.data['bband20down'] = (close - BBANDS20.bollinger_lband()) / close
self.data['stoch14'] = STOCH14.stoch()
self.data['stoch28'] = STOCH28.stoch()
self.data['stoch60'] = STOCH60.stoch()
self.data['cmi20'] = CMI20.chaikin_money_flow()
self.data['cmi40'] = CMI40.chaikin_money_flow()
self.data['cmi100'] = CMI100.chaikin_money_flow()
self.data['kc20up'] = (KC20.keltner_channel_hband() - close) / close
self.data['kc20down'] = (close - KC20.keltner_channel_lband()) / close
return self.data
def add_momentum_ta(df: pd.DataFrame,
high: str,
low: str,
close: str,
volume: str,
fillna: bool = False,
colprefix: str = "") -> pd.DataFrame:
"""Add trend technical analysis features to dataframe.
Args:
df (pandas.core.frame.DataFrame): Dataframe base.
high (str): Name of 'high' column.
low (str): Name of 'low' column.
close (str): Name of 'close' column.
fillna(bool): if True, fill nan values.
colprefix(str): Prefix column names inserted
Returns:
pandas.core.frame.DataFrame: Dataframe with new features.
"""
# Relative Strength Index (RSI)
df[f'{colprefix}momentum_rsi'] = RSIIndicator(close=df[close],
n=14,
fillna=fillna).rsi()
# TSI Indicator
df[f'{colprefix}momentum_tsi'] = TSIIndicator(close=df[close],
r=25,
s=13,
fillna=fillna).tsi()
# Ultimate Oscillator
df[f'{colprefix}momentum_uo'] = UltimateOscillator(high=df[high],
low=df[low],
close=df[close],
s=7,
m=14,
len=28,
ws=4.0,
wm=2.0,
wl=1.0,
fillna=fillna).uo()
# Stoch Indicator
indicator = StochasticOscillator(high=df[high],
low=df[low],
close=df[close],
n=14,
d_n=3,
fillna=fillna)
df[f'{colprefix}momentum_stoch'] = indicator.stoch()
df[f'{colprefix}momentum_stoch_signal'] = indicator.stoch_signal()
# Williams R Indicator
df[f'{colprefix}momentum_wr'] = WilliamsRIndicator(high=df[high],
low=df[low],
close=df[close],
lbp=14,
fillna=fillna).wr()
# Awesome Oscillator
df[f'{colprefix}momentum_ao'] = AwesomeOscillatorIndicator(
high=df[high], low=df[low], s=5, len=34, fillna=fillna).ao()
# KAMA
df[f'{colprefix}momentum_kama'] = KAMAIndicator(close=df[close],
n=10,
pow1=2,
pow2=30,
fillna=fillna).kama()
# Rate Of Change
df[f'{colprefix}momentum_roc'] = ROCIndicator(close=df[close],
n=12,
fillna=fillna).roc()
return df
def setUp(self):
self._df = pd.read_csv(self._filename, sep=',')
self._indicator = StochasticOscillator(
high=self._df['High'], low=self._df['Low'], close=self._df['Close'], n=14, d_n=3, fillna=False)
