def test_macd_invalid_period_long(self):
short_period = 1
long_period = 128
with self.assertRaises(Exception) as cm:
moving_average_convergence_divergence.moving_average_convergence_divergence(
self.data, short_period, long_period)
expected = "Error: data_len < period"
self.assertEqual(str(cm.exception), expected)
def test_macd_period_10_period_20(self):
short_period = 10
long_period = 20
macd = moving_average_convergence_divergence.moving_average_convergence_divergence(
self.data, short_period, long_period)
np.testing.assert_array_equal(macd,
self.macd_period_10_period_20_expected)
def compute_moving_average_convergence_divergence(df):
df['macd'] = moving_average_convergence_divergence(df.close, 12, 26)
def _get_ta_features(high, low, close, volume, desc):
"""
Returns a dict containing the technical analysis indicators calculated on the given
high, low, close and volumes.
"""
ta = {}
# Set numpy to ignore division error and invalid values (since not all features are complete)
old_settings = np.seterr(divide='ignore', invalid='ignore')
record_count = len(close)
# Determine relative moving averages
for _short, _long in desc['rsma']:
if record_count < _short or record_count < _long:
logging.error(
"get_ta_features: not enough records for rsma (short={}, long={}, records={})"
.format(_short, _long, record_count))
continue
ta['rsma_{}_{}'.format(_short,
_long)] = relative_sma(close, _short, _long)
for _short, _long in desc['rema']:
if record_count < _short or record_count < _long:
logging.error(
"get_ta_features: not enough records for rema (short={}, long={}, records={})"
.format(_short, _long, record_count))
continue
ta['rema_{}_{}'.format(_short,
_long)] = relative_ema(close, _short, _long)
# MACD Indicator
if 'macd' in desc:
for _short, _long in desc['macd']:
if record_count < _short or record_count < _long:
logging.error(
"get_ta_features: not enough records for rema (short={}, long={}, records={})"
.format(_short, _long, record_count))
continue
ta['macd_{}_{}'.format(
_short, _long)] = moving_average_convergence_divergence(
close, _short, _long)
# Aroon Indicator
if 'ao' in desc:
for _period in desc['ao']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for ao (period={}, records={})"
.format(_period, record_count))
continue
ta['ao_{}'.format(_period)] = aroon_oscillator(close, _period)
# Average Directional Movement Index (ADX)
if 'adx' in desc:
for _period in desc['adx']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for adx (period={}, records={})"
.format(_period, record_count))
continue
ta['adx_{}'.format(_period)] = average_directional_index(
close, high, low, _period)
# Difference between Positive Directional Index(DI+) and Negative Directional Index(DI-)
if 'wd' in desc:
for _period in desc['wd']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for wd (period={}, records={})"
.format(_period, record_count))
continue
ta['wd_{}'.format(_period)] = \
positive_directional_index(close, high, low, _period) \
- negative_directional_index(close, high, low, _period)
# Percentage Price Oscillator
if 'ppo' in desc:
for _short, _long in desc['ppo']:
if record_count < _short or record_count < _long:
logging.error(
"get_ta_features: not enough records for ppo (short={}, long={}, records={})"
.format(_short, _long, record_count))
continue
ta['ppo_{}_{}'.format(_short, _long)] = price_oscillator(
close, _short, _long)
# Relative Strength Index
if 'rsi' in desc:
for _period in desc['rsi']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for rsi (period={}, records={})"
.format(_period, record_count))
continue
ta['rsi_{}'.format(_period)] = relative_strength_index(
close, _period)
# Money Flow Index
if 'mfi' in desc:
for _period in desc['mfi']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for mfi (period={}, records={})"
.format(_period, record_count))
continue
ta['mfi_{}'.format(_period)] = money_flow_index(
close, high, low, volume, _period)
# True Strength Index
if 'tsi' in desc and len(close) >= 40:
if record_count < 40:
logging.error(
"get_ta_features: not enough records for tsi (period={}, records={})"
.format(40, record_count))
else:
ta['tsi'] = true_strength_index(close)
if 'boll' in desc:
for _period in desc['stoch']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for boll (period={}, records={})"
.format(_period, record_count))
continue
ta['boll_{}'.format(_period)] = percent_b(close, _period)
# Stochastic Oscillator
if 'stoch' in desc:
for _period in desc['stoch']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for stoch (period={}, records={})"
.format(_period, record_count))
continue
ta['stoch_{}'.format(_period)] = percent_k(close, _period)
# ta.py['stoch'] = percent_k(high, low, close, 14)
# Chande Momentum Oscillator
## Not available in ta.py
if 'cmo' in desc:
for _period in desc['cmo']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for cmo (period={}, records={})"
.format(_period, record_count))
continue
ta['cmo_{}'.format(_period)] = chande_momentum_oscillator(
close, _period)
# Average True Range Percentage
if 'atrp' in desc:
for _period in desc['atrp']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for atrp (period={}, records={})"
.format(_period, record_count))
continue
ta['atrp_{}'.format(_period)] = average_true_range_percent(
close, _period)
# Percentage Volume Oscillator
if 'pvo' in desc:
for _short, _long in desc['pvo']:
if record_count < _short or record_count < _long:
logging.error(
"get_ta_features: not enough records for pvo (short={}, long={}, records={})"
.format(_short, _long, record_count))
continue
ta['pvo_{}_{}'.format(_short, _long)] = volume_oscillator(
volume, _short, _long)
# Force Index
if 'fi' in desc:
fi = force_index(close, volume)
for _period in desc['fi']:
if record_count < _period:
logging.error(
"get_ta_features: not enough records for atrp (period={}, records={})"
.format(_period, record_count))
continue
ta['fi_{}'.format(_period)] = exponential_moving_average(
fi, _period)
# Accumulation Distribution Line
if 'adi' in desc:
ta['adi'] = accumulation_distribution(close, high, low, volume)
# On Balance Volume
if 'obv' in desc:
ta['obv'] = on_balance_volume(close, volume)
# Restore numpy error settings
np.seterr(**old_settings)
return ta
from pyti.simple_moving_average import simple_moving_average
sma = simple_moving_average(close, period)
from pyti.weighted_moving_average import weighted_moving_average
wma = weighted_moving_average(close, period)
from pyti.momentum import momentum
mome = momentum(close, period)
from pyti.relative_strength_index import relative_strength_index
rsi = relative_strength_index(close, period)
from pyti.moving_average_convergence_divergence import moving_average_convergence_divergence
macd = moving_average_convergence_divergence(close,
short_period=1,
long_period=10)
from pyti.commodity_channel_index import commodity_channel_index
cci = commodity_channel_index(close,
high_data=high,
low_data=low,
period=period)
from pyti.williams_percent_r import williams_percent_r
willr = williams_percent_r(close)
from pyti.accumulation_distribution import accumulation_distribution
acd = accumulation_distribution(close_data=close,
low_data=low,
high_data=high,
def convert(str):
period = 10
dataset_train = pd.read_csv(str)
x = dataset_train.iloc[:, 4].values
try:
open = dataset_train.iloc[:, 1].values
except Exception:
open = read_float_with_comma(dataset_train.iloc[:, 1].values)
try:
high = dataset_train.iloc[:, 2].values
except Exception:
high = read_float_with_comma(dataset_train.iloc[:, 2].values)
try:
low = dataset_train.iloc[:, 3].values
except Exception:
low = read_float_with_comma(dataset_train.iloc[:, 3].values)
try:
close = dataset_train.iloc[:, 4].values
except Exception:
close = read_float_with_comma(dataset_train.iloc[:, 4].values)
try:
volume = dataset_train.iloc[:, 5].values
except Exception:
volume = read_float_with_comma(dataset_train.iloc[:, 5].values)
from pyti.simple_moving_average import simple_moving_average
sma = simple_moving_average(close, period)
from pyti.weighted_moving_average import weighted_moving_average
wma = weighted_moving_average(close, period)
from pyti.momentum import momentum
mome = momentum(close, period)
from pyti.relative_strength_index import relative_strength_index
rsi = relative_strength_index(close, period)
from pyti.moving_average_convergence_divergence import moving_average_convergence_divergence
macd = moving_average_convergence_divergence(close,
short_period=1,
long_period=10)
from pyti.commodity_channel_index import commodity_channel_index
cci = commodity_channel_index(close,
high_data=high,
low_data=low,
period=period)
from pyti.williams_percent_r import williams_percent_r
willr = williams_percent_r(close)
from pyti.accumulation_distribution import accumulation_distribution
acd = accumulation_distribution(close_data=close,
low_data=low,
high_data=high,
volume=volume)
X = []
Y = []
for _ in range(10, len(open)):
tmp = []
tmp.append(sma[_])
tmp.append(wma[_])
tmp.append(mome[_])
tmp.append(rsi[_])
tmp.append(macd[_])
tmp.append(cci[_])
tmp.append(willr[_])
X.append(tmp)
Y.append([close[_]])
X, Y = np.array(X), np.array(Y)
return X, Y
