def enhance_with_indicators(data):
set = []
OPEN = data[:, Candle.OPEN]
HIGH = data[:, Candle.HIGH]
LOW = data[:, Candle.LOW]
CLOSE = data[:, Candle.CLOSE]
VOLUME = data[:, Candle.VOLUME]
low_high = talib.BBANDS(CLOSE,
timeperiod=14,
nbdevup=2,
nbdevdn=2,
matype=1)
low_high = np.asarray([low_high[0][-1], low_high[2][-1]]).reshape(-1, 1)
low_high_scaler = StandardScaler()
low_high_scaler.fit(low_high)
one = np.asarray([-1, 1]).reshape(-1, 1)
one_scaler = StandardScaler()
one_scaler.fit(one)
hundred = np.asarray([-100, 100]).reshape(-1, 1)
hundred_scaler = StandardScaler()
hundred_scaler.fit(hundred)
thousand = np.asarray([-1000, 1000]).reshape(-1, 1)
thousand_scaler = StandardScaler()
thousand_scaler.fit(thousand)
million = np.asarray([-1000000, 1000000]).reshape(-1, 1)
million_scaler = StandardScaler()
million_scaler.fit(million)
set.append(scale(OPEN, low_high_scaler))
set.append(scale(HIGH, low_high_scaler))
set.append(scale(LOW, low_high_scaler))
set.append(scale(CLOSE, low_high_scaler))
#Bollinger Bands are envelopes plotted at a standard deviation level above and below a simple moving average of the price.
set.append(
scale(
talib.BBANDS(CLOSE, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0),
low_high_scaler)) #121.03399999999903 19719.281591268886
set.append(
scale(
talib.BBANDS(CLOSE, timeperiod=14, nbdevup=2, nbdevdn=2, matype=1),
low_high_scaler))
#The DEMA uses two exponential moving averages (EMAs) to eliminate lag, as some traders view lag as a problem.
set.append(scale(talib.DEMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19573.564771355504
set.append(scale(talib.DEMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19546.76082510694
set.append(scale(talib.DEMA(CLOSE, timeperiod=100),
low_high_scaler)) #123.84710711425136 19578.715808186673
#However, whereas SMA simply calculates an average of price data, EMA applies more weight to data that is more current.
set.append(scale(talib.EMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19499.362560116417
set.append(scale(talib.EMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19433.26416788178
set.append(scale(talib.EMA(CLOSE, timeperiod=100),
low_high_scaler)) #122.11270000000005 19059.124645340504
#The HTTrendline at a specific bar gives the current Hilbert Transform Trendline as instantaneously measured at that
#bar. In its Series form, the Instantaneous Trendline appears much like a Moving Average, but with minimal lag
#compared with the lag normally associated with such averages for equivalent periods.
set.append(scale(talib.HT_TRENDLINE(CLOSE),
low_high_scaler)) #122.0 19471.324
#Kaufman's Adaptive Moving Average (KAMA) is a moving average designed to account for market noise or volatility.
#KAMA will closely follow prices when the price swings are relatively small and the noise is low.
set.append(scale(talib.KAMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19397.611724437047
set.append(scale(talib.KAMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19336.434082122203
set.append(scale(talib.KAMA(CLOSE, timeperiod=100),
low_high_scaler)) #123.61 19301.746826077375
#The MESA adaptive moving average is a trend-following indicator. It adapts to price movements in a very unique way,
#based on the rate of change (ROC), as measured by the Hilbert Transform Discriminator.
set.append(
scale(talib.MAMA((HIGH + LOW) / 2., fastlimit=0.5, slowlimit=0.05),
low_high_scaler)) #121.04112572694972 19494.294994956996
set.append(scale(talib.MIDPOINT(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19544.95
set.append(scale(talib.MIDPRICE(LOW, HIGH, timeperiod=5),
low_high_scaler)) #122.0 19562.6
#The parabolic SAR indicator, developed by J. Welles Wilder Jr., is used by traders to determine trend direction
# and potential reversals in price.
set.append(
scale(talib.SAR(HIGH, LOW, acceleration=0.02, maximum=0.2),
low_high_scaler)) #122.0 19660.0
#A simple moving average (SMA) is an arithmetic moving average calculated by adding recent prices and then dividing
# that figure by the number of time periods in the calculation average.
set.append(scale(talib.SMA(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19553.340000000037
set.append(scale(talib.SMA(CLOSE, timeperiod=25),
low_high_scaler)) #122.0 19405.74400000004
set.append(scale(talib.SMA(CLOSE, timeperiod=50),
low_high_scaler)) #122.0 19286.443999999996
#The Triple Exponential Moving Average (T3) developed by Tim Tillson attempts to offer a moving average with better
#smoothing then traditional exponential moving average. It incorporates a smoothing technique which allows it to
#plot curves more gradual than ordinary moving averages and with a smaller lag.
set.append(scale(talib.T3(CLOSE, timeperiod=5, vfactor=0),
low_high_scaler)) #122.0 19498.31237177043
set.append(
scale(talib.T3(CLOSE, timeperiod=10, vfactor=0),
low_high_scaler)) #122.0 19419.991324685387
set.append(
scale(talib.T3(CLOSE, timeperiod=21, vfactor=0),
low_high_scaler)) #122.84310194419339 19306.63501695168
#The triple exponential moving average was designed to smooth price fluctuations, thereby making it easier to
#identify trends without the lag associated with traditional moving averages (MA).
set.append(scale(talib.TEMA(CLOSE, timeperiod=7),
low_high_scaler)) #122.0 19617.222402494965
set.append(scale(talib.TEMA(CLOSE, timeperiod=15),
low_high_scaler)) #122.0 19586.42515855386
#The Triangular Moving Average is basically a double-smoothed Simple Moving Average that gives more weight to the
#middle section of the data interval. The TMA has a significant lag to current prices and is not well-suited to
#fast moving markets.
set.append(scale(talib.TRIMA(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19567.31111092877
set.append(scale(talib.TRIMA(CLOSE, timeperiod=25),
low_high_scaler)) #122.0 19459.8816568341
set.append(scale(talib.TRIMA(CLOSE, timeperiod=50),
low_high_scaler)) #122.0 19359.257076923175
#The weighted moving average (WMA) is a technical indicator that assigns a greater weighting to the most recent data
#points, and less weighting to data points in the distant past. The WMA is obtained by multiplying each number in
#the data set by a predetermined weight and summing up the resulting values.
set.append(scale(talib.WMA(CLOSE, timeperiod=5),
low_high_scaler)) #122.0 19567.840000466134
set.append(scale(talib.WMA(CLOSE, timeperiod=10),
low_high_scaler)) #122.0 19527.127272724356
set.append(scale(talib.WMA(CLOSE, timeperiod=21),
low_high_scaler)) #122.0 19479.342424127473
set.append(scale(talib.WMA(CLOSE, timeperiod=50),
low_high_scaler)) #122.0 19355.600000135404
set.append(scale(talib.WMA(CLOSE, timeperiod=100),
low_high_scaler)) #122.21647326732675 19265.66566335264
set.append(scale(talib.LINEARREG(CLOSE, timeperiod=14),
low_high_scaler)) # 122.0 19585.157142857144
set.append(
scale(talib.LINEARREG_INTERCEPT(CLOSE, timeperiod=14),
low_high_scaler)) #121.54000000000003 19643.968571428577
set.append(scale(talib.TSF(CLOSE, timeperiod=14),
low_high_scaler)) #122.0 19609.668131868133
#ADX stands for Average Directional Movement Index and can be used to help measure the overall strength of a trend.
#The ADX indicator is an average of expanding price range values.
set.append(
scale(talib.ADX(HIGH, LOW, CLOSE, timeperiod=10),
hundred_scaler)) #0.0 99.99999999999963
set.append(
scale(talib.ADX(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 99.9999999940751
set.append(
scale(talib.ADX(HIGH, LOW, CLOSE, timeperiod=21),
hundred_scaler)) #0.0 99.99998408446837
#ADXR stands for Average Directional Movement Index Rating. ADXR is a component of the Directional Movement System
#developed by Welles Wilder.
set.append(
scale(talib.ADXR(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 99.9999999892742
#The Aroon indicator is a technical indicator that is used to identify trend changes in the price of an asset,
#as well as the strength of that trend. In essence, the indicator measures the time between highs and the time
#between lows over a time period. ... The indicator signals when this is happening, and when it isn't
set.append(scale(talib.AROON(HIGH, LOW), hundred_scaler)) #0.0 100.0
#The Directional Movement Index, or DMI, is an indicator developed by J. ... An optional third line, called
#directional movement (DX) shows the difference between the lines. When +DI is above -DI, there is more upward
#pressure than downward pressure in the price.
set.append(scale(talib.DX(HIGH, LOW, CLOSE, timeperiod=5),
hundred_scaler)) #0.0 100.0
set.append(scale(talib.DX(HIGH, LOW, CLOSE, timeperiod=21),
hundred_scaler)) #0.0 100.0
set.append(scale(talib.DX(HIGH, LOW, CLOSE, timeperiod=50),
hundred_scaler)) #0.0 100.0
set.append(
scale(talib.MFI(HIGH, LOW, CLOSE, VOLUME, timeperiod=14),
hundred_scaler)) #-5.888410733172162e-08 100.00000000707982
set.append(
scale(talib.MFI(HIGH, LOW, CLOSE, VOLUME, timeperiod=26),
hundred_scaler)) #-1.3802451942902055e-09 100.00000001185656
set.append(
scale(talib.MFI(HIGH, LOW, CLOSE, VOLUME, timeperiod=100),
hundred_scaler)) #-5.3901183535126315e-08 100.00000000091877
set.append(
scale(talib.MINUS_DI(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 99.99999996020233
set.append(
scale(talib.PLUS_DI(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) #0.0 100.0
set.append(scale(talib.RSI(CLOSE, timeperiod=14),
hundred_scaler)) #0.0 100.0
set.append(
scale(
talib.STOCH(HIGH,
LOW,
CLOSE,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0),
hundred_scaler)) #-1.0137076363510762e-12 100.00000000000279
set.append(
scale(
talib.STOCHF(HIGH,
LOW,
CLOSE,
fastk_period=5,
fastd_period=3,
fastd_matype=0),
hundred_scaler)) #-1.0137076363510762e-12 100.0000000000012
set.append(
scale(
talib.STOCHRSI(CLOSE,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0),
hundred_scaler)) #-1.2166564052525548e-12 100.00000000000011
set.append(
scale(
talib.ULTOSC(HIGH,
LOW,
CLOSE,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28),
hundred_scaler)) # 0.0 100.00000032481957
set.append(
scale(talib.CDL3WHITESOLDIERS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLDRAGONFLYDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLGRAVESTONEDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLHAMMER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLHOMINGPIGEON(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLINVERTEDHAMMER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLLADDERBOTTOM(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLLONGLEGGEDDOJI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLMATCHINGLOW(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLMORNINGDOJISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLMORNINGSTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLPIERCING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLRICKSHAWMAN(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLSTICKSANDWICH(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(scale(talib.CDLTAKURI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
set.append(
scale(talib.CDLUNIQUE3RIVER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #0 100
#Absolute Price Oscillator crossing above zero is considered bullish, while crossing below zero is bearish. A
#positive indicator value indicates an upward movement, while negative readings signal a downward trend.
set.append(
scale(talib.APO(CLOSE, fastperiod=12, slowperiod=26, matype=1),
thousand_scaler)) #-536.1910463572985 443.13971636041424
set.append(scale(VOLUME, thousand_scaler))
#The Commodity Channel Index (CCI) measures the current price level relative to an average price level over a given
#period of time. CCI is relatively high when prices are far above their average.
set.append(scale(talib.CCI(HIGH, LOW, CLOSE),
thousand_scaler)) #-466.66671166042244 466.66673951370416
#Moving average convergence divergence (MACD) is a trend-following momentum indicator that shows the relationship
#between two moving averages of a security’s price.
set.append(
scale(talib.MACD(CLOSE, fastperiod=5, slowperiod=14, signalperiod=5),
thousand_scaler)) # -536.1910463572985 443.13971636041424
set.append(
scale(talib.MACD(CLOSE, fastperiod=12, slowperiod=26, signalperiod=9),
thousand_scaler)) #-536.1910463572985 443.13971636041424
set.append(
scale(talib.MACD(CLOSE, fastperiod=14, slowperiod=50, signalperiod=25),
thousand_scaler)) # -536.1910463572985 443.13971636041424
set.append(scale(talib.ATR(HIGH, LOW, CLOSE),
thousand_scaler)) #0.0 672.1715311610562
set.append(scale(talib.HT_DCPHASE(CLOSE),
hundred_scaler)) #-44.99298332517037 314.99654478107004
set.append(
scale(talib.LINEARREG_SLOPE(CLOSE, timeperiod=14),
hundred_scaler)) #-222.33604395604476 152.37032967033085
set.append(
scale(talib.STDDEV(CLOSE, timeperiod=5, nbdev=1),
thousand_scaler)) #0.0 709.4023698851089
set.append(scale(talib.MINUS_DM(HIGH, LOW, timeperiod=14),
thousand_scaler)) #0.0 2909.3760999618785
set.append(scale(talib.MOM(CLOSE, timeperiod=10),
thousand_scaler)) #-2508.0 1711.2000000000007
set.append(scale(talib.MOM(CLOSE, timeperiod=25),
thousand_scaler)) # -2508.0 1711.2000000000007
set.append(scale(talib.PLUS_DM(HIGH, LOW, timeperiod=14),
thousand_scaler)) #0.0 3697.0008310558483
set.append(scale(talib.ADOSC(HIGH, LOW, CLOSE, VOLUME),
thousand_scaler)) #-1843.4418435977714 1237.4131984846026
set.append(scale(talib.TRANGE(HIGH, LOW, CLOSE),
thousand_scaler)) #0.0 4000.0
set.append(scale(talib.HT_PHASOR(CLOSE),
thousand_scaler)) #-2873.977625168652 3422.2535328187428
#The Balance of Power indicator measures the market strength of buyers against sellers by assessing the ability of
#each side to drive prices to an extreme level. The calculation is: Balance of Power = (Close price – Open price) /
#(High price – Low price) The resulting value can be smoothed by a moving average.
set.append(scale(talib.BOP(OPEN, HIGH, LOW, CLOSE), one_scaler)) #-1.0 1.0
set.append(scale(talib.ROCP(CLOSE, timeperiod=10),
one_scaler)) #-0.30688987999999995 0.46745909457773854
set.append(scale(talib.ROCR(CLOSE, timeperiod=10),
one_scaler)) #0.69311012 1.4674590945777386
set.append(scale(talib.TRIX(CLOSE, timeperiod=30),
one_scaler)) #-0.6044429731575707 0.434667877456385
set.append(scale(talib.HT_SINE(CLOSE),
one_scaler)) #-0.9999999999996187 0.9999999999940317
set.append(scale(talib.HT_TRENDMODE(CLOSE), one_scaler)) #0 1
set.append(
scale(talib.PPO(CLOSE, fastperiod=12, slowperiod=26, matype=0),
hundred_scaler)) #-13.640389725420714 13.383459677599681
set.append(scale(talib.ROC(CLOSE, timeperiod=10),
hundred_scaler)) #-30.688987999999995 46.74590945777386
set.append(scale(talib.NATR(HIGH, LOW, CLOSE),
one_scaler)) #0.0 7.881777549670427
set.append(scale(talib.HT_DCPERIOD(CLOSE),
hundred_scaler)) #6.91050087362864 49.99951053223339
set.append(scale(talib.CORREL(HIGH, LOW, timeperiod=30),
one_scaler)) #-2.4748737341529163 2.2135943621178655
set.append(scale(talib.AD(HIGH, LOW, CLOSE, VOLUME),
million_scaler)) #-3719.2404462314116 199644.25743563366
set.append(scale(talib.OBV(CLOSE, VOLUME),
million_scaler)) #-23849.75116020021 29139.83770172981
set.append(scale(talib.BETA(HIGH, LOW, timeperiod=5),
million_scaler)) #-2971957.111723269 1250567.1172035346
set.append(
scale(talib.VAR(CLOSE, timeperiod=5, nbdev=1),
million_scaler)) #-1.4901161193847656e-07 503251.7223986089
# The Aroon Oscillator is a trend-following indicator that uses aspects of the Aroon Indicator (Aroon Up and Aroon
# Down) to gauge the strength of a current trend and the likelihood that it will continue. Readings above zero
# indicate that an uptrend is present, while readings below zero indicate that a downtrend is present.
set.append(scale(talib.AROONOSC(HIGH, LOW),
hundred_scaler)) # -100.0 100.0
# The Chande Momentum Oscillator (CMO) is a technical momentum indicator developed by Tushar Chande. The CMO
# indicator is created by calculating the difference between the sum of all recent higher closes and the sum of all
# recent lower closes and then dividing the result by the sum of all price movement over a given time period.
set.append(scale(talib.CMO(CLOSE, timeperiod=5),
hundred_scaler)) # -100.0 100.0
set.append(scale(talib.CMO(CLOSE, timeperiod=14),
hundred_scaler)) # -99.99999998652726 100.0
set.append(scale(talib.CMO(CLOSE, timeperiod=25),
hundred_scaler)) # -99.99854211548185 100.0
set.append(scale(talib.CDL3INSIDE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDL3LINESTRIKE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDL3OUTSIDE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLABANDONEDBABY(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLBELTHOLD(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLBREAKAWAY(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLCLOSINGMARUBOZU(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLCOUNTERATTACK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLDOJISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLENGULFING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLGAPSIDESIDEWHITE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLHARAMI(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLHARAMICROSS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLHIGHWAVE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLKICKING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLKICKINGBYLENGTH(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLLONGLINE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLMARUBOZU(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLRISEFALL3METHODS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLSEPARATINGLINES(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLSHORTLINE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLSPINNINGTOP(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLTASUKIGAP(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(scale(talib.CDLTRISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.CDLXSIDEGAP3METHODS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 100
set.append(
scale(talib.LINEARREG_ANGLE(CLOSE, timeperiod=14),
hundred_scaler)) #-89.74230272272693 89.62397563202859
set.append(
scale(talib.WILLR(HIGH, LOW, CLOSE, timeperiod=14),
hundred_scaler)) # -100.00000000000001 0.0
#The Two Crows is a three-line bearish reversal candlestick pattern. The pattern requires confirmation, that is,
#the following candles should break a trendline or the nearest support area which may be formed by the first
#candle's line. If the pattern is not confirmed it may act only as a temporary pause within an uptrend.
set.append(scale(talib.CDL2CROWS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDL3BLACKCROWS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLADVANCEBLOCK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) # -100 0
set.append(
scale(talib.CDLDARKCLOUDCOVER(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLEVENINGDOJISTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLEVENINGSTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLHANGINGMAN(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLIDENTICAL3CROWS(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(scale(talib.CDLINNECK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(scale(talib.CDLONNECK(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLSHOOTINGSTAR(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLSTALLEDPATTERN(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(
scale(talib.CDLTHRUSTING(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-100 0
set.append(scale(talib.CDLHIKKAKE(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-200 200
set.append(
scale(talib.CDLHIKKAKEMOD(OPEN, HIGH, LOW, CLOSE),
hundred_scaler)) #-200 200
return np.concatenate(set)
def build_talib_factors(df_ftr, tp=10):
tporg = tp
mul = 2
rtn_divisor = [1, 1 / 8]
# momentum
df_ftr['BOP'] = ta.BOP(df_ftr.open.values, df_ftr.high.values,
df_ftr.low.values, df_ftr.close.values)
# volatility
df_ftr['TRANGE'] = ta.TRANGE(df_ftr.high.values, df_ftr.low.values,
df_ftr.close.values)
# volume
df_ftr['AD'] = ta.AD(df_ftr.high.values, df_ftr.low.values,
df_ftr.close.values, df_ftr.volume.values)
# df_ftr['AD_ANGLE']=ta.LINEARREG_ANGLE(df_ftr['AD'].values, timeperiod=tp) too little variation
# overlap
df_ftr['OBV'] = ta.OBV(df_ftr.close.values, df_ftr.volume.values)
for i in range(len(rtn_divisor)):
tp = int(tporg // rtn_divisor[i])
if tp <= 3:
continue
x = str(i)
######## self defined
df_ftr['rtn_disper'] = df_ftr['high'] - df_ftr['low']
df_ftr['rtn_disper_rolling' + x] = df_ftr['rtn_disper'].rolling(
int(tp)).mean()
######## momentum indicators
# see descriptoin for the values df_ftr['close_slope' + x] and others see the freq it falls into the ranges
df_ftr['close_slope' + x] = ta.LINEARREG_SLOPE(df_ftr['close'].values,
timeperiod=tp)
df_ftr['close_slope_std' + x] = df_ftr['close_slope' + x].rolling(
int(tp)).std()
# rsi
df_ftr['rsi' + x] = ta.RSI(df_ftr.close.values, timeperiod=tp)
df_ftr['rsi_mean' +
x] = ta.SUM(df_ftr['rsi' + x].values, timeperiod=tp) / tp
df_ftr['storsi' +
x] = (df_ftr['rsi' + x] - df_ftr['rsi' + x].rolling(tp).min()
) / (df_ftr['rsi' + x].rolling(tp).max() -
df_ftr['rsi' + x].rolling(tp).min())
# stochastic
df_ftr['slowk' + x], df_ftr['slowd' + x] = ta.STOCH(
df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
fastk_period=round(tp * mul),
slowk_period=tp,
slowk_matype=0,
slowd_period=tp,
slowd_matype=0) # slowd is slow sto, slowk is fast sto
df_ftr['slowj'] = (3 * df_ftr['slowd' + x]) - (2 * df_ftr['slowk' + x])
df_ftr['fastk' + x], df_ftr['fastd' + x] = ta.STOCHF(
df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
fastk_period=tp,
fastd_period=tp // mul,
fastd_matype=0)
df_ftr['mom' + x] = ta.MOM(df_ftr.close.values, timeperiod=tp)
# directional change
df_ftr['plus_di' + x] = ta.PLUS_DI(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
df_ftr['plus_dm' + x] = ta.PLUS_DM(df_ftr.high.values,
df_ftr.low.values,
timeperiod=tp)
df_ftr['MINUS_DI' + x] = ta.MINUS_DI(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
df_ftr['MINUS_DM' + x] = ta.MINUS_DM(df_ftr.high.values,
df_ftr.low.values,
timeperiod=tp)
df_ftr['plus_minus_di' +
x] = df_ftr['plus_di' + x] - df_ftr['MINUS_DI' + x]
df_ftr['DX' + x] = ta.DX(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
df_ftr['ADX' + x] = ta.ADX(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
df_ftr['ADXR' + x] = ta.ADXR(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
# MACD
df_ftr['MACD' + x], df_ftr['macdsignal' +
x], df_ftr['macdhist' + x] = ta.MACD(
df_ftr.close.values,
fastperiod=tp,
slowperiod=round(tp * 2),
signalperiod=tp // mul)
# http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:moving_average_convergence_divergence_macd
# Aroon
# https://tradingsim.com/blog/aroon-indicator/
df_ftr['aroondown' + x], df_ftr['aroonup' + x] = ta.AROON(
df_ftr.high.values, df_ftr.low.values, timeperiod=tp)
df_ftr['AROONOSC' + x] = ta.AROONOSC(df_ftr.high.values,
df_ftr.low.values,
timeperiod=tp)
# Chande Momentum Oscillator
# https://www.investopedia.com/terms/c/chandemomentumoscillator.asp
df_ftr['CMO' + x] = ta.CMO(df_ftr.close.values, timeperiod=tp)
# Money Flow Index
# http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:money_flow_index_mfi
df_ftr['MFI' + x] = ta.MFI(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
df_ftr.volume.values,
timeperiod=tp)
df_ftr['MFI_slope' + x] = ta.LINEARREG_SLOPE(df_ftr['MFI' + x].values,
timeperiod=tp)
# MACD with controllable MA type
df_ftr['macdEXT' + x], df_ftr['macdEXTsignal' +
x], df_ftr['macdEXThist' +
x] = ta.MACDEXT(
df_ftr.close.values,
fastperiod=tp // mul,
fastmatype=0,
slowperiod=tp,
slowmatype=0,
signalperiod=9,
signalmatype=0)
df_ftr['macdEXT_slope' + x] = ta.LINEARREG_SLOPE(df_ftr['macdEXT' +
x].values,
timeperiod=tp)
df_ftr['macdFIX' + x], df_ftr['macdFIXsignal' +
x], df_ftr['macdFIXhist' +
x] = ta.MACDFIX(
df_ftr.close.values,
signalperiod=9)
# Stochastic Relative Strength Index
df_ftr['fastkRSI' + x], df_ftr['fastdRSI' + x] = ta.STOCHRSI(
df_ftr.close.values,
timeperiod=tp,
fastk_period=tp // 2,
fastd_period=tp // (mul * 2),
fastd_matype=0)
# volatility
df_ftr['ATR' + x] = ta.ATR(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
df_ftr['NATR' + x] = ta.NATR(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
timeperiod=tp)
# volume
df_ftr['ADOSC' + x] = ta.ADOSC(df_ftr.high.values,
df_ftr.low.values,
df_ftr.close.values,
df_ftr.volume.values,
fastperiod=tp,
slowperiod=tp * mul)
df_ftr['AD_SLOPE' + x] = ta.LINEARREG_SLOPE(df_ftr['AD'].values,
timeperiod=tp)
df_ftr['AD_SLOPE_std' + x] = df_ftr['AD_SLOPE' + x].rolling(
int(tp * 20)).std()
df_ftr['OBV_slope' + x] = ta.LINEARREG_SLOPE(df_ftr['OBV'].values,
timeperiod=tp)
# cycle
df_ftr['HT_DCPERIOD' +
x] = df_ftr['HT_DCPERIOD'].pct_change(periods=int(tp)).values
df_ftr['HT_TRENDLINE' + x] = pd.DataFrame(
ta.HT_TRENDLINE(
df_ftr.close.values)).pct_change(periods=int(tp)).values
# statistics
df_ftr['STDDEV' + x] = ta.STDDEV(df_ftr.close.values,
timeperiod=tp,
nbdev=1)
# NbDev = How may deviations you want this function to return (normally = 1).
df_ftr[
'TSF' +
x] = ta.TSF(df_ftr.close.values, timeperiod=tp) / df_ftr.close - 1
df_ftr['BETA' + x] = ta.BETA(df_ftr.high.values,
df_ftr.low.values,
timeperiod=tp)
df_ftr['LINEARREG_SLOPE' + x] = ta.LINEARREG_SLOPE(df_ftr.close.values,
timeperiod=tp)
df_ftr['CORREL' + x] = ta.CORREL(df_ftr.high.values,
df_ftr.low.values,
timeperiod=tp)
# candle indicators - pattern recognition - unused features
df_ftr = df_ftr.replace([np.inf, -np.inf], np.nan)
col = list(df_ftr.columns.values)
df_ftr.to_pickle(r'../data/ftr_ta.pkl')
resorted = {
'open': np.array(resorted['open']),
'high': np.array(resorted['high']),
'low': np.array(resorted['low']),
'close': np.array(resorted['close']),
'volume': np.array(resorted['volume']),
'time': np.array(resorted['time'])
}
##Classic
bb_upperband, bb_middleband, bb_lowerband = talib.BBANDS(
resorted['close'])
dema_real = talib.DEMA(resorted['close'])
ema_real = talib.EMA(resorted['close'])
httrend_real = talib.HT_TRENDLINE(resorted['close'])
kama_real = talib.KAMA(resorted['close'])
ma_real = talib.MA(resorted['close'])
mama_real, fama_real = talib.MAMA(resorted['close'])
#mavp_real = talib.MAVP(resorted['close'])
midpoint_real = talib.MIDPOINT(resorted['close'])
midprice_real = talib.MIDPRICE(resorted['high'],
resorted['low'])
sar_real = talib.SAR(resorted['high'], resorted['low'])
sarext_real = talib.SAREXT(resorted['high'], resorted['low'])
sma_real = talib.SMA(resorted['close'])
t3_real = talib.T3(resorted['close'])
tema_real = talib.TEMA(resorted['close'])
trima_real = talib.TRIMA(resorted['close'])
wma_real = talib.WMA(resorted['close'])
def featureExt(data_input=None):
open = data_input['open'].values.astype(np.float64)
low = data_input['low'].values.astype(np.float64)
high = data_input['high'].values.astype(np.float64)
close = data_input['close'].values.astype(np.float64)
volume = data_input['vol'].values.astype(np.float64)
data_input['xclose'] = data_input['close']
data_input['MA5'] = ta.MA(np.array(close), timeperiod=5)
data_input['MA10'] = ta.MA(np.array(close), timeperiod=10)
data_input['MA20'] = ta.MA(np.array(close), timeperiod=20)
data_input['EMA12'] = ta.EMA(np.array(close), timeperiod=6)
data_input['EMA26'] = ta.EMA(np.array(close), timeperiod=12)
data_input['MACD'], data_input['MACDsignal'], data_input[
'MACDhist'] = ta.MACD(np.array(close),
fastperiod=6,
slowperiod=12,
signalperiod=9)
data_input['RSI'] = ta.RSI(np.array(close), timeperiod=12)
data_input['MOM'] = ta.MOM(np.array(close), timeperiod=5)
data_input['K'], data_input['D'] = ta.STOCH(np.array(high),
np.array(low),
np.array(close),
fastk_period=9,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
data_input['J'] = data_input.K * 3 - data_input.D * 2
##########Volatility Indicator Functions########
data_input['ATR'] = ta.ATR(np.array(high),
np.array(low),
np.array(close),
timeperiod=14)
#########Volume Indicator Functions#############
data_input['OBV'] = ta.OBV(np.array(close), np.array(volume))
data_input['AD'] = ta.AD(np.array(high), np.array(low), np.array(close),
np.array(volume))
data_input['ADOSC'] = ta.ADOSC(np.array(high), np.array(low),
np.array(close), np.array(volume))
#########Overlap Studies###########
data_input['UPPERBAND'], data_input['MIDDLEBAND'], data_input[
'LOWERBAND'] = ta.BBANDS(np.array(close),
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
data_input['DEMA'] = ta.DEMA(np.array(close), timeperiod=30)
data_input['EMA'] = ta.EMA(np.array(close), timeperiod=30)
data_input['HT_TRENDLINE'] = ta.HT_TRENDLINE(np.array(close))
data_input['KAMA'] = ta.KAMA(np.array(close), timeperiod=30)
data_input['MA'] = ta.MA(np.array(close), timeperiod=30, matype=0)
data_input['MIDPOINT'] = ta.MIDPOINT(np.array(close), timeperiod=14)
data_input['MIDPRICE'] = ta.MIDPRICE(np.array(high),
np.array(low),
timeperiod=14)
data_input['SAR'] = ta.SAR(np.array(high),
np.array(low),
acceleration=0,
maximum=0)
data_input['SAREXT'] = ta.SAREXT(np.array(high),
np.array(low),
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
data_input['SMA'] = ta.SMA(np.array(close), timeperiod=30)
data_input['T3'] = ta.T3(np.array(close), timeperiod=5, vfactor=0)
data_input['TEMA'] = ta.TEMA(np.array(close), timeperiod=30)
data_input['TRIMA'] = ta.TRIMA(np.array(close), timeperiod=30)
data_input['WMA'] = ta.WMA(np.array(close), timeperiod=30)
#########Momentum Indicators###########
data_input['ADX'] = ta.ADX(np.array(high),
np.array(low),
np.array(close),
timeperiod=14)
#data_input['CCI'] = ta.CCI(np.array(high), np.array(low), np.array(close), timeperiod=14)
#data_input['TRIX'] = ta.TRIX(np.array(close), timeperiod=30)
return data_input
#量价指标
real = talib.OBV(df.close, df.volume)
real = talib.AD(df.high, df.low, df.close, df.volume)
real = talib.ADOSC(df.high,
df.low,
df.close,
df.volume,
fastperiod=3,
slowperiod=10)
#avg
real = talib.DEMA(df.close, timeperiod=30)
real = talib.EMA(df.close, timeperiod=30)
real = talib.HT_TRENDLINE(df.close)
real = talib.KAMA(df.close, timeperiod=30)
##################################################
real = talib.SAREXT(df.high,
df.low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
def handle_data(context):
# 获取历史数据, 取后window根bar
hist = context.data.get_price(context.security,
count=context.user_data.ht_window,
frequency='60m')
if len(hist.index) < context.user_data.ht_window:
context.log.warn("bar的数量不足, 等待下一根bar...")
return
# 历史收盘价
hist_close = np.array(hist["close"])
# 初始化买入/卖出信号
long_signal_triggered = False
short_signal_triggered = False
# 计算指标值
ht_line = talib.HT_TRENDLINE(hist_close)
current_price = context.data.get_current_price(context.security)
current_drawdown = 0
if context.account.huobi_cny_ltc > HUOBI_CNY_LTC_MIN_ORDER_QUANTITY:
if context.user_data.max_net is None:
context.user_data.max_net = context.account.huobi_cny_net
else:
if context.account.huobi_cny_net > context.user_data.max_net:
context.user_data.max_net = context.account.huobi_cny_net
current_drawdown = (
context.account.huobi_cny_net -
context.user_data.max_net) / context.user_data.max_net
else:
context.user_data.max_net = None
context.log.info('dd = %s' % current_drawdown)
if -current_drawdown >= context.user_data.stop_loss:
context.log.info("触发止损信号")
short_signal_triggered = True
else:
# 产生买入/卖出信号
if current_price > ht_line[-1] * (1 + context.user_data.upper):
long_signal_triggered = True
elif current_price < ht_line[-1] * (1 - context.user_data.lower):
short_signal_triggered = True
# 有卖出信号，且持有仓位，则全仓卖出
if short_signal_triggered:
if context.account.huobi_cny_ltc >= HUOBI_CNY_LTC_MIN_ORDER_QUANTITY:
context.log.info("正在卖出 %s" % context.security)
context.log.info("卖出数量为 %s" % context.account.huobi_cny_ltc)
context.order.sell_limit(context.security,
quantity=str(
context.account.huobi_cny_ltc),
price=str(hist_close[-1] * 0.999))
else:
context.log.info("仓位不足，无法卖出")
# 有买入信号，且持有现金，则全仓买入
elif long_signal_triggered:
if context.account.huobi_cny_cash >= HUOBI_CNY_LTC_MIN_ORDER_CASH_AMOUNT:
context.log.info("正在买入 %s" % context.security)
context.log.info("下单金额为 %s 元" % context.account.huobi_cny_cash)
context.order.buy_limit(
context.security,
quantity=str(context.account.huobi_cny_cash / hist_close[-1] *
0.999),
price=str(hist_close[-1] * 1.001))
else:
context.log.info("现金不足，无法下单")
else:
context.log.info("无交易信号，进入下一根bar")
def get_ht(ohlc):
ht = ta.HT_TRENDLINE(ohlc['4_close'])
ohlc['ht'] = ht
return ohlc
def HT_TRENDLINE(Close):
return Close.apply(lambda col: ta.HT_TRENDLINE(col), axis=0)
def HT_TRENDLINE_factor(self, df):
return talib.HT_TRENDLINE(df.loc[:, self.map_dict['default']].values)
def appendAllTAData(df=pd.DataFrame([])):
resDF = pd.DataFrame([])
# 函数名：AD名称：ChaikinA/DLine累积/派发线（Accumulation/DistributionLine）
# 简介：MarcChaikin提出的一种平衡交易量指标，以当日的收盘价位来估算成交流量，用于估定一段时间内该证券累积的资金流量。
# 计算公式：A/D=昨日A/D+多空对比*今日成交量多空对比=[（收盘价-最低价）-（最高价-收盘价）]/（最高价-最低价）
# 若最高价等于最低价：多空对比=（收盘价/昨收盘）-1
# 研判：1、A/D测量资金流向，向上的A/D表明买方占优势，而向下的A/D表明卖方占优势
# 2、A/D与价格的背离可视为买卖信号，即底背离考虑买入，顶背离考虑卖出
# 3、应当注意A/D忽略了缺口的影响，事实上，跳空缺口的意义是不能轻易忽略的
# A/D指标无需设置参数，但在应用时，可结合指标的均线进行分析例子：real=AD(high,low,close,volume)
resDF['AD'] = ta.AD(df['max_price'].values, df['min_price'].values,
df['price'].values, df['vol'].values)
# 函数名：ADOSC名称：Chaikin A/D Oscillator Chaikin震荡指标
# 简介：将资金流动情况与价格行为相对比，检测市场中资金流入和流出的情况
# 计算公式：fastperiod A/D - slowperiod A/D
# 研判：1、交易信号是背离：看涨背离做多，看跌背离做空
# 2、股价与90天移动平均结合，与其他指标结合
# 3、由正变负卖出，由负变正买进
# 例子：real = ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
resDF['ADOSC'] = ta.ADOSC(df['max_price'].values,
df['min_price'].values,
df['price'].values,
df['vol'].values,
fastperiod=3,
slowperiod=10)
resDF['ADX'] = ta.ADX(df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['ADXR'] = ta.ADXR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['APO'] = ta.APO(df['price'].values,
fastperiod=12,
slowperiod=26,
matype=0)
resDF['aroondown'], resDF['aroonup'] = ta.AROON(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['AROONOSC'] = ta.AROONOSC(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['ATR'] = ta.ATR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['AVGPRICE'] = ta.AVGPRICE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values, df['price'].values)
resDF['upperband'], resDF['middleband'], resDF['lowerband'] = ta.BBANDS(
df['price'].values, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
resDF['BETA'] = ta.BETA(df['max_price'].values,
df['min_price'].values,
timeperiod=5)
resDF['BOP'] = ta.BOP(df['price_today_open'].values,
df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['CCI'] = ta.CCI(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=10)[-1]
# 函数名：CDL2CROWS名称：Two Crows 两只乌鸦
# 简介：三日K线模式，第一天长阳，第二天高开收阴，第三天再次高开继续收阴，收盘比前一日收盘价低，预示股价下跌。
# 例子：integer = CDL2CROWS(open, high, low, close)
resDF['CDL2CROWS'] = ta.CDL2CROWS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3BLACKCROWS名称：Three Black Crows 三只乌鸦
# 简介：三日K线模式，连续三根阴线，每日收盘价都下跌且接近最低价，每日开盘价都在上根K线实体内，预示股价下跌。
# 例子：integer = CD3BLACKCROWS(open, high, low, close)
resDF['CDL3BLACKCROWS'] = ta.CDL3BLACKCROWS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3INSIDE名称： Three Inside Up/Down 三内部上涨和下跌
# 简介：三日K线模式，母子信号+长K线，以三内部上涨为例，K线为阴阳阳，第三天收盘价高于第一天开盘价，第二天K线在第一天K线内部，预示着股价上涨。
# 例子：integer = CDL3INSIDE(open, high, low, close)
resDF['CDL3INSIDE'] = ta.CDL3INSIDE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3LINESTRIKE名称： Three-Line Strike 三线打击
# 简介：四日K线模式，前三根阳线，每日收盘价都比前一日高，开盘价在前一日实体内，第四日市场高开，收盘价低于第一日开盘价，预示股价下跌。
# 例子：integer = CDL3LINESTRIKE(open, high, low, close)
resDF['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3OUTSIDE名称：Three Outside Up/Down 三外部上涨和下跌
# 简介：三日K线模式，与三内部上涨和下跌类似，K线为阴阳阳，但第一日与第二日的K线形态相反，以三外部上涨为例，第一日K线在第二日K线内部，预示着股价上涨。
# 例子：integer = CDL3OUTSIDE(open, high, low, close)
resDF['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3STARSINSOUTH名称：Three Stars In The South 南方三星
# 简介：三日K线模式，与大敌当前相反，三日K线皆阴，第一日有长下影线，第二日与第一日类似，K线整体小于第一日，第三日无下影线实体信号，成交价格都在第一日振幅之内，预示下跌趋势反转，股价上升。
# 例子：integer = CDL3STARSINSOUTH(open, high, low, close)
resDF['CDL3STARSINSOUTH'] = ta.CDL3STARSINSOUTH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDL3WHITESOLDIERS名称：Three Advancing White Soldiers 三个白兵
# 简介：三日K线模式，三日K线皆阳，每日收盘价变高且接近最高价，开盘价在前一日实体上半部，预示股价上升。
# 例子：integer = CDL3WHITESOLDIERS(open, high, low, close)
resDF['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLABANDONEDBABY名称：Abandoned Baby 弃婴
# 简介：三日K线模式，第二日价格跳空且收十字星（开盘价与收盘价接近，最高价最低价相差不大），预示趋势反转，发生在顶部下跌，底部上涨。
# 例子：integer = CDLABANDONEDBABY(open, high, low, close, penetration=0)
resDF['CDLABANDONEDBABY'] = ta.CDLABANDONEDBABY(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLADVANCEBLOCK名称：Advance Block 大敌当前
# 简介：三日K线模式，三日都收阳，每日收盘价都比前一日高，开盘价都在前一日实体以内，实体变短，上影线变长。
# 例子：integer = CDLADVANCEBLOCK(open, high, low, close)
resDF['CDLADVANCEBLOCK'] = ta.CDLADVANCEBLOCK(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLBELTHOLD名称：Belt-hold 捉腰带线
# 简介：两日K线模式，下跌趋势中，第一日阴线，第二日开盘价为最低价，阳线，收盘价接近最高价，预示价格上涨。
# 例子：integer = CDLBELTHOLD(open, high, low, close)
resDF['CDLBELTHOLD'] = ta.CDLBELTHOLD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLBREAKAWAY名称：Breakaway 脱离
# 简介：五日K线模式，以看涨脱离为例，下跌趋势中，第一日长阴线，第二日跳空阴线，延续趋势开始震荡，第五日长阳线，收盘价在第一天收盘价与第二天开盘价之间，预示价格上涨。
# 例子：integer = CDLBREAKAWAY(open, high, low, close)
resDF['CDLBREAKAWAY'] = ta.CDLBREAKAWAY(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名： CDLCLOSINGMARUBOZU 名称：Closing Marubozu 收盘缺影线
# 简介：一日K线模式，以阳线为例，最低价低于开盘价，收盘价等于最高价，预示着趋势持续。
# 例子：integer = CDLCLOSINGMARUBOZU(open, high, low, close)
resDF['CDLCLOSINGMARUBOZU'] = ta.CDLCLOSINGMARUBOZU(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLCONCEALBABYSWALL名称： Concealing Baby Swallow 藏婴吞没
# 简介：四日K线模式，下跌趋势中，前两日阴线无影线，第二日开盘、收盘价皆低于第二日，第三日倒锤头，第四日开盘价高于前一日最高价，收盘价低于前一日最低价，预示着底部反转。
# 例子：integer = CDLCONCEALBABYSWALL(open, high, low, close)
resDF['CDLCONCEALBABYSWALL'] = ta.CDLCONCEALBABYSWALL(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLCOUNTERATTACK
# 名称：Counterattack 反击线
# 简介：二日K线模式，与分离线类似。
# 例子：integer = CDLCOUNTERATTACK(open, high, low, close)
resDF['CDLCOUNTERATTACK'] = ta.CDLCOUNTERATTACK(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLDARKCLOUDCOVER名称：Dark Cloud Cover 乌云压顶
# 简介：二日K线模式，第一日长阳，第二日开盘价高于前一日最高价，收盘价处于前一日实体中部以下，预示着股价下跌。
# 例子：integer = CDLDARKCLOUDCOVER(open, high, low, close, penetration=0)
resDF['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名： CDLDOJI
# 名称：Doji 十字
# 简介：一日K线模式，开盘价与收盘价基本相同。
# 例子：integer = CDLDOJI(open, high, low, close)
resDF['CDLDOJI'] = ta.CDLDOJI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名： CDLDOJISTAR
# 名称：Doji Star 十字星
# 简介：一日K线模式，开盘价与收盘价基本相同，上下影线不会很长，预示着当前趋势反转。
# 例子：integer = CDLDOJISTAR(open, high, low, close)
resDF['CDLDOJISTAR'] = ta.CDLDOJISTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLDRAGONFLYDOJI名称：Dragonfly Doji 蜻蜓十字/T形十字
# 简介：一日K线模式，开盘后价格一路走低，之后收复，收盘价与开盘价相同，预示趋势反转。
# 例子：integer = CDLDRAGONFLYDOJI(open, high, low, close)
resDF['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLENGULFING名称：Engulfing Pattern 吞噬模式
# 简介：两日K线模式，分多头吞噬和空头吞噬，以多头吞噬为例，第一日为阴线，第二日阳线，第一日的开盘价和收盘价在第二日开盘价收盘价之内，但不能完全相同。
# 例子：integer = CDLENGULFING(open, high, low, close)
resDF['CDLENGULFING'] = ta.CDLENGULFING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLEVENINGDOJISTAR名称：Evening Doji Star 十字暮星
# 简介：三日K线模式，基本模式为暮星，第二日收盘价和开盘价相同，预示顶部反转。
# 例子：integer = CDLEVENINGDOJISTAR(open, high, low, close, penetration=0)
resDF['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLEVENINGSTAR名称：Evening Star 暮星
# 简介：三日K线模式，与晨星相反，上升趋势中，第一日阳线，第二日价格振幅较小，第三日阴线，预示顶部反转。
# 例子：integer = CDLEVENINGSTAR(open, high, low, close, penetration=0)
resDF['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLGAPSIDESIDEWHITE名称：Up/Down-gap side-by-side white lines 向上/下跳空并列阳线
# 简介：二日K线模式，上升趋势向上跳空，下跌趋势向下跳空，第一日与第二日有相同开盘价，实体长度差不多，则趋势持续。
# 例子：integer = CDLGAPSIDESIDEWHITE(open, high, low, close)
resDF['CDLGAPSIDESIDEWHITE'] = ta.CDLGAPSIDESIDEWHITE(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLGRAVESTONEDOJI名称：Gravestone Doji 墓碑十字/倒T十字
# 简介：一日K线模式，开盘价与收盘价相同，上影线长，无下影线，预示底部反转。
# 例子：integer = CDLGRAVESTONEDOJI(open, high, low, close)
resDF['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLHAMMER
# 名称：Hammer 锤头
# 简介：一日K线模式，实体较短，无上影线，下影线大于实体长度两倍，处于下跌趋势底部，预示反转。
# 例子：integer = CDLHAMMER(open, high, low, close)
resDF['CDLHAMMER'] = ta.CDLHAMMER(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHANGINGMAN
# 名称：Hanging Man 上吊线
# 简介：一日K线模式，形状与锤子类似，处于上升趋势的顶部，预示着趋势反转。
# 例子：integer = CDLHANGINGMAN(open, high, low, close)
resDF['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHARAMI名称：Harami Pattern 母子线
# 简介：二日K线模式，分多头母子与空头母子，两者相反，以多头母子为例，在下跌趋势中，第一日K线长阴，第二日开盘价收盘价在第一日价格振幅之内，为阳线，预示趋势反转，股价上升。
# 例子：integer = CDLHARAMI(open, high, low, close)
resDF['CDLHARAMI'] = ta.CDLHARAMI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHARAMICROSS名称：Harami Cross Pattern 十字孕线
# 简介：二日K线模式，与母子县类似，若第二日K线是十字线，便称为十字孕线，预示着趋势反转。
# 例子：integer = CDLHARAMICROSS(open, high, low, close)
resDF['CDLHARAMICROSS'] = ta.CDLHARAMICROSS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIGHWAVE
# 名称：High-Wave Candle 风高浪大线
# 简介：三日K线模式，具有极长的上/下影线与短的实体，预示着趋势反转。
# 例子：integer = CDLHIGHWAVE(open, high, low, close)
resDF['CDLHIGHWAVE'] = ta.CDLHIGHWAVE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIKKAKE名称：Hikkake Pattern 陷阱
# 简介：三日K线模式，与母子类似，第二日价格在前一日实体范围内，第三日收盘价高于前两日，反转失败，趋势继续。
# 例子：integer = CDLHIKKAKE(open, high, low, close)
resDF['CDLHIKKAKE'] = ta.CDLHIKKAKE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIKKAKEMOD名称：Modified Hikkake Pattern 修正陷阱
# 简介：三日K线模式，与陷阱类似，上升趋势中，第三日跳空高开；下跌趋势中，第三日跳空低开，反转失败，趋势继续。
# 例子：integer = CDLHIKKAKEMOD(open, high, low, close)
resDF['CDLHIKKAKEMOD'] = ta.CDLHIKKAKEMOD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHOMINGPIGEON名称：Homing Pigeon 家鸽
# 简介：二日K线模式，与母子线类似，不同的的是二日K线颜色相同，第二日最高价、最低价都在第一日实体之内，预示着趋势反转。
# 例子：integer = CDLHOMINGPIGEON(open, high, low, close)
resDF['CDLHOMINGPIGEON'] = ta.CDLHOMINGPIGEON(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLIDENTICAL3CROWS名称：Identical Three Crows 三胞胎乌鸦
# 简介：三日K线模式，上涨趋势中，三日都为阴线，长度大致相等，每日开盘价等于前一日收盘价，收盘价接近当日最低价，预示价格下跌。
# 例子：integer = CDLIDENTICAL3CROWS(open, high, low, close)
resDF['CDLIDENTICAL3CROWS'] = ta.CDLIDENTICAL3CROWS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLINNECK名称：In-Neck Pattern 颈内线
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日开盘价较低，收盘价略高于第一日收盘价，阳线，实体较短，预示着下跌继续。
# 例子：integer = CDLINNECK(open, high, low, close)
resDF['CDLINNECK'] = ta.CDLINNECK(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLINVERTEDHAMMER名称：Inverted Hammer 倒锤头
# 简介：一日K线模式，上影线较长，长度为实体2倍以上，无下影线，在下跌趋势底部，预示着趋势反转。
# 例子：integer = CDLINVERTEDHAMMER(open, high, low, close)
resDF['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLKICKING
# 名称：Kicking 反冲形态
# 简介：二日K线模式，与分离线类似，两日K线为秃线，颜色相反，存在跳空缺口。
# 例子：integer = CDLKICKING(open, high, low, close)
resDF['CDLKICKING'] = ta.CDLKICKING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLKICKINGBYLENGTH名称：Kicking - bull/bear determined by the longer marubozu 由较长缺影线决定的反冲形态
# 简介：二日K线模式，与反冲形态类似，较长缺影线决定价格的涨跌。
# 例子：integer = CDLKICKINGBYLENGTH(open, high, low, close)
resDF['CDLKICKINGBYLENGTH'] = ta.CDLKICKINGBYLENGTH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLADDERBOTTOM名称：Ladder Bottom 梯底
# 简介：五日K线模式，下跌趋势中，前三日阴线，开盘价与收盘价皆低于前一日开盘、收盘价，第四日倒锤头，第五日开盘价高于前一日开盘价，阳线，收盘价高于前几日价格振幅，预示着底部反转。
# 例子：integer = CDLLADDERBOTTOM(open, high, low, close)
resDF['CDLLADDERBOTTOM'] = ta.CDLLADDERBOTTOM(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLONGLEGGEDDOJI名称：Long Legged Doji 长脚十字
# 简介：一日K线模式，开盘价与收盘价相同居当日价格中部，上下影线长，表达市场不确定性。
# 例子：integer = CDLLONGLEGGEDDOJI(open, high, low, close)
resDF['CDLLONGLEGGEDDOJI'] = ta.CDLLONGLEGGEDDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLONGLINE
# 名称：Long Line Candle 长蜡烛
# 简介：一日K线模式，K线实体长，无上下影线。
# 例子：integer = CDLLONGLINE(open, high, low, close)
resDF['CDLLONGLINE'] = ta.CDLLONGLINE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMARUBOZU
# 名称：Marubozu 光头光脚/缺影线
# 简介：一日K线模式，上下两头都没有影线的实体，阴线预示着熊市持续或者牛市反转，阳线相反。
# 例子：integer = CDLMARUBOZU(open, high, low, close)
resDF['CDLMARUBOZU'] = ta.CDLMARUBOZU(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMATCHINGLOW名称：Matching Low 相同低价
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日阴线，收盘价与前一日相同，预示底部确认，该价格为支撑位。
# 例子：integer = CDLMATCHINGLOW(open, high, low, close)
resDF['CDLMATCHINGLOW'] = ta.CDLMATCHINGLOW(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMATHOLD名称：Mat Hold 铺垫
# 简介：五日K线模式，上涨趋势中，第一日阳线，第二日跳空高开影线，第三、四日短实体影线，第五日阳线，收盘价高于前四日，预示趋势持续。
# 例子：integer = CDLMATHOLD(open, high, low, close, penetration=0)
resDF['CDLMATHOLD'] = ta.CDLMATHOLD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLMORNINGDOJISTAR名称：Morning Doji Star 十字晨星
# 简介：三日K线模式，基本模式为晨星，第二日K线为十字星，预示底部反转。
# 例子：integer = CDLMORNINGDOJISTAR(open, high, low, close, penetration=0)
resDF['CDLMORNINGDOJISTAR'] = ta.CDLMORNINGDOJISTAR(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLMORNINGSTAR名称：Morning Star 晨星
# 简介：三日K线模式，下跌趋势，第一日阴线，第二日价格振幅较小，第三天阳线，预示底部反转。
# 例子：integer = CDLMORNINGSTAR(open, high, low, close, penetration=0)
resDF['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLONNECK名称：On-Neck Pattern 颈上线
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日开盘价较低，收盘价与前一日最低价相同，阳线，实体较短，预示着延续下跌趋势。
# 例子：integer = CDLONNECK(open, high, low, close)
resDF['CDLONNECK'] = ta.CDLONNECK(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLPIERCING名称：Piercing Pattern 刺透形态
# 简介：两日K线模式，下跌趋势中，第一日阴线，第二日收盘价低于前一日最低价，收盘价处在第一日实体上部，预示着底部反转。
# 例子：integer = CDLPIERCING(open, high, low, close)
resDF['CDLPIERCING'] = ta.CDLPIERCING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLRICKSHAWMAN名称：Rickshaw Man 黄包车夫
# 简介：一日K线模式，与长腿十字线类似，若实体正好处于价格振幅中点，称为黄包车夫。
# 例子：integer = CDLRICKSHAWMAN(open, high, low, close)
resDF['CDLRICKSHAWMAN'] = ta.CDLRICKSHAWMAN(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLRISEFALL3METHODS名称：Rising/Falling Three Methods 上升/下降三法
# 简介： 五日K线模式，以上升三法为例，上涨趋势中，第一日长阳线，中间三日价格在第一日范围内小幅震荡，第五日长阳线，收盘价高于第一日收盘价，预示股价上升。
# 例子：integer = CDLRISEFALL3METHODS(open, high, low, close)
resDF['CDLRISEFALL3METHODS'] = ta.CDLRISEFALL3METHODS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSEPARATINGLINES名称：Separating Lines 分离线
# 简介：二日K线模式，上涨趋势中，第一日阴线，第二日阳线，第二日开盘价与第一日相同且为最低价，预示着趋势继续。
# 例子：integer = CDLSEPARATINGLINES(open, high, low, close)
resDF['CDLSEPARATINGLINES'] = ta.CDLSEPARATINGLINES(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSHOOTINGSTAR名称：Shooting Star 射击之星
# 简介：一日K线模式，上影线至少为实体长度两倍，没有下影线，预示着股价下跌
# 例子：integer = CDLSHOOTINGSTAR(open, high, low, close)
resDF['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSHORTLINE
# 名称：Short Line Candle 短蜡烛
# 简介：一日K线模式，实体短，无上下影线。
# 例子：integer = CDLSHORTLINE(open, high, low, close)
resDF['CDLSHORTLINE'] = ta.CDLSHORTLINE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLSPINNINGTOP
# 名称：Spinning Top 纺锤
# 简介：一日K线，实体小。
# 例子：integer = CDLSPINNINGTOP(open, high, low, close)
resDF['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLSTALLEDPATTERN名称：Stalled Pattern 停顿形态
# 简介：三日K线模式，上涨趋势中，第二日长阳线，第三日开盘于前一日收盘价附近，短阳线，预示着上涨结束。
# 例子：integer = CDLSTALLEDPATTERN(open, high, low, close)
resDF['CDLSTALLEDPATTERN'] = ta.CDLSTALLEDPATTERN(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSTICKSANDWICH名称：Stick Sandwich 条形三明治
# 简介：三日K线模式，第一日长阴线，第二日阳线，开盘价高于前一日收盘价，第三日开盘价高于前两日最高价，收盘价于第一日收盘价相同。
# 例子：integer = CDLSTICKSANDWICH(open, high, low, close)
resDF['CDLSTICKSANDWICH'] = ta.CDLSTICKSANDWICH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLTAKURI名称：Takuri (Dragonfly Doji with very long lower shadow) 探水竿
# 简介：一日K线模式，大致与蜻蜓十字相同，下影线长度长。
# 例子：integer = CDLTAKURI(open, high, low, close)
resDF['CDLTAKURI'] = ta.CDLTAKURI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTASUKIGAP名称：Tasuki Gap 跳空并列阴阳线
# 简介：三日K线模式，分上涨和下跌，以上升为例，前两日阳线，第二日跳空，第三日阴线，收盘价于缺口中，上升趋势持续。
# 例子：integer = CDLTASUKIGAP(open, high, low, close)
resDF['CDLTASUKIGAP'] = ta.CDLTASUKIGAP(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTHRUSTING名称：Thrusting Pattern 插入
# 简介：二日K线模式，与颈上线类似，下跌趋势中，第一日长阴线，第二日开盘价跳空，收盘价略低于前一日实体中部，与颈上线相比实体较长，预示着趋势持续。
# 例子：integer = CDLTHRUSTING(open, high, low, close)
resDF['CDLTHRUSTING'] = ta.CDLTHRUSTING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTRISTAR
# 名称：Tristar Pattern 三星
# 简介：三日K线模式，由三个十字组成，第二日十字必须高于或者低于第一日和第三日，预示着反转。
# 例子：integer = CDLTRISTAR(open, high, low, close)
resDF['CDLTRISTAR'] = ta.CDLTRISTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLUNIQUE3RIVER名称：Unique 3 River 奇特三河床
# 简介：三日K线模式，下跌趋势中，第一日长阴线，第二日为锤头，最低价创新低，第三日开盘价低于第二日收盘价，收阳线，收盘价不高于第二日收盘价，预示着反转，第二日下影线越长可能性越大。
# 例子：integer = CDLUNIQUE3RIVER(open, high, low, close)
resDF['CDLUNIQUE3RIVER'] = ta.CDLUNIQUE3RIVER(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLUPSIDEGAP2CROWS名称：Upside Gap Two Crows 向上跳空的两只乌鸦
# 简介：三日K线模式，第一日阳线，第二日跳空以高于第一日最高价开盘，收阴线，第三日开盘价高于第二日，收阴线，与第一日比仍有缺口。
# 例子：integer = CDLUPSIDEGAP2CROWS(open, high, low, close)
resDF['CDLUPSIDEGAP2CROWS'] = ta.CDLUPSIDEGAP2CROWS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLXSIDEGAP3METHODS名称：Upside/Downside Gap Three Methods 上升/下降跳空三法
# 简介：五日K线模式，以上升跳空三法为例，上涨趋势中，第一日长阳线，第二日短阳线，第三日跳空阳线，第四日阴线，开盘价与收盘价于前两日实体内，第五日长阳线，收盘价高于第一日收盘价，预示股价上升。
# 例子：integer = CDLXSIDEGAP3METHODS(open, high, low, close)
resDF['CDLXSIDEGAP3METHODS'] = ta.CDLXSIDEGAP3METHODS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
resDF['CMO'] = ta.CMO(df['price'].values, timeperiod=14)
resDF['CORREL'] = ta.CORREL(df['max_price'].values,
df['min_price'].values,
timeperiod=30)
resDF['DEMA'] = ta.DEMA(df['price'].values, timeperiod=30)
resDF['DX'] = ta.DX(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['EMA'] = ta.EMA(df['price'].values, timeperiod=30)
resDF['HT_DCPERIOD'] = ta.HT_DCPERIOD(df['price'].values)
resDF['HT_DCPHASE'] = ta.HT_DCPHASE(df['price'].values)
resDF['inphase'], resDF['quadrature'] = ta.HT_PHASOR(df['price'].values)
resDF['sine'], resDF['leadsine'] = ta.HT_SINE(df['price'].values)
resDF['HT_TRENDLINE'] = ta.HT_TRENDLINE(df['price'].values)
resDF['HT_TRENDMODE'] = ta.HT_TRENDMODE(df['price'].values)
resDF['KAMA'] = ta.KAMA(df['price'].values, timeperiod=30)
resDF['LINEARREG'] = ta.LINEARREG(df['price'].values, timeperiod=14)
resDF['LINEARREG_ANGLE'] = ta.LINEARREG_ANGLE(df['price'].values,
timeperiod=14)
resDF['LINEARREG_INTERCEPT'] = ta.LINEARREG_INTERCEPT(df['price'].values,
timeperiod=14)
resDF['LINEARREG_SLOPE'] = ta.LINEARREG_SLOPE(df['price'].values,
timeperiod=14)
resDF['MA'] = ta.MA(df['price'].values, timeperiod=30, matype=0)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACD(
df['price'].values, fastperiod=12, slowperiod=26, signalperiod=9)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACDEXT(
df['price'].values,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACDFIX(
df['price'].values, signalperiod=9)
#resDF['mama'], resDF['fama'] = ta.MAMA (df['price'].values, fastlimit=0, slowlimit=0)
resDF['MAX'] = ta.MAX(df['price'].values, timeperiod=30)
resDF['MAXINDEX'] = ta.MAXINDEX(df['price'].values, timeperiod=30)
resDF['MEDPRICE'] = ta.MEDPRICE(df['max_price'].values,
df['min_price'].values)
resDF['MFI'] = ta.MFI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['MIDPOINT'] = ta.MIDPOINT(df['price'].values, timeperiod=14)
resDF['MIDPRICE'] = ta.MIDPRICE(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['MIN'] = ta.MIN(df['price'].values, timeperiod=30)
resDF['MININDEX'] = ta.MININDEX(df['price'].values, timeperiod=30)
resDF['min'], resDF['max'] = ta.MINMAX(df['price'].values, timeperiod=30)
resDF['minidx'], resDF['maxidx'] = ta.MINMAXINDEX(df['price'].values,
timeperiod=30)
resDF['MINUS_DI'] = ta.MINUS_DI(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['MINUS_DM'] = ta.MINUS_DM(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['MOM'] = ta.MOM(df['max_price'].values, timeperiod=10)
resDF['NATR'] = ta.NATR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
# 函数名：OBV 名称：On Balance Volume 能量潮
# 简介：Joe Granville提出，通过统计成交量变动的趋势推测股价趋势计算公式：以某日为基期，逐日累计每日上市股票总成交量，若隔日指数或股票上涨，则基期OBV加上本日成交量为本日OBV。隔日指数或股票下跌，则基期OBV减去本日成交量为本日OBV
# 研判：1、以“N”字型为波动单位，一浪高于一浪称“上升潮”，下跌称“跌潮”；上升潮买进，跌潮卖出
# 2、须配合K线图走势
# 3、用多空比率净额法进行修正，但不知TA-Lib采用哪种方法
# 多空比率净额= [（收盘价－最低价）－（最高价-收盘价）] ÷（ 最高价－最低价）×成交量
# 例子：real = OBV(close, volume)
resDF['OBV'] = ta.OBV(df['price'].values, df['vol'].values)
# resDF['PLUS_DI'] = ta.PLUS_DI
# resDF['PLUS_DM'] = ta.PLUS_DM
resDF['PPO'] = ta.PPO(df['price'].values,
fastperiod=12,
slowperiod=26,
matype=0)
resDF['ROC'] = ta.ROC(df['price'].values, timeperiod=10)
resDF['ROCP'] = ta.ROCP(df['price'].values, timeperiod=10)
resDF['ROCR'] = ta.ROCR(df['price'].values, timeperiod=10)
resDF['ROCR100'] = ta.ROCR100(df['price'].values, timeperiod=10)
resDF['RSI'] = ta.RSI(df['price'].values, timeperiod=14)
resDF['SAR'] = ta.SAR(df['max_price'].values,
df['min_price'].values,
acceleration=0,
maximum=0)
resDF['SAREXT'] = ta.SAREXT(df['max_price'].values,
df['min_price'].values,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
resDF['SMA'] = ta.SMA(df['price'].values, timeperiod=30)
resDF['STDDEV'] = ta.STDDEV(df['price'].values, timeperiod=5, nbdev=1)
# resDF['STOCH'] = ta.STOCH
# resDF['STOCHF'] = ta.STOCHF
resDF['fastk'], resDF['fastd'] = ta.STOCHRSI(df['price'].values,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
resDF['SUM'] = ta.SUM(df['price'].values, timeperiod=30)
resDF['T3'] = ta.T3(df['price'].values, timeperiod=5, vfactor=0)
resDF['TEMA'] = ta.TEMA(df['price'].values, timeperiod=30)
resDF['TRANGE'] = ta.TRANGE(df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['TRIMA'] = ta.TRIMA(df['price'].values, timeperiod=30)
resDF['TRIX'] = ta.TRIX(df['price'].values, timeperiod=30)
resDF['TSF'] = ta.TSF(df['price'].values, timeperiod=14)
resDF['TYPPRICE'] = ta.TYPPRICE(df['max_price'].values,
df['min_price'].values, df['price'].values)
# resDF['ULTOSC'] = ta.ULTOSC
resDF['VAR'] = ta.VAR(df['price'].values, timeperiod=5, nbdev=1)
resDF['WCLPRICE'] = ta.WCLPRICE(df['max_price'].values,
df['min_price'].values, df['price'].values)
# resDF['WILLR'] = ta.WILLR
resDF['WMA'] = ta.WMA(df['price'].values, timeperiod=30)
return resDF
def handle_overlap_studies(args, kax, klines_df, close_times, display_count):
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)
os_key = 'EMA'
if args.EMA:
cs = ['c', 'b', 'm', 'k']
for idx, e_p in enumerate(args.EMA):
if idx >= len(cs):
break
e_p = int(e_p)
emas = talib.EMA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
emas[-display_count:],
cs[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)
os_key = 'MA'
if args.MA:
cs = ['c', 'b', 'm', 'k']
for idx, e_p in enumerate(args.MA):
if idx >= len(cs):
break
e_p = int(e_p)
emas = talib.MA(klines_df["close"], timeperiod=e_p)
kax.plot(close_times,
emas[-display_count:],
cs[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)
def hilbert_transform_inst_trendline(close):
try:
htit_data = talib.HT_TRENDLINE(close)
return htit_data
except Exception as e:
raise (e)
def indicator(filename):
database = pd.read_csv(filename)
close = np.array(database.close)
high = np.array(database.high)
low = np.array(database.low)
volume = np.array(database.volume)
o = np.array(database.open)
#简单区分其到底处于什么区间内
Add('OPEN', o)
Add('HIGH', high)
Add('LOW', low)
Add('CLOSE', close)
Add('VOLUME', volume)
upperband, middleband, lowerband = talib.BBANDS(close,
timeperiod=20,
nbdevup=2,
nbdevdn=2,
matype=0)
Length = len(upperband)
increase = []
for i in range(0, Length):
if math.isnan(upperband[i]):
increase.append(np.nan)
else:
increase.append(upperband[i] - middleband[i])
Add('BBANDS', np.asarray(increase))
real = talib.DEMA(close, timeperiod=10)
real1 = talib.DEMA(close, timeperiod=20)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('DEMA', real0)
real = talib.EMA(close, timeperiod=5)
real1 = talib.EMA(close, timeperiod=10)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('EMA', real0)
#暂时不会用这个指标
real = talib.HT_TRENDLINE(close)
Add('HT_TRENDLINE', real)
real = talib.KAMA(close, timeperiod=30)
real1 = talib.KAMA(close, timeperiod=60)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('KAMA', real0)
real = talib.MA(close, timeperiod=7, matype=0)
real1 = talib.MA(close, timeperiod=14, matype=0)
real0 = []
for i in range(Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('MA', real0)
#暂时没找到怎么去用
mama, fama = talib.MAMA(close, fastlimit=0.5, slowlimit=0.05)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(mama[i] - fama[i])
else:
real0.append(np.nan)
Add('MAMA', np.asarray(real0))
#没找到
real = talib.MIDPOINT(close, timeperiod=14)
Add('MIDPOINT', real)
#没找到
real = talib.MIDPRICE(high, low, timeperiod=14)
Add('MIDPRICE', real)
real = talib.SAR(high, low, acceleration=0, maximum=0)
real0 = []
for i in range(0, Length):
if not math.isnan(real[i]):
real0.append(close[i] - real[i])
else:
real0.append(np.nan)
Add('SAR', real0)
#暂时不会
real = talib.SAREXT(high,
low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
Add('SAREXT', real)
real = talib.SMA(close, timeperiod=3)
real1 = talib.SMA(close, timeperiod=5)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('SMA', real0)
#暂时不懂
real = talib.T3(close, timeperiod=5, vfactor=0)
Add('T3', real)
real = talib.TEMA(close, timeperiod=7)
real1 = talib.TEMA(close, timeperiod=14)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('TEMA', real0)
real = talib.TRIMA(close, timeperiod=7)
real1 = talib.TRIMA(close, timeperiod=14)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('TRIMA', real0)
real = talib.WMA(close, timeperiod=7)
real1 = talib.WMA(close, timeperiod=14)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('WMA', real0)
#ADX与ADXR的关系需要注意一下
real = talib.ADX(high, low, close, timeperiod=14)
Add('ADX', real)
real = talib.ADXR(high, low, close, timeperiod=14)
Add('ADXR', real)
#12个和26个简单移动平均线的差值
real = talib.APO(close, fastperiod=12, slowperiod=26, matype=0)
Add('APO', real)
'''
aroondown, aroonup = talib.AROON(high, low, timeperiod=14)
real0 = []
for i in range(0,Length):
if not(math.isnan(aroondown) or math.isnan(aroonup)):
real0.append(aroonup[i] - aroondown[i])
else:
real0.append(numpy.nan)
Add('AROON',numpy.asarray(real0))
'''
#AROONOSC就是Aroonup-aroondown
real = talib.AROONOSC(high, low, timeperiod=14)
Add('AROONOSC', real)
#不懂
real = talib.BOP(o, high, low, close)
Add('BOP', real)
#
real = talib.CCI(high, low, close, timeperiod=14)
Add('CCI', real)
real = talib.CMO(close, timeperiod=14)
Add('CMO', real)
#需要再考虑一下，因为DX代表的市场的活跃度
real = talib.DX(high, low, close, timeperiod=14)
Add('DX', real)
macd, macdsignal, macdhist = talib.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
Add('MACD', macdhist)
macd, macdsignal, macdhist = talib.MACDEXT(close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
Add('MACDEXT', macdhist)
macd, macdsignal, macdhist = talib.MACDFIX(close, signalperiod=9)
Add('MACDFIX', macdhist)
real = talib.MFI(high, low, close, volume, timeperiod=14)
real1 = talib.MA(real, 7)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('MFI', np.asarray(real0))
real = talib.MINUS_DI(high, low, close, timeperiod=14)
real1 = talib.PLUS_DI(high, low, close, timeperiod=14)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real1[i] - real[i])
else:
real0.append(np.nan)
Add('PLUS_DI', np.asarray(real0))
real = talib.MINUS_DM(high, low, timeperiod=14)
Add('MINUS_DM', real)
#虽然大概了解了规则，但在标普500上怎么用还不是很清楚
real = talib.MOM(close, timeperiod=14)
Add('MOM', real)
real = talib.PLUS_DM(high, low, timeperiod=14)
Add('PLUS_DM', real)
#暂时不用
real = talib.PPO(close, fastperiod=12, slowperiod=26, matype=0)
Add('PPO', real)
real = talib.ROC(close, timeperiod=14)
Add('ROC', real)
real = talib.ROCP(close, timeperiod=14)
Add('ROCP', real)
real = talib.ROCR(close, timeperiod=14)
Add('ROCR', real)
real = talib.ROCR100(close, timeperiod=14)
Add('ROCR100', real)
real = talib.RSI(close, timeperiod=14)
Add('RSI', real)
slowk, slowd = talib.STOCH(high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
slowj = []
for i in range(Length):
if not (math.isnan(slowk[i]) or math.isnan(slowd[i])):
slowj.append(3 * slowk[i] - 2 * slowd[i])
else:
slowj.append(np.nan)
Add('STOCH', np.asarray(slowj))
fastk, fastd = talib.STOCHF(high,
low,
close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
fastj = []
for i in range(Length):
if not (math.isnan(fastk[i]) or math.isnan(fastd[i])):
fastj.append(3 * fastk[i] - 2 * fastd[i])
else:
fastj.append(np.nan)
Add('STOCHF', np.asarray(fastj))
fastk, fastd = talib.STOCHRSI(close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
fastj = []
for i in range(Length):
if not (math.isnan(fastk[i]) or math.isnan(fastd[i])):
fastj.append(3 * fastk[i] - 2 * fastd[i])
else:
fastj.append(np.nan)
Add('STOCHRSI', np.asarray(fastj))
real = talib.TRIX(close, timeperiod=30)
real1 = talib.MA(real, 6)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i] or math.isnan(real1[i]))):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('TRIX', real)
real = talib.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
Add('ULTOSC', real)
real = talib.WILLR(high, low, close, timeperiod=14)
real0 = []
for i in range(0, Length):
if not math.isnan(real[i]):
if real[i] > -20:
real0.append(1.0)
elif real[i] < -80:
real0.append(-1.0)
else:
real0.append(0.0)
else:
real0.append(np.nan)
Add('WILLR', np.asarray(real0))
real = talib.AD(high, low, close, volume)
real1 = talib.MA(real, 6)
real0 = []
for i in range(0, Length):
if not (math.isnan(real[i]) or math.isnan(real1[i])):
real0.append(real[i] - real1[i])
else:
real0.append(np.nan)
Add('AD', np.asarray(real0))
real = talib.ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
Add('ADOSC', real)
#对于每个指标的处理还是很有问题的呀
real = talib.OBV(close, volume)
Add('OBV', real)
real = talib.ATR(high, low, close, timeperiod=14)
Add('ATR', real)
real = talib.NATR(high, low, close, timeperiod=14)
Add('NATR', real)
real = talib.TRANGE(high, low, close)
Add('TRANGE', real)
integer = talib.HT_TRENDMODE(close)
Add('HT_TRENDMODE', integer)
real = talib.LINEARREG_SLOPE(close, timeperiod=14)
Add('LINEARREG_SLOPE', real)
real = talib.STDDEV(close, timeperiod=5, nbdev=1)
Add('STDDEV', real)
real = talib.TSF(close, timeperiod=14)
Add('TSF', real)
real = talib.VAR(close, timeperiod=5, nbdev=1)
Add('VAR', real)
real = talib.MEDPRICE(high, low)
Add('MEDPRICE', real)
real = talib.TYPPRICE(high, low, close)
Add('TYPPRICE', real)
real = talib.WCLPRICE(high, low, close)
Add('WCLPRICE', real)
real = talib.DIV(high, low)
Add('DIV', real)
real = talib.MAX(close, timeperiod=30)
Add('MAX', real)
real = talib.MIN(close, timeperiod=30)
Add('MIN', real)
real = talib.SUB(high, low)
Add('SUB', real)
real = talib.SUM(close, timeperiod=30)
Add('SUM', real)
return [dict1, dict2]
def trendline(col):
return {"trendline": ta.HT_TRENDLINE(col)}
def get_indicators(data, intervals=(5, 10, 20, 50, 100)):
"""
Computes technical indicators given ticks data.
These indicators are computed with fixed parameters, i.e. intervals argument shouldn't affect them:
* Parabolic SAR
* Chaikin A/D Line
* On Balance Volume
* Hilbert Transform - Instantaneous Trendline
* Hilbert Transform - Trend vs Cycle Mode
* Hilbert Transform - Dominant Cycle Period
* Hilbert Transform - Dominant Cycle Phase
* Typical Price
These indicators are computed for each of periods given in intervals argument:
* Exponential Moving Average
* Double Exponential Moving Average
* Kaufman Adaptive Moving Average
* Midpoint Price over period
* Triple Exponential Moving Average
* Average Directional Movement Index
* Aroon
* Commodity Channel Index
* Momentum
* Rate of change Percentage: (price-prevPrice)/prevPrice
* Relative Strength Index
* Ultimate Oscillator (based on T, 2T, 3T periods)
* Williams' %R
* Normalized Average True Range
* Time Series Forecast (linear regression)
* Bollinger Bands
For more details see TA-lib documentation.
When there are options in indicator API, Close Price prices are used for computation. For volume TickVol is used.
Note that some of the indicators are not stable and could output unexpected results if fed with NaNs or long series.
:param trader DataFrame with data.
:param intervals Iterable with time periods to use for computation.
Periods should be in the same sample units as ticks data, i.e. in minutes.
Default values: 5, 10, 20, 50 and 100 minutes.
:return DataFrame with indicators. For interval-based indicators, interval is mentioned in column name, e.g. CCI_5.
"""
indicators = {}
# Time period based indicators.
for i in intervals:
indicators['DEMA_{}'.format(i)] = talib.DEMA(data['Close Price'],
timeperiod=i)
indicators['EMA_{}'.format(i)] = talib.EMA(data['Close Price'],
timeperiod=i)
indicators['KAMA_{}'.format(i)] = talib.KAMA(data['Close Price'],
timeperiod=i)
indicators['MIDPRICE_{}'.format(i)] = talib.MIDPRICE(
data['High Price'], data['Low Price'], timeperiod=i)
indicators['T3_{}'.format(i)] = talib.T3(data['Close Price'],
timeperiod=i)
indicators['ADX_{}'.format(i)] = talib.ADX(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod=i)
indicators['AROON_down_{}'.format(i)], indicators['AROON_up_{}'.format(
i)] = talib.AROON(data['High Price'],
data['Low Price'],
timeperiod=i)
indicators['CCI_{}'.format(i)] = talib.CCI(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod=i)
indicators['MOM_{}'.format(i)] = talib.MOM(data['Close Price'],
timeperiod=i)
indicators['ROCP_{}'.format(i)] = talib.ROCP(data['Close Price'],
timeperiod=i)
indicators['RSI_{}'.format(i)] = talib.RSI(data['Close Price'],
timeperiod=i)
indicators['ULTOSC_{}'.format(i)] = talib.ULTOSC(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod1=i,
timeperiod2=2 * i,
timeperiod3=4 * i)
indicators['WILLR_{}'.format(i)] = talib.WILLR(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod=i)
indicators['NATR_{}'.format(i)] = talib.NATR(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod=i)
indicators['TSF_{}'.format(i)] = talib.TSF(data['Close Price'],
timeperiod=i)
indicators['BBANDS_upper_{}'.format(i)], indicators[
'BBANDS_middle_{}'.format(i)], indicators[
'BBANDS_Low Priceer_{}'.format(i)] = talib.BBANDS(
data['Close Price'],
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
indicators['ATR_{}'.format(i)] = talib.ATR(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod=i)
indicators['NATR_{}'.format(i)] = talib.NATR(data['High Price'],
data['Low Price'],
data['Close Price'],
timeperiod=i)
indicators['BETA_{}'.format(i)] = talib.BETA(data['High Price'],
data['Low Price'],
timeperiod=i)
indicators['CORREL_{}'.format(i)] = talib.CORREL(data['High Price'],
data['Low Price'],
timeperiod=1)
indicators['LINEARREG_ANGLE_{}'.format(i)] = talib.LINEARREG_ANGLE(
data['Close Price'], timeperiod=i)
indicators['Close Price_STDDEV_{}'.format(i)] = talib.STDDEV(
data['Close Price'], timeperiod=i)
indicators['High Price_STDDEV_{}'.format(i)] = talib.STDDEV(
data['High Price'], timeperiod=i)
indicators['Low Price_STDDEV_{}'.format(i)] = talib.STDDEV(
data['Low Price'], timeperiod=i)
indicators['Open Price_STDDEV_{}'.format(i)] = talib.STDDEV(
data['Open Price'], timeperiod=i)
indicators['Close Price_VAR_{}'.format(i)] = talib.VAR(
data['Close Price'], timeperiod=i, nbdev=1)
indicators['Open Price_VAR_{}'.format(i)] = talib.VAR(
data['Open Price'], timeperiod=i, nbdev=1)
indicators['High Price_VAR_{}'.format(i)] = talib.VAR(
data['High Price'], timeperiod=i, nbdev=1)
indicators['Low Price_VAR_{}'.format(i)] = talib.VAR(data['Low Price'],
timeperiod=i,
nbdev=1)
# Indicators that do not depend on time periods.
indicators['Close Price_macd'], indicators[
'Close Price_macdsignal'], indicators[
'Close Price_macdhist'] = talib.MACD(data['Close Price'],
fastperiod=12,
slowperiod=26,
signalperiod=9)
indicators['Open Price_macd'], indicators[
'Open Price_macdsignal'], indicators[
'Open Price_macdhist'] = talib.MACD(data['Open Price'],
fastperiod=12,
slowperiod=26,
signalperiod=9)
indicators['High Price_macd'], indicators[
'High Price_macdsignal'], indicators[
'High Price_macdhist'] = talib.MACD(data['High Price'],
fastperiod=12,
slowperiod=26,
signalperiod=9)
indicators['Low Price_macd'], indicators[
'Low Price_macdsignal'], indicators['Low Price_macdhist'] = talib.MACD(
data['Low Price'], fastperiod=12, slowperiod=26, signalperiod=9)
indicators['SAR'] = talib.SAR(data['High Price'], data['Low Price'])
indicators['HT_TRENDLINE'] = talib.HT_TRENDLINE(data['Close Price'])
indicators['HT_TRENDMODE'] = talib.HT_TRENDMODE(data['Close Price'])
indicators['HT_DCPERIOD'] = talib.HT_DCPERIOD(data['Close Price'])
indicators['HT_DCPHASE'] = talib.HT_DCPHASE(data['Close Price'])
indicators['TYPPRICE'] = talib.TYPPRICE(data['High Price'],
data['Low Price'],
data['Close Price'])
return pd.DataFrame(indicators)
def addIndi(self, enrich, endf):
# Overlays
if enrich == 'bbands':
bbup, bbmid, bblow = ta.BBANDS(endf['Close'], timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
endf.insert(0, column='bblow', value=bblow)
endf.insert(0, column='bbmid', value=bbmid)
endf.insert(0, column='bbup', value=bbup)
return endf
if enrich == 'mama':
mama, fama = ta.MAMA(endf['Close'])
endf.insert(0, column='fama', value=fama)
endf.insert(0, column='mama', value=mama)
return endf
if enrich == 'dema':
endf.insert(0, column='dema', value=ta.DEMA(endf['Close'], timeperiod=30))
return endf
if enrich == 'ema':
endf.insert(0, column='ema', value=ta.EMA(endf['Close'], timeperiod=30)) # Unstable period
return endf
if enrich == 'ht_trendline':
endf.insert(0, column='ht_trendline', value=ta.HT_TRENDLINE(endf['Close'])) # Unstable period
return endf
if enrich == 'kama':
endf.insert(0, column='kama', value=ta.KAMA(endf['Close'], timeperiod=30)) # Unstable period
return endf
if enrich == 'ma':
endf.insert(0, column='ma', value=ta.MA(endf['Close'], timeperiod=30, matype=0))
return endf
if enrich == 'midpoint':
endf.insert(0, column='midpoint', value=ta.MIDPOINT(endf['Close'], timeperiod=14))
return endf
if enrich == 'midprice':
endf.insert(0, column='midprice', value=ta.MIDPRICE(endf['High'], endf['Low'], timeperiod=14))
return endf
if enrich == 'sar':
endf.insert(0, column='sar', value=ta.SAR(endf['High'], endf['Low'], acceleration=0, maximum=0))
return endf
if enrich == 'sarext':
endf.insert(0, column='sarext', value=ta.SAREXT(endf['High'], endf['Low'], startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0))
return endf
if enrich == 'sma':
endf.insert(0, column='sma', value=ta.SMA(endf['Close'], timeperiod=30))
return endf
if enrich == 't3':
endf.insert(0, column='t3', value=ta.T3(endf['Close'], timeperiod=5, vfactor=0)) # Unstable period
return endf
if enrich == 'tema':
endf.insert(0, column='tema', value=ta.TEMA(endf['Close'], timeperiod=30))
return endf
if enrich == 'trima':
endf.insert(0, column='trima', value=ta.TRIMA(endf['Close'], timeperiod=30))
return endf
if enrich == 'wma':
endf.insert(0, column='wma', value=ta.WMA(endf['Close'], timeperiod=30))
return endf
# Momentum
if enrich == 'adx':
endf.insert(0, column='adx', value=ta.ADX(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
if enrich == 'adxr':
endf.insert(0, column='adxr', value=ta.ADXR(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
if enrich == 'apo':
endf.insert(0, column='apo', value=ta.APO(endf['Close'], fastperiod=12, slowperiod=26, matype=0))
return endf
if enrich == 'aroonosc':
endf.insert(0, column='aroonosc', value=ta.AROONOSC(endf['High'], endf['Low'], timeperiod=14))
return endf
if enrich == 'aroon':
aroondown, aroonup = ta.AROON(endf['High'], endf['Low'], timeperiod=14)
endf.insert(0, column='aroonup', value=aroonup)
endf.insert(0, column='aroondown', value=aroondown)
return endf
if enrich == 'bop':
endf.insert(0, column='bop', value=ta.BOP(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cci':
endf.insert(0, column='cci', value=ta.CCI(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
if enrich == 'cmo':
endf.insert(0, column='cmo', value=ta.CMO(endf['Close'], timeperiod=14))
return endf
if enrich == 'dx':
endf.insert(0, column='dx', value=ta.DX(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
if enrich == 'macd':
macd, macdsignal, macdhist = ta.MACD(endf['Close'], fastperiod=12, slowperiod=26, signalperiod=9)
endf.insert(0, column='macd', value=macd)
endf.insert(0, column='macdsignal', value=macdsignal)
endf.insert(0, column='macdhist', value=macdhist)
return endf
if enrich == 'mfi':
endf.insert(0, column='mfi', value=ta.MFI(endf['High'], endf['Low'], endf['Close'], endf['Volume'], timeperiod=14))
return endf
if enrich == 'mom':
endf.insert(0, column='mom', value=ta.MOM(endf['Close'], timeperiod=10))
return endf
if enrich == 'ppo':
endf.insert(0, column='ppo', value=ta.PPO(endf['Close'], fastperiod=12, slowperiod=26, matype=0))
return endf
if enrich == 'roc':
endf.insert(0, column='roc', value=ta.ROC(endf['Close'], timeperiod=10))
return endf
if enrich == 'rocp':
endf.insert(0, column='rocp', value=ta.ROCP(endf['Close'], timeperiod=10))
return endf
if enrich == 'rsi':
endf.insert(0, column='rsi', value=ta.RSI(endf['Close'], timeperiod=14))
return endf
if enrich == 'stoch':
slowk, slowd = ta.STOCH(endf['High'], endf['Low'], endf['Close'], fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
endf.insert(0, column='slowk', value=slowk)
endf.insert(0, column='slowd', value=slowd)
return endf
if enrich == 'trix':
endf.insert(0, column='trix', value=ta.TRIX(endf['Close'], timeperiod=30))
return endf
if enrich == 'ultosc':
endf.insert(0, column='ultosc', value=ta.ULTOSC(endf['High'], endf['Low'], endf['Close'], timeperiod1=7, timeperiod2=14, timeperiod3=28))
return endf
if enrich == 'willr':
endf.insert(0, column='willr', value=ta.WILLR(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
# Volume
if enrich == 'ad':
endf.insert(0, column='ad', value=ta.AD(endf['High'], endf['Low'], endf['Close'], endf['Volume']))
return endf
if enrich == 'adosc':
endf.insert(0, column='adosc', value=ta.ADOSC(endf['High'], endf['Low'], endf['Close'], endf['Volume'], fastperiod=3, slowperiod=10))
return endf
if enrich == 'obv':
endf.insert(0, column='obv', value=ta.OBV(endf['Close'], endf['Volume']))
return endf
# Volitility
if enrich == 'atr':
endf.insert(0, column='atr', value=ta.ATR(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
if enrich == 'natr':
endf.insert(0, column='natr', value=ta.NATR(endf['High'], endf['Low'], endf['Close'], timeperiod=14))
return endf
if enrich == 'trange':
endf.insert(0, column='trange', value=ta.TRANGE(endf['High'], endf['Low'], endf['Close']))
return endf
# Pattern
if enrich == 'cdl2crows':
endf.insert(0, column='cdl2crows', value=ta.CDL2CROWS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdl3blackcrows':
endf.insert(0, column='cdl3blackcrows', value=ta.CDL3BLACKCROWS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdl3inside':
endf.insert(0, column='cdl3inside', value=ta.CDL3INSIDE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdl3linestrike':
endf.insert(0, column='cdl3linestrike', value=ta.CDL3LINESTRIKE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdl3outside':
endf.insert(0, column='cdlcdl3outside', value=ta.CDL3OUTSIDE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdl3starsinsouth':
endf.insert(0, column='cdl3starsinsouth', value=ta.CDL3STARSINSOUTH(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdl3whitesoldiers':
endf.insert(0, column='cdl3whitesoldiers', value=ta.CDL3WHITESOLDIERS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlabandonedbaby':
endf.insert(0, column='cdlabandonedbaby', value=ta.CDLABANDONEDBABY(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdladvanceblock':
endf.insert(0, column='cdladvanceblock', value=ta.CDLADVANCEBLOCK(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlbelthold':
endf.insert(0, column='cdlbelthold', value=ta.CDLBELTHOLD(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlbreakaway':
endf.insert(0, column='cdlbreakaway', value=ta.CDLBREAKAWAY(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlclosingmarubozu':
endf.insert(0, column='cdlclosingmarubozu', value=ta.CDLCLOSINGMARUBOZU(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlconcealbabyswall':
endf.insert(0, column='cdlconcealbabyswall', value=ta.CDLCONCEALBABYSWALL(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlcounterattack':
endf.insert(0, column='cdlcounterattack', value=ta.CDLCOUNTERATTACK(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdldarkcloudcover':
endf.insert(0, column='cdldarkcloudcover', value=ta.CDLDARKCLOUDCOVER(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdldoji':
endf.insert(0, column='cdldoji', value=ta.CDLDOJI(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdldojistar':
endf.insert(0, column='cdldojistar', value=ta.CDLDOJISTAR(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdldragonflydoji':
endf.insert(0, column='cdldragonflydoji', value=ta.CDLDRAGONFLYDOJI(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlengulfing':
endf.insert(0, column='cdlengulfing', value=ta.CDLENGULFING(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdleveningdojistar':
endf.insert(0, column='cdleveningdojistar', value=ta.CDLEVENINGDOJISTAR(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdleveningstar':
endf.insert(0, column='cdleveningstar', value=ta.CDLEVENINGSTAR(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdlgapsidesidewhite':
endf.insert(0, column='cdlgapsidesidewhite', value=ta.CDLGAPSIDESIDEWHITE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlgravestonedoji':
endf.insert(0, column='cdlgravestonedoji', value=ta.CDLGRAVESTONEDOJI(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlhammer':
endf.insert(0, column='cdlhammer', value=ta.CDLHAMMER(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlhangingman':
endf.insert(0, column='cdlhangingman', value=ta.CDLHANGINGMAN(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlharami':
endf.insert(0, column='cdlharami', value=ta.CDLHARAMI(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlharamicross':
# print(endf.info(),file=sys.stderr)
endf.insert(0, column='cdlharamicross', value=ta.CDLHARAMICROSS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
# print(endf.info(),file=sys.stderr)
return endf
if enrich == 'cdlhighwave':
print(endf.info(), file=sys.stderr)
endf.insert(0, column='cdlhighwave', value=ta.CDLHIGHWAVE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlhikkake':
endf.insert(0, column='cdlhikkake', value=ta.CDLHIKKAKE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlhikkakemod':
endf.insert(0, column='cdlhikkakemod', value=ta.CDLHIKKAKEMOD(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlhomingpigeon':
endf.insert(0, column='cdlhomingpigeon', value=ta.CDLHOMINGPIGEON(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlidentical3crows':
endf.insert(0, column='cdlidentical3crows', value=ta.CDLIDENTICAL3CROWS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlinneck':
endf.insert(0, column='cdlinneck', value=ta.CDLINNECK(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlinvertedhammer':
endf.insert(0, column='cdlinvertedhammer', value=ta.CDLINVERTEDHAMMER(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlkicking':
endf.insert(0, column='cdlkicking', value=ta.CDLKICKING(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlkickingbylength':
endf.insert(0, column='cdlkickingbylength', value=ta.CDLKICKINGBYLENGTH(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlladderbottom':
endf.insert(0, column='cdlladderbottom', value=ta.CDLLADDERBOTTOM(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdllongleggeddoji':
endf.insert(0, column='cdllongleggeddoji', value=ta.CDLLONGLEGGEDDOJI(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdllongline':
endf.insert(0, column='cdllongline', value=ta.CDLLONGLINE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlmarubozu':
endf.insert(0, column='cdlmarubozu', value=ta.CDLMARUBOZU(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlmatchinglow':
endf.insert(0, column='cdlmatchinglow', value=ta.CDLMATCHINGLOW(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlmathold':
endf.insert(0, column='cdlmathold', value=ta.CDLMATHOLD(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdlmorningdojistar':
endf.insert(0, column='cdlmorningdojistar', value=ta.CDLMORNINGDOJISTAR(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdlmorningstar':
endf.insert(0, column='cdlmorningstar', value=ta.CDLMORNINGSTAR(endf['Open'], endf['High'], endf['Low'], endf['Close'], penetration=0))
return endf
if enrich == 'cdlonneck':
endf.insert(0, column='cdlonneck', value=ta.CDLONNECK(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlpiercing':
endf.insert(0, column='cdlpiercing', value=ta.CDLPIERCING(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlrickshawman':
endf.insert(0, column='cdlrickshawman', value=ta.CDLRICKSHAWMAN(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlrisefall3methods':
endf.insert(0, column='cdlrisefall3methods', value=ta.CDLRISEFALL3METHODS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlseparatinglines':
endf.insert(0, column='cdlseparatinglines', value=ta.CDLSEPARATINGLINES(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlshootingstar':
endf.insert(0, column='cdlshootingstar', value=ta.CDLSHOOTINGSTAR(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlshortline':
endf.insert(0, column='cdlshortline', value=ta.CDLSHORTLINE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlspinningtop':
endf.insert(0, column='cdlspinningtop', value=ta.CDLSPINNINGTOP(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlstalledpattern':
endf.insert(0, column='cdlstalledpattern', value=ta.CDLSTALLEDPATTERN(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlsticksandwich':
endf.insert(0, column='cdlsticksandwich', value=ta.CDLSTICKSANDWICH(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdltakuri':
endf.insert(0, column='cdltakuri', value=ta.CDLTAKURI(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdltasukigap':
endf.insert(0, column='cdltasukigap', value=ta.CDLTASUKIGAP(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlthrusting':
endf.insert(0, column='cdlthrusting', value=ta.CDLTHRUSTING(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdltristar':
endf.insert(0, column='cdltristar', value=ta.CDLTRISTAR(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlunique3river':
endf.insert(0, column='cdlunique3river', value=ta.CDLUNIQUE3RIVER(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlupsidegap2crows':
endf.insert(0, column='cdlupsidegap2crows', value=ta.CDLUPSIDEGAP2CROWS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'cdlxsidegap3methods':
endf.insert(0, column='cdlxsidegap3methods', value=ta.CDLXSIDEGAP3METHODS(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
# Price
if enrich == 'avgprice':
endf.insert(0, column='avgprice', value=ta.AVGPRICE(endf['Open'], endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'medprice':
endf.insert(0, column='medprice', value=ta.MEDPRICE(endf['High'], endf['Low']))
return endf
if enrich == 'typprice':
endf.insert(0, column='typprice', value=ta.TYPPRICE(endf['High'], endf['Low'], endf['Close']))
return endf
if enrich == 'wclprice':
endf.insert(0, column='wclprice', value=ta.WCLPRICE(endf['High'], endf['Low'], endf['Close']))
return endf
# Stats
if enrich == 'beta':
endf.insert(0, column='beta', value=ta.BETA(endf['High'], endf['Low'], timeperiod=5))
return endf
if enrich == 'correl':
endf.insert(0, column='correl', value=ta.CORREL(endf['High'], endf['Low'], timeperiod=30))
return endf
if enrich == 'linearreg':
endf.insert(0, column='linearreg', value=ta.LINEARREG(endf['Close'], timeperiod=14))
return endf
if enrich == 'linearreg_angle':
endf.insert(0, column='linearreg_angle', value=ta.LINEARREG_ANGLE(endf['Close'], timeperiod=14))
return endf
if enrich == 'linearreg_intercept':
endf.insert(0, column='linearreg_intercept', value=ta.LINEARREG_INTERCEPT(endf['Close'], timeperiod=14))
return endf
if enrich == 'linearreg_slope':
endf.insert(0, column='linearreg_slope', value=ta.LINEARREG_SLOPE(endf['Close'], timeperiod=14))
return endf
if enrich == 'stddev':
endf.insert(0, column='stddev', value=ta.STDDEV(endf['Close'], timeperiod=5, nbdev=1))
return endf
if enrich == 'tsf':
endf.insert(0, column='tsf', value=ta.TSF(endf['Close'], timeperiod=14))
return endf
if enrich == 'var':
endf.insert(0, column='var', value=ta.VAR(endf['Close'], timeperiod=5, nbdev=1))
return endf
def get_datasets(asset,
currency,
granularity,
datapoints,
exchange,
df_train_size=0.75):
"""Fetch the API and precess the desired pair
Arguments:
asset {str} -- First pair
currency {str} -- Second pair
granularity {str ['day', 'hour']} -- Granularity
datapoints {int [100 - 2000]} -- [description]
Returns:
pandas.Dataframe -- The OHLCV and indicators dataframe
"""
load_dotenv()
CRYPTOCOMPARE_API_KEY = os.getenv('CRYPTOCOMPARE_API_KEY')
if not CRYPTOCOMPARE_API_KEY:
raise EnvironmentError('CRYPTOCOMPARE_API_KEY not found on .env')
df_train_path = 'data/bot_train_{}_{}_{}.csv'.format(
asset + currency, datapoints, granularity)
df_rollout_path = 'data/bot_rollout_{}_{}_{}.csv'.format(
asset + currency, datapoints, granularity)
if not os.path.exists(df_rollout_path):
headers = {
'User-Agent': 'Mozilla/5.0',
'authorization': 'Apikey {}'.format(CRYPTOCOMPARE_API_KEY)
}
url = 'https://min-api.cryptocompare.com/data/histo{}?fsym={}&tsym={}&limit={}&e={}'.format(
granularity, asset, currency, datapoints, exchange)
with yaspin(text='Downloading datasets') as sp:
response = requests.get(url, headers=headers)
sp.hide()
print_formatted_text(HTML(
u'<b>></b> <msg>{}/{}</msg> <sub-msg>download complete</sub-msg>'
.format(asset, currency)),
style=style)
sp.show()
json_response = response.json()
status = json_response['Response']
if status == "Error":
raise AssertionError(colored(json_response['Message'], 'red'))
result = json_response['Data']
df = pd.DataFrame(result)
# print(df.tail())
df['Date'] = pd.to_datetime(df['time'], utc=True, unit='s')
df.drop('time', axis=1, inplace=True)
# indicators
# https://github.com/mrjbq7/ta-lib/blob/master/docs/func.md
open_price, high, low, close = np.array(df['open']), np.array(
df['high']), np.array(df['low']), np.array(df['close'])
volume = np.array(df['volumefrom'], dtype=float)
# cycle indicators
df.loc[:, 'HT_DCPERIOD'] = talib.HT_DCPERIOD(close)
df.loc[:, 'HT_DCPHASE'] = talib.HT_DCPHASE(close)
df.loc[:,
'HT_PHASOR_inphase'], df.loc[:,
'HT_PHASOR_quadrature'] = talib.HT_PHASOR(
close)
df.loc[:, 'HT_SINE_sine'], df.loc[:,
'HT_SINE_leadsine'] = talib.HT_SINE(
close)
df.loc[:, 'HT_TRENDMODE'] = talib.HT_TRENDMODE(close)
# momemtum indicators
df.loc[:, 'ADX'] = talib.ADX(high, low, close, timeperiod=12)
df.loc[:, 'ADXR'] = talib.ADXR(high, low, close, timeperiod=13)
df.loc[:, 'APO'] = talib.APO(close,
fastperiod=5,
slowperiod=10,
matype=0)
df.loc[:,
'AROON_down'], df.loc[:,
'AROON_up'] = talib.AROON(high,
low,
timeperiod=15)
df.loc[:, 'AROONOSC'] = talib.AROONOSC(high, low, timeperiod=13)
df.loc[:, 'BOP'] = talib.BOP(open_price, high, low, close)
df.loc[:, 'CCI'] = talib.CCI(high, low, close, timeperiod=13)
df.loc[:, 'CMO'] = talib.CMO(close, timeperiod=14)
df.loc[:, 'DX'] = talib.DX(high, low, close, timeperiod=10)
df['MACD'], df['MACD_signal'], df['MACD_hist'] = talib.MACD(
close, fastperiod=5, slowperiod=10, signalperiod=20)
df.loc[:, 'MFI'] = talib.MFI(high, low, close, volume, timeperiod=12)
df.loc[:, 'MINUS_DI'] = talib.MINUS_DI(high, low, close, timeperiod=10)
df.loc[:, 'MINUS_DM'] = talib.MINUS_DM(high, low, timeperiod=14)
df.loc[:, 'MOM'] = talib.MOM(close, timeperiod=20)
df.loc[:, 'PPO'] = talib.PPO(close,
fastperiod=17,
slowperiod=35,
matype=2)
df.loc[:, 'ROC'] = talib.ROC(close, timeperiod=12)
df.loc[:, 'RSI'] = talib.RSI(close, timeperiod=25)
df.loc[:, 'STOCH_k'], df.loc[:,
'STOCH_d'] = talib.STOCH(high,
low,
close,
fastk_period=35,
slowk_period=12,
slowk_matype=0,
slowd_period=7,
slowd_matype=0)
df.loc[:,
'STOCHF_k'], df.loc[:,
'STOCHF_d'] = talib.STOCHF(high,
low,
close,
fastk_period=28,
fastd_period=14,
fastd_matype=0)
df.loc[:, 'STOCHRSI_K'], df.loc[:, 'STOCHRSI_D'] = talib.STOCHRSI(
close,
timeperiod=35,
fastk_period=12,
fastd_period=10,
fastd_matype=1)
df.loc[:, 'TRIX'] = talib.TRIX(close, timeperiod=30)
df.loc[:, 'ULTOSC'] = talib.ULTOSC(high,
low,
close,
timeperiod1=14,
timeperiod2=28,
timeperiod3=35)
df.loc[:, 'WILLR'] = talib.WILLR(high, low, close, timeperiod=35)
# overlap studies
df.loc[:,
'BBANDS_upper'], df.loc[:,
'BBANDS_middle'], df.loc[:,
'BBANDS_lower'] = talib.BBANDS(
close,
timeperiod=
12,
nbdevup=2,
nbdevdn=2,
matype=0)
df.loc[:, 'DEMA'] = talib.DEMA(close, timeperiod=30)
df.loc[:, 'EMA'] = talib.EMA(close, timeperiod=7)
df.loc[:, 'HT_TRENDLINE'] = talib.HT_TRENDLINE(close)
df.loc[:, 'KAMA'] = talib.KAMA(close, timeperiod=5)
df.loc[:, 'MA'] = talib.MA(close, timeperiod=5, matype=0)
df.loc[:, 'MIDPOINT'] = talib.MIDPOINT(close, timeperiod=20)
df.loc[:, 'WMA'] = talib.WMA(close, timeperiod=15)
df.loc[:, 'SMA'] = talib.SMA(close)
# pattern recoginition
df.loc[:, 'CDL2CROWS'] = talib.CDL2CROWS(open_price, high, low, close)
df.loc[:, 'CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(
open_price, high, low, close)
df.loc[:, 'CDL3INSIDE'] = talib.CDL3INSIDE(open_price, high, low,
close)
df.loc[:, 'CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(
open_price, high, low, close)
# price transform
df.loc[:, 'WCLPRICE'] = talib.WCLPRICE(high, low, close)
# statistic funcitons
df.loc[:, 'BETA'] = talib.BETA(high, low, timeperiod=20)
df.loc[:, 'CORREL'] = talib.CORREL(high, low, timeperiod=20)
df.loc[:, 'STDDEV'] = talib.STDDEV(close, timeperiod=20, nbdev=1)
df.loc[:, 'TSF'] = talib.TSF(close, timeperiod=20)
df.loc[:, 'VAR'] = talib.VAR(close, timeperiod=20, nbdev=1)
# volatility indicators
df.loc[:, 'ATR'] = talib.ATR(high, low, close, timeperiod=7)
df.loc[:, 'NATR'] = talib.NATR(high, low, close, timeperiod=20)
df.loc[:, 'TRANGE'] = talib.TRANGE(high, low, close)
# volume indicators
df.loc[:, 'AD'] = talib.AD(high, low, close, volume)
df.loc[:, 'ADOSC'] = talib.ADOSC(high,
low,
close,
volume,
fastperiod=10,
slowperiod=20)
df.loc[:, 'OBV'] = talib.OBV(close, volume)
# df.fillna(df.mean(), inplace=True)
df.dropna(inplace=True)
df.set_index('Date', inplace=True)
# print(colored('> caching' + asset + '/' + currency + ':)', 'cyan'))
# 75% to train -> test with different value
train_size = round(len(df) * df_train_size)
df_train = df[:train_size]
df_rollout = df[train_size:]
df_train.to_csv(df_train_path)
df_rollout.to_csv(df_rollout_path)
# re-read to avoid indexing issue w/ Ray
df_train = pd.read_csv(df_train_path)
df_rollout = pd.read_csv(df_rollout_path)
else:
print_formatted_text(HTML(
u'<b>></b> <msg>{}/{}</msg> <sub-msg>cached</sub-msg>'.format(
asset, currency)),
style=style)
# print(colored('> feching ' + asset + '/' + currency + ' from cache :)', 'magenta'))
df_train = pd.read_csv(df_train_path)
df_rollout = pd.read_csv(df_rollout_path)
# df_train.set_index('Date', inplace=True)
# df_rollout.set_index('Date', inplace=True)
return df_train, df_rollout
Low = np.array(LowList) High = np.array(HighList) Close = np.array(PriceList) #Low, High, and Close converted to Array format (TA-Lib calls require Array) SARtoList = (talib.SAR(High, Low, acceleration = 0.2, maximum = 0.20)) BBandsArray = (talib.BBANDS(Close, timeperiod = 5, nbdevup = 2, nbdevdn = 2, matype = 0)) EMAList = talib.EMA(Close, timeperiod=30) KAMAList = talib.KAMA(Close, timeperiod=30) MAList = talib.MA(Close, timeperiod=30, matype=0) WMAList = talib.WMA(Close, timeperiod=30) TRIMAList = talib.TRIMA(Close, timeperiod=30) TEMAList = talib.TEMA(Close, timeperiod=30) HTList = talib.HT_TRENDLINE(Close) ADXList = talib.ADX(High, Low, Close, timeperiod=14) ADXRList = talib.ADXR(High, Low, Close, timeperiod=14) CMOList = talib.CMO(Close, timeperiod=14) DXList = talib.DX(High, Low, Close, timeperiod=14) MACDArray = talib.MACDFIX(Close, signalperiod=9) MINUS_DI_List = talib.MINUS_DI(High, Low, Close, timeperiod=14) PLUS_DI_List = talib.PLUS_DI(High, Low, Close, timeperiod=14) MOMList = talib.MOM(Close, timeperiod=10) RSIList = talib.RSI(Close, timeperiod=14) NATRList = talib.NATR(High, Low, Close, timeperiod=14) BETAList = talib.BETA(High, Low, timeperiod=5) #method calls to TA-Lib complete, results stored in SARtoList (list) and BBandsArray (array) BBandsUpperDF = pd.DataFrame(BBandsArray[0], columns = ['Upper Band',])
def compute_indicators(self):
df = deepcopy(self.df)
open = df.open
close = df.close
high = df.high
low = df.low
volume = df.volume
adjclose = close
nan_offset = 50
df['beta'] = talib.BETA(high, low, timeperiod=5)
df['rsi_14'] = talib.RSI(close, timeperiod=14)
df['rsi_14_thresh'] = df.rsi_14.apply(lambda c: 1 if c > 70 else (-1 if c < 30 else 0))
df['rsi_21'] = talib.RSI(close, timeperiod=21)
df['rsi_21_thresh'] = df.rsi_21.apply(lambda c: 1 if c > 70 else (-1 if c < 30 else 0))
df['rsi_60'] = talib.RSI(close, timeperiod=60)
df['rsi_60_thresh'] = df.rsi_60.apply(lambda c: 1 if c > 70 else (-1 if c < 30 else 0))
df['macd_12_26'], df['macdsignal_12_26'], df['macdhist_12_26'] = talib.MACD(close, fastperiod=12, slowperiod=26,
signalperiod=9)
df['macd_5_12'], df['macdsignal_5_12'], df['macdhist_5_12'] = talib.MACD(close, fastperiod=3, slowperiod=15,
signalperiod=5)
df['mom'] = talib.MOM(close, timeperiod=10)
df['roc_20'] = talib.ROC(close, timeperiod=21)
df['roc_125'] = talib.ROC(close, timeperiod=125)
df['roc_90'] = talib.ROC(close, timeperiod=90)
high = deepcopy(df.high)
low = deepcopy(df.low)
df['psar_005'] = self.get_sar(high, low, 0.005, 0.2)
df['psar_02'] = self.get_sar(high, low, 0.02, 0.2)
df['psar_1'] = self.get_sar(high, low, 0.1, 0.2)
try:
df['psar_005_dist'] = df.psar_005 - df.adjclose
df['psar_02_dist'] = df.psar_02 - df.adjclose
df['psar_1_dist'] = df.psar_1 - df.adjclose
except Exception as e:
print(e)
try:
df['psar_005_ind'] = (df.psar_005 < self.df.adjclose).astype(int)
df['psar_02_ind'] = (df.psar_02 < self.df.adjclose).astype(int)
df['psar_1_ind'] = (df.psar_1 < self.df.adjclose).astype(int)
except Exception as e:
print(e)
df['sma5'] = talib.SMA(close, timeperiod=5)
df['sma10'] = talib.SMA(close, timeperiod=10)
df['sma20'] = talib.SMA(close, timeperiod=20)
df['sma50'] = talib.SMA(close, timeperiod=50)
df['sma200'] = talib.SMA(close, timeperiod=200)
df['midprice_5'] = talib.MIDPRICE(high, low, timeperiod=5)
df['midprice_14'] = talib.MIDPRICE(high, low, timeperiod=14)
df['midprice_21'] = talib.MIDPRICE(high, low, timeperiod=21)
df['upperband'], df['middleband'], df['lowerband'] = talib.BBANDS(close, timeperiod=5, nbdevup=2., nbdevdn=2.,
matype=0)
df['instantaneous_trend'] = talib.HT_TRENDLINE(close)
df['adx_7'] = talib.ADX(high, low, close, timeperiod=7)
df['adx_7_pctchg'] = df.adx_7.pct_change()
df['adx_14'] = talib.ADX(high, low, close, timeperiod=14)
df['adx_14_pctchg'] = df.adx_14.pct_change()
df['adx_21'] = talib.ADX(high, low, close, timeperiod=21)
df['adx_21_pctchg'] = df.adx_21.pct_change()
df['adx_60'] = talib.ADX(high, low, close, timeperiod=61)
df['adx_60_pctchg'] = df.adx_60.pct_change()
df['cci'] = talib.CCI(high, low, close, timeperiod=14)
df['cci_chg'] = df.cci.pct_change()
df['cci_thresh'] = df.cci.apply(lambda c: 1 if c > 100 else (-1 if c < 20 else 0))
df['direction_movement_idx'] = talib.DX(high, low, close, timeperiod=14)
df['money_flow'] = talib.MFI(high, low, close, volume, timeperiod=14)
df['aroon_down'], df['aroon_up'] = talib.AROON(high, low)
df['ppo'] = talib.PPO(close, fastperiod=12, slowperiod=26, matype=0)
df['trix'] = talib.TRIX(close, timeperiod=30)
df['stoch_k'], df['stoch_d'] = talib.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0,
slowd_period=3, slowd_matype=0)
df['stoch_rsi_k'], df['stoch_rsi_d'] = talib.STOCHRSI(close, timeperiod=14, fastk_period=5, fastd_period=3,
fastd_matype=0)
df['willR'] = talib.WILLR(high, low, close, timeperiod=14)
df['natr'] = talib.NATR(high, low, close, timeperiod=14)
df['trange'] = talib.TRANGE(high, low, close)
df['obv'] = talib.OBV(close, volume)
df['adosc'] = talib.ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
df['ad'] = talib.AD(high, low, close, volume)
try:
df['log_return'] = df.ta.log_return()
df['percent_return'] = df.ta.percent_return()
except Exception as e:
print(e)
df['zscore'] = df.ta.zscore()
df['quantile'] = df.ta.quantile()
df['ht_dom_per'] = talib.HT_DCPERIOD(close)
df['ht_dom_cycle'] = talib.HT_DCPHASE(close)
df['ht_trendmode'] = talib.HT_TRENDMODE(close)
df['pvt'] = df.ta.pvt()
df['increasing'] = df.ta.increasing()
df['decreasing'] = df.ta.decreasing()
df['cross_sma5'] = df.ta.cross('close', 'sma5')
df['cross_sma10'] = df.ta.cross('close', 'sma10')
df['cross_sma20'] = df.ta.cross('close', 'sma20')
df['cross_sma50'] = df.ta.cross('close', 'sma50')
df['cross_sma200'] = df.ta.cross('close', 'sma200')
df['sma20_above'] = (df.sma20 > df.sma200).astype(int)
df['sma50_above'] = (df.sma50 > df.sma200).astype(int)
df['cross_psar_rsi14'] = df.ta.cross('psar_02', 'rsi_14')
df['cross_psar_005_close'] = df.ta.cross('psar_005', 'adjclose')
df['cross_psar_02_close'] = df.ta.cross('psar_02', 'adjclose')
df['cross_psar_1_close'] = df.ta.cross('psar_1', 'adjclose')
df['cross_adx14_psar_02'] = df.ta.cross('psar_02', 'adx_14')
df['cross_adx7_psar_02'] = df.ta.cross('psar_005', 'adx_7')
df['cross_adx14_psar_02'] = df.ta.cross('psar_005', 'adx_14')
df['cross_stoch'] = df.ta.cross('stoch_k', 'stoch_d')
df['cross_macd_12_26'] = df.ta.cross('macd_12_26', 'macdsignal_12_26')
df['cross_macd_5_12'] = df.ta.cross('macd_5_12', 'macdsignal_5_12')
df['roc_20_125'] = df.ta.cross('roc_20', 'roc_125')
df['roc_20_125_dist'] = df.roc_20 - df.roc_125
#df = df.iloc[nan_offset:, :].dropna(axis=1).copy()
self.df = df
self.indicator_matrix = df.iloc[:, 6:]
def get_datasets(asset, currency, granularity, datapoints, df_train_size=0.75):
"""Fetch the API and precess the desired pair
Arguments:
asset {str} -- First pair
currency {str} -- Second pair
granularity {str ['day', 'hour']} -- Granularity
datapoints {int [100 - 2000]} -- [description]
Returns:
pandas.Dataframe -- The OHLCV and indicators dataframe
"""
df_train_path = 'datasets/bot_train_{}_{}_{}.csv'.format(
asset + currency, datapoints, granularity)
df_rollout_path = 'datasets/bot_rollout_{}_{}_{}.csv'.format(
asset + currency, datapoints, granularity)
emojis = [
':moneybag:', ':yen:', ':dollar:', ':pound:', ':euro:',
':credit_card:', ':money_with_wings:', ':gem:'
]
if not os.path.exists(df_rollout_path):
headers = {
'User-Agent':
'Mozilla/5.0',
'authorization':
'Apikey 3d7d3e9e6006669ac00584978342451c95c3c78421268ff7aeef69995f9a09ce'
}
# OHLC
# url = 'https://min-api.cryptocompare.com/data/histo{}?fsym={}&tsym={}&e=Binance&limit={}'.format(granularity, asset, currency, datapoints)
url = 'https://min-api.cryptocompare.com/data/histo{}?fsym={}&tsym={}&limit={}'.format(
granularity, asset, currency, datapoints)
# print(emoji.emojize(':dizzy: :large_blue_diamond: :gem: :bar_chart: :crystal_ball: :chart_with_downwards_trend: :chart_with_upwards_trend: :large_orange_diamond: loading...', use_aliases=True))
print(
colored(
emoji.emojize('> ' + random.choice(emojis) + ' downloading ' +
asset + '/' + currency,
use_aliases=True), 'green'))
# print(colored('> downloading ' + asset + '/' + currency, 'green'))
response = requests.get(url, headers=headers)
json_response = response.json()
status = json_response['Response']
if status == "Error":
print(colored('=== {} ==='.format(json_response['Message']),
'red'))
raise AssertionError()
result = json_response['Data']
df = pd.DataFrame(result)
print(df.tail())
df['Date'] = pd.to_datetime(df['time'], utc=True, unit='s')
df.drop('time', axis=1, inplace=True)
# indicators
# https://github.com/mrjbq7/ta-lib/blob/master/docs/func.md
open_price, high, low, close = np.array(df['open']), np.array(
df['high']), np.array(df['low']), np.array(df['close'])
volume = np.array(df['volumefrom'])
# cycle indicators
df.loc[:, 'HT_DCPERIOD'] = talib.HT_DCPERIOD(close)
df.loc[:, 'HT_DCPHASE'] = talib.HT_DCPHASE(close)
df.loc[:,
'HT_PHASOR_inphase'], df.loc[:,
'HT_PHASOR_quadrature'] = talib.HT_PHASOR(
close)
df.loc[:, 'HT_SINE_sine'], df.loc[:,
'HT_SINE_leadsine'] = talib.HT_SINE(
close)
df.loc[:, 'HT_TRENDMODE'] = talib.HT_TRENDMODE(close)
# momemtum indicators
df.loc[:, 'ADX'] = talib.ADX(high, low, close, timeperiod=12)
df.loc[:, 'ADXR'] = talib.ADXR(high, low, close, timeperiod=13)
df.loc[:, 'APO'] = talib.APO(close,
fastperiod=5,
slowperiod=10,
matype=0)
df.loc[:,
'AROON_down'], df.loc[:,
'AROON_up'] = talib.AROON(high,
low,
timeperiod=15)
df.loc[:, 'AROONOSC'] = talib.AROONOSC(high, low, timeperiod=13)
df.loc[:, 'BOP'] = talib.BOP(open_price, high, low, close)
df.loc[:, 'CCI'] = talib.CCI(high, low, close, timeperiod=13)
df.loc[:, 'CMO'] = talib.CMO(close, timeperiod=14)
df.loc[:, 'DX'] = talib.DX(high, low, close, timeperiod=10)
df['MACD'], df['MACD_signal'], df['MACD_hist'] = talib.MACD(
close, fastperiod=5, slowperiod=10, signalperiod=20)
df.loc[:, 'MFI'] = talib.MFI(high, low, close, volume, timeperiod=12)
df.loc[:, 'MINUS_DI'] = talib.MINUS_DI(high, low, close, timeperiod=10)
df.loc[:, 'MINUS_DM'] = talib.MINUS_DM(high, low, timeperiod=14)
df.loc[:, 'MOM'] = talib.MOM(close, timeperiod=20)
df.loc[:, 'PPO'] = talib.PPO(close,
fastperiod=17,
slowperiod=35,
matype=2)
df.loc[:, 'ROC'] = talib.ROC(close, timeperiod=12)
df.loc[:, 'RSI'] = talib.RSI(close, timeperiod=25)
df.loc[:, 'STOCH_k'], df.loc[:,
'STOCH_d'] = talib.STOCH(high,
low,
close,
fastk_period=35,
slowk_period=12,
slowk_matype=0,
slowd_period=7,
slowd_matype=0)
df.loc[:,
'STOCHF_k'], df.loc[:,
'STOCHF_d'] = talib.STOCHF(high,
low,
close,
fastk_period=28,
fastd_period=14,
fastd_matype=0)
df.loc[:, 'STOCHRSI_K'], df.loc[:, 'STOCHRSI_D'] = talib.STOCHRSI(
close,
timeperiod=35,
fastk_period=12,
fastd_period=10,
fastd_matype=1)
df.loc[:, 'TRIX'] = talib.TRIX(close, timeperiod=30)
df.loc[:, 'ULTOSC'] = talib.ULTOSC(high,
low,
close,
timeperiod1=14,
timeperiod2=28,
timeperiod3=35)
df.loc[:, 'WILLR'] = talib.WILLR(high, low, close, timeperiod=35)
# overlap studies
df.loc[:,
'BBANDS_upper'], df.loc[:,
'BBANDS_middle'], df.loc[:,
'BBANDS_lower'] = talib.BBANDS(
close,
timeperiod=
12,
nbdevup=2,
nbdevdn=2,
matype=0)
df.loc[:, 'DEMA'] = talib.DEMA(close, timeperiod=30)
df.loc[:, 'EMA'] = talib.EMA(close, timeperiod=7)
df.loc[:, 'HT_TRENDLINE'] = talib.HT_TRENDLINE(close)
df.loc[:, 'KAMA'] = talib.KAMA(close, timeperiod=5)
df.loc[:, 'MA'] = talib.MA(close, timeperiod=5, matype=0)
df.loc[:, 'MIDPOINT'] = talib.MIDPOINT(close, timeperiod=20)
df.loc[:, 'WMA'] = talib.WMA(close, timeperiod=15)
df.loc[:, 'SMA'] = talib.SMA(close)
# pattern recoginition
df.loc[:, 'CDL2CROWS'] = talib.CDL2CROWS(open_price, high, low, close)
df.loc[:, 'CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(
open_price, high, low, close)
df.loc[:, 'CDL3INSIDE'] = talib.CDL3INSIDE(open_price, high, low,
close)
df.loc[:, 'CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(
open_price, high, low, close)
# price transform
df.loc[:, 'WCLPRICE'] = talib.WCLPRICE(high, low, close)
# statistic funcitons
df.loc[:, 'BETA'] = talib.BETA(high, low, timeperiod=20)
df.loc[:, 'CORREL'] = talib.CORREL(high, low, timeperiod=20)
df.loc[:, 'STDDEV'] = talib.STDDEV(close, timeperiod=20, nbdev=1)
df.loc[:, 'TSF'] = talib.TSF(close, timeperiod=20)
df.loc[:, 'VAR'] = talib.VAR(close, timeperiod=20, nbdev=1)
# volatility indicators
df.loc[:, 'ATR'] = talib.ATR(high, low, close, timeperiod=7)
df.loc[:, 'NATR'] = talib.NATR(high, low, close, timeperiod=20)
df.loc[:, 'TRANGE'] = talib.TRANGE(high, low, close)
# volume indicators
df.loc[:, 'AD'] = talib.AD(high, low, close, volume)
df.loc[:, 'ADOSC'] = talib.ADOSC(high,
low,
close,
volume,
fastperiod=10,
slowperiod=20)
df.loc[:, 'OBV'] = talib.OBV(close, volume)
# df.fillna(df.mean(), inplace=True)
df.dropna(inplace=True)
df.set_index('Date', inplace=True)
print(colored('> caching' + asset + '/' + currency + ':)', 'cyan'))
train_size = round(
len(df) *
df_train_size) # 75% to train -> test with different value
df_train = df[:train_size]
df_rollout = df[train_size:]
df_train.to_csv(df_train_path)
df_rollout.to_csv(df_rollout_path)
df_train = pd.read_csv(
df_train_path) # re-read to avoid indexing issue w/ Ray
df_rollout = pd.read_csv(df_rollout_path)
else:
print(
colored(
emoji.emojize('> ' + random.choice(emojis) + ' feching ' +
asset + '/' + currency + ' from cache',
use_aliases=True), 'magenta'))
# print(colored('> feching ' + asset + '/' + currency + ' from cache :)', 'magenta'))
df_train = pd.read_csv(df_train_path)
df_rollout = pd.read_csv(df_rollout_path)
# df_train.set_index('Date', inplace=True)
# df_rollout.set_index('Date', inplace=True)
return df_train, df_rollout
# return[float('nan') if x == 0 else x for x in complete_doji_prices]
# complete_doji_prices = pd.DataFrame(doji_prices_to_nan(complete_doji_prices))
# complete_doji_prices = complete_doji_prices.dropna()
#
#
# def doji_idx_to_nan(complete_doji_idx):
# return[float('nan') if x == 0 else x for x in complete_doji_idx]
# complete_doji_idx = pd.DataFrame(doji_idx_to_nan(complete_doji_idx))
# complete_doji_idx = complete_doji_idx.dropna()
# print(complete_doji_idx.index)
#print(doji_idx_to_nan(complete_doji_idx))
#complete_doji_idx = argrelmax(complete_doji.values, order=1)
#complete_doji = close[complete_doji_idx]
#TA-LIB Trend line scanner
trend_line = talib.HT_TRENDLINE(close)
#Replace first 63 rows, 'NaN' values with 0s, create a new Trendline Column
trend_line.fillna(0, inplace=True)
df['trend_line'] = trend_line
#TA-LIB RSI Scanner
rsi = talib.RSI(close, timeperiod=7)
#Fill 'NaN' values with 0s
df['rsi'] = rsi.fillna(0)
#Create new columns for RSI70 and RSI30 and fill with rsi values if Above/Below
df['rsi70'] = np.where(df['rsi'] >= 70, rsi, 0)
df['rsi30'] = np.where(df['rsi'] <= 30, rsi, 0)
def hilbert(stockData, point):
return talib.HT_TRENDLINE(stockData['close'][:point])[-1]
def HT_TRENDLINE(data, **kwargs):
_check_talib_presence()
prices = _extract_series(data)
return talib.HT_TRENDLINE(prices, **kwargs)
def get_factors(high,
low,
close,
volume,
BBANDS=False,
DEMA=False,
EMA=False,
HT_TRENDLINE=False,
KAMA=False,
MA=False,
MAMA=False,
MAVP=False,
MIDPOINT=False,
MIDPRICE=False,
SAR=False,
SAREXT=False,
SMA=False,
T3=False,
TEMA=False,
TRIMA=False,
WMA=False,
AD=False,
ADOSC=False,
OBV=False,
HT_DCPERIOD=False,
HT_DCPHASE=False,
HT_PHASOR=False,
HT_SINE=False,
HT_TRENDMODE=False,
AVGPRICE=False,
MEDPRICE=False,
TYPPRICE=False,
WCLPRICE=False,
ATR=False,
NATR=False,
TRANGE=False,
ADX=False,
ADXR=False,
APO=False,
AROON=False,
AROONOSC=False,
BOP=False,
CCI=False,
CMO=False,
DX=False,
MACD=False,
ivergence=False,
MACDEXT=False,
MACDFIX=False,
MFI=False,
MINUS_DI=False,
MINUS_DM=False,
MOM=False,
PLUS_DI=False,
PLUS_DM=False,
PPO=False,
ROC=False,
ROCP=False,
ROCR=False,
ROCR100=False,
RSI=False,
STOCH=False,
STOCHF=False,
STOCHRSI=False,
TRIX=False,
ULTOSC=False,
WILLR=False):
fators = [
'BBANDS', 'DEMA', 'EMA', 'HT_TRENDLINE', 'KAMA', 'MA', 'MAMA',
'MIDPOINT', 'MIDPRICE', 'SAR', 'SAREXT', 'SMA', 'T3', 'TEMA', 'TRIMA',
'WMA', 'AD', 'ADOSC', 'OBV', 'HT_DCPERIOD', 'HT_DCPHASE', 'HT_PHASOR',
'HT_SINE', 'HT_TRENDMODE', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE',
'WCLPRICE', 'ATR', 'NATR', 'TRANGE', 'ADX', 'ADXR', 'APO', 'AROON',
'AROONOSC', 'BOP', 'CCI', 'CMO', 'DX', 'MACD', 'ivergence', 'MACDEXT',
'MACDFIX', 'MFI,MINUS_DI', 'MINUS_DM', 'MOM', 'PLUS_DI', 'PLUS_DM',
'PPO', 'ROC', 'ROCP', 'ROCR', 'ROCR100', 'RSI', 'STOCH', 'STOCHF',
'STOCHRSI', 'TRIX', 'ULTOSC', 'WILLR'
]
data_sets = np.zeros([len(high), 1])
if BBANDS == True:
upperband, middleband, lowerband = ta.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
upperband = array_process(upperband)
middleband = array_process(middleband)
lowerband = array_process(lowerband)
data_sets = np.hstack([data_sets, upperband, middleband, lowerband])
if DEMA == True:
dema = ta.DEMA(close, timeperiod=30)
dema = array_process(dema)
data_sets = np.hstack([data_sets, dema])
if EMA == True:
ema = ta.EMA(close, timeperiod=30)
ema = array_process(ema)
data_sets = np.hstack([data_sets, ema])
if HT_TRENDLINE == True:
trendline = ta.HT_TRENDLINE(close)
trendline = array_process(trendline)
data_sets = np.hstack([data_sets, trendline])
if KAMA == True:
kama = ta.KAMA(close, timeperiod=30)
kama = array_process(kama)
data_sets = np.hstack([data_sets, kama])
if MA == True:
ma = ta.MA(close, timeperiod=30, matype=0)
ma = array_process(ma)
data_sets = np.hstack([data_sets, ma])
if MAMA == True:
mama, fama = ta.MAMA(close, fastlimit=0, slowlimit=0)
mama = array_process(mama)
fama = array_process(fama)
data_sets = np.hstack([data_sets, mama, fama])
if MIDPOINT == True:
midpoint = ta.MIDPOINT(close, timeperiod=14)
midpoint = array_process(midpoint)
data_sets = np.hstack([data_sets, midpoint])
if MIDPRICE == True:
midprice = ta.MIDPRICE(high, low, timeperiod=14)
midprice = array_process(midprice)
data_sets = np.hstack([data_sets, midprice])
if SAR == True:
sar = ta.SAR(high, low, acceleration=0, maximum=0)
sar = array_process(sar)
data_sets = np.hstack([data_sets, sar])
if SAREXT == True:
sarext = ta.SAREXT(high,
low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
sarext = array_process(sarext)
data_sets = np.hstack([data_sets, sarext])
if SMA == True:
sma = ta.SMA(close, timeperiod=30)
sma = array_process(sma)
data_sets = np.hstack([data_sets, sma])
if T3 == True:
t3 = ta.T3(close, timeperiod=5, vfactor=0)
t3 = array_process(t3)
data_sets = np.hstack([data_sets, t3])
if TEMA == True:
tema = ta.TEMA(close, timeperiod=30)
tema = array_process(tema)
data_sets = np.hstack([data_sets, tema])
if TRIMA == True:
trima = ta.TRIMA(close, timeperiod=30)
trima = array_process(trima)
data_sets = np.hstack([data_sets, trima])
if WMA == True:
wma = ta.WMA(close, timeperiod=30)
wma = array_process(wma)
data_sets = np.hstack([data_sets, wma])
if AD == True:
ad = ta.AD(high, low, close, volume)
ad = array_process(ad)
data_sets = np.hstack([data_sets, ad])
if ADOSC == True:
adosc = ta.ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
adosc = array_process(adosc)
data_sets = np.hstack([data_sets, adosc])
if OBV == True:
obv = ta.OBV(close, volume)
obv = array_process(obv)
data_sets = np.hstack([data_sets, obv])
if HT_DCPERIOD == True:
dcperiod = ta.HT_DCPERIOD(close)
dcperiod = array_process(dcperiod)
data_sets = np.hstack([data_sets, dcperiod])
if HT_DCPHASE == True:
dcphase = ta.HT_DCPHASE(close)
dcphase = array_process(dcphase)
data_sets = np.hstack([data_sets, dcphase])
if HT_PHASOR == True:
inphase, quadrature = ta.HT_PHASOR(close)
inphase = array_process(inphase)
data_sets = np.hstack([data_sets, inphase])
quadrature = array_process(quadrature)
data_sets = np.hstack([data_sets, quadrature])
if HT_SINE == True:
sine, leadsine = ta.HT_SINE(close)
sine = array_process(sine)
data_sets = np.hstack([data_sets, sine])
leadsine = array_process(leadsine)
data_sets = np.hstack([data_sets, leadsine])
if HT_TRENDMODE == True:
integer = ta.HT_TRENDMODE(close)
integer = array_process(integer)
data_sets = np.hstack([data_sets, integer])
if AVGPRICE == True:
avgprice = ta.AVGPRICE(open, high, low, close)
avgprice = array_process(avgprice)
data_sets = np.hstack([data_sets, avgprice])
if MEDPRICE == True:
medprice = ta.MEDPRICE(high, low)
medprice = array_process(medprice)
data_sets = np.hstack([data_sets, medprice])
if TYPPRICE == True:
typprice = ta.TYPPRICE(high, low, close)
typprice = array_process(typprice)
data_sets = np.hstack([data_sets, typprice])
if WCLPRICE == True:
wclprice = ta.WCLPRICE(high, low, close)
wclprice = array_process(wclprice)
data_sets = np.hstack([data_sets, wclprice])
if ATR == True:
atr = ta.ATR(high, low, close, timeperiod=14)
atr = array_process(atr)
data_sets = np.hstack([data_sets, atr])
if NATR == True:
natr = ta.NATR(high, low, close, timeperiod=14)
natr = array_process(natr)
data_sets = np.hstack([data_sets, natr])
if TRANGE == True:
trange = ta.TRANGE(high, low, close)
natr = array_process(trange)
data_sets = np.hstack([data_sets, trange])
if ADX == True:
adx = ta.ADX(high, low, close, timeperiod=14)
adx = array_process(adx)
data_sets = np.hstack([data_sets, adx])
if ADXR == True:
adxr = ta.ADXR(high, low, close, timeperiod=14)
adxr = array_process(adxr)
data_sets = np.hstack([data_sets, adxr])
if APO == True:
apo = ta.APO(close, fastperiod=12, slowperiod=26, matype=0)
apo = array_process(apo)
data_sets = np.hstack([data_sets, apo])
if AROON == True:
aroondown, aroonup = ta.AROON(high, low, timeperiod=14)
aroondown = array_process(aroondown)
data_sets = np.hstack([data_sets, aroondown])
aroonup = array_process(aroonup)
data_sets = np.hstack([data_sets, aroonup])
if AROONOSC == True:
aroonosc = ta.AROONOSC(high, low, timeperiod=14)
aroonosc = array_process(aroonosc)
data_sets = np.hstack([data_sets, aroonosc])
if BOP == True:
bop = ta.BOP(open, high, low, close)
bop = array_process(bop)
data_sets = np.hstack([data_sets, bop])
if CCI == True:
cci = ta.CCI(high, low, close, timeperiod=14)
cci = array_process(cci)
data_sets = np.hstack([data_sets, cci])
if CMO == True:
cmo = ta.CMO(close, timeperiod=14)
cmo = array_process(cmo)
data_sets = np.hstack([data_sets, cmo])
if DX == True:
dx = ta.DX(high, low, close, timeperiod=14)
dx = array_process(dx)
data_sets = np.hstack([data_sets, dx])
if MACD == True:
macd, macdsignal, macdhist = ta.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
macd = array_process(macd)
data_sets = np.hstack([data_sets, macd])
macdhist = array_process(macdhist)
data_sets = np.hstack([data_sets, macdhist])
macdsignal = array_process(macdsignal)
data_sets = np.hstack([data_sets, macdsignal])
if MACDEXT == True:
macd, macdsignal, macdhist = ta.MACDEXT(close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
macd = array_process(macd)
data_sets = np.hstack([data_sets, macd])
macdhist = array_process(macdhist)
data_sets = np.hstack([data_sets, macdhist])
macdsignal = array_process(macdsignal)
data_sets = np.hstack([data_sets, macdsignal])
if MACDFIX == True:
macd, macdsignal, macdhist = ta.MACDFIX(close, signalperiod=9)
macd = array_process(macd)
data_sets = np.hstack([data_sets, macd])
macdhist = array_process(macdhist)
data_sets = np.hstack([data_sets, macdhist])
macdsignal = array_process(macdsignal)
data_sets = np.hstack([data_sets, macdsignal])
if MFI == True:
mfi = ta.MFI(high, low, close, volume, timeperiod=14)
mfi = array_process(mfi)
data_sets = np.hstack([data_sets, mfi])
if MINUS_DI == True:
minus_di = ta.MINUS_DI(high, low, close, timeperiod=14)
minus_di = array_process(minus_di)
data_sets = np.hstack([data_sets, minus_di])
if MINUS_DM == True:
minus_dm = ta.MINUS_DM(high, low, timeperiod=14)
minus_dm = array_process(minus_dm)
data_sets = np.hstack([data_sets, minus_dm])
if MOM == True:
mom = ta.MOM(close, timeperiod=10)
mom = array_process(mom)
data_sets = np.hstack([data_sets, mom])
if PLUS_DI == True:
plus_di = ta.PLUS_DI(high, low, close, timeperiod=14)
plus_di = array_process(plus_di)
data_sets = np.hstack([data_sets, plus_di])
if PLUS_DM == True:
plus_dm = ta.PLUS_DM(high, low, timeperiod=14)
plus_dm = array_process(plus_dm)
data_sets = np.hstack([data_sets, plus_dm])
if PPO == True:
ppo = ta.PPO(close, fastperiod=12, slowperiod=26, matype=0)
ppo = array_process(ppo)
data_sets = np.hstack([data_sets, ppo])
if ROC == True:
roc = ta.ROC(close, timeperiod=10)
roc = array_process(roc)
data_sets = np.hstack([data_sets, roc])
if ROCP == True:
rocp = ta.ROCP(close, timeperiod=10)
rocp = array_process(rocp)
data_sets = np.hstack([data_sets, rocp])
if ROCR == True:
rocr = ta.ROCR(close, timeperiod=10)
rocr = array_process(rocr)
data_sets = np.hstack([data_sets, rocr])
if ROCR100 == True:
rocr100 = ta.ROCR100(close, timeperiod=10)
rocr100 = array_process(rocr100)
data_sets = np.hstack([data_sets, rocr100])
if RSI == True:
rsi = ta.RSI(close, timeperiod=14)
rsi = array_process(rsi)
data_sets = np.hstack([data_sets, rsi])
if STOCH == True:
slowk, slowd = ta.STOCH(high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
slowd = array_process(slowd)
data_sets = np.hstack([data_sets, slowd])
slowk = array_process(slowk)
data_sets = np.hstack([data_sets, slowk])
if STOCHF == True:
fastk, fastd = ta.STOCHF(high,
low,
close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
fastd = array_process(fastd)
data_sets = np.hstack([data_sets, fastd])
fastk = array_process(fastk)
data_sets = np.hstack([data_sets, fastk])
if STOCHRSI == True:
fastk, fastd = ta.STOCHRSI(close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
fastk = array_process(fastk)
data_sets = np.hstack([data_sets, fastk])
fastd = array_process(fastd)
data_sets = np.hstack([data_sets, fastd])
if TRIX == True:
trix = ta.TRIX(close, timeperiod=30)
trix = array_process(trix)
data_sets = np.hstack([data_sets, trix])
if ULTOSC == True:
ultosc = ta.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
ultosc = array_process(ultosc)
data_sets = np.hstack([data_sets, ultosc])
if WILLR == True:
willr = ta.WILLR(high, low, close, timeperiod=14)
willr = array_process(willr)
data_sets = np.hstack([data_sets, willr])
return data_sets[:, 1:]
def HT_TRENDLINE(self):
real = talib.HT_TRENDLINE(self.close)
return real
timeperiod2=14,
timeperiod3=28)
df.loc[:, 'WILLR'] = talib.WILLR(high, low, close, timeperiod=14)
# overlap studies
df.loc[:,
'BBANDS_upper'], df.loc[:,
'BBANDS_middle'], df.loc[:,
'BBANDS_lower'] = talib.BBANDS(
close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
df.loc[:, 'DEMA'] = talib.DEMA(close, timeperiod=30)
df.loc[:, 'EMA'] = talib.EMA(close, timeperiod=30)
df.loc[:, 'HT_TRENDLINE'] = talib.HT_TRENDLINE(close)
df.loc[:, 'KAMA'] = talib.KAMA(close, timeperiod=30)
df.loc[:, 'MA'] = talib.MA(close, timeperiod=30, matype=0)
df.loc[:, 'MIDPOINT'] = talib.MIDPOINT(close, timeperiod=14)
df.loc[:, 'WMA'] = talib.WMA(close, timeperiod=30)
df.loc[:, 'SMA'] = talib.SMA(close)
# pattern recoginition
df.loc[:, 'CDL2CROWS'] = talib.CDL2CROWS(open_price, high, low, close)
df.loc[:, 'CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(open_price, high, low,
close)
df.loc[:, 'CDL3INSIDE'] = talib.CDL3INSIDE(open_price, high, low, close)
df.loc[:, 'CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(open_price, high, low,
close)
# price transform
df.loc[:, 'WCLPRICE'] = talib.WCLPRICE(high, low, close)
# statistic funcitons
def get_datasets(symbol, to_symbol, histo, limit):
"""Fetch the API and precess the desired pair
Arguments:
symbol {str} -- First pair
to_symbol {str} -- Second pair
histo {str ['day', 'hour']} -- Granularity
limit {int [100 - 2000]} -- [description]
Returns:
pandas.Dataframe -- The OHLCV and indicators dataframe
"""
headers = {
'User-Agent':
'Mozilla/5.0',
'authorization':
'Apikey 3d7d3e9e6006669ac00584978342451c95c3c78421268ff7aeef69995f9a09ce'
}
# OHLC
url = 'https://min-api.cryptocompare.com/data/histo{}?fsym={}&tsym={}&e=Binance&limit={}'.format(
histo, symbol, to_symbol, limit)
print(colored('> downloading ' + symbol + ' OHLCV', 'green'))
response = requests.get(url, headers=headers)
json_response = response.json()
status = json_response['Response']
if status == "Error":
print(colored('=== {} ==='.format(json_response['Message']), 'red'))
raise AssertionError()
result = json_response['Data']
df = pd.DataFrame(result)
df['Date'] = pd.to_datetime(df['time'], utc=True, unit='s')
df.drop('time', axis=1, inplace=True)
# indicators
# https://github.com/mrjbq7/ta-lib/blob/master/docs/func.md
open_price, high, low, close = np.array(df['open']), np.array(
df['high']), np.array(df['low']), np.array(df['close'])
volume = np.array(df['volumefrom'])
# cycle indicators
df.loc[:, 'HT_DCPERIOD'] = talib.HT_DCPERIOD(close)
df.loc[:, 'HT_DCPHASE'] = talib.HT_DCPHASE(close)
df.loc[:,
'HT_PHASOR_inphase'], df.loc[:,
'HT_PHASOR_quadrature'] = talib.HT_PHASOR(
close)
df.loc[:,
'HT_SINE_sine'], df.loc[:,
'HT_SINE_leadsine'] = talib.HT_SINE(close)
df.loc[:, 'HT_TRENDMODE'] = talib.HT_TRENDMODE(close)
# momemtum indicators
df.loc[:, 'ADX'] = talib.ADX(high, low, close, timeperiod=14)
df.loc[:, 'ADXR'] = talib.ADXR(high, low, close, timeperiod=14)
df.loc[:, 'APO'] = talib.APO(close, fastperiod=12, slowperiod=26, matype=0)
df.loc[:, 'AROON_down'], df.loc[:, 'AROON_up'] = talib.AROON(high,
low,
timeperiod=14)
df.loc[:, 'AROONOSC'] = talib.AROONOSC(high, low, timeperiod=14)
df.loc[:, 'BOP'] = talib.BOP(open_price, high, low, close)
df.loc[:, 'CCI'] = talib.CCI(high, low, close, timeperiod=14)
df.loc[:, 'CMO'] = talib.CMO(close, timeperiod=14)
df.loc[:, 'DX'] = talib.DX(high, low, close, timeperiod=14)
df['MACD'], df['MACD_signal'], df['MACD_hist'] = talib.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df.loc[:, 'MFI'] = talib.MFI(high, low, close, volume, timeperiod=14)
df.loc[:, 'MINUS_DI'] = talib.MINUS_DI(high, low, close, timeperiod=14)
df.loc[:, 'MINUS_DM'] = talib.MINUS_DM(high, low, timeperiod=14)
df.loc[:, 'MOM'] = talib.MOM(close, timeperiod=10)
df.loc[:, 'PPO'] = talib.PPO(close, fastperiod=12, slowperiod=26, matype=0)
df.loc[:, 'ROC'] = talib.ROC(close, timeperiod=10)
df.loc[:, 'RSI'] = talib.RSI(close, timeperiod=14)
df.loc[:, 'STOCH_k'], df.loc[:, 'STOCH_d'] = talib.STOCH(high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df.loc[:, 'STOCHF_k'], df.loc[:, 'STOCHF_d'] = talib.STOCHF(high,
low,
close,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
df.loc[:, 'STOCHRSI_K'], df.loc[:, 'STOCHRSI_D'] = talib.STOCHRSI(
close, timeperiod=30, fastk_period=14, fastd_period=10, fastd_matype=1)
df.loc[:, 'TRIX'] = talib.TRIX(close, timeperiod=30)
df.loc[:, 'ULTOSC'] = talib.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
df.loc[:, 'WILLR'] = talib.WILLR(high, low, close, timeperiod=14)
# overlap studies
df.loc[:,
'BBANDS_upper'], df.loc[:,
'BBANDS_middle'], df.loc[:,
'BBANDS_lower'] = talib.BBANDS(
close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
df.loc[:, 'DEMA'] = talib.DEMA(close, timeperiod=30)
df.loc[:, 'EMA'] = talib.EMA(close, timeperiod=30)
df.loc[:, 'HT_TRENDLINE'] = talib.HT_TRENDLINE(close)
df.loc[:, 'KAMA'] = talib.KAMA(close, timeperiod=30)
df.loc[:, 'MA'] = talib.MA(close, timeperiod=30, matype=0)
df.loc[:, 'MIDPOINT'] = talib.MIDPOINT(close, timeperiod=14)
df.loc[:, 'WMA'] = talib.WMA(close, timeperiod=30)
df.loc[:, 'SMA'] = talib.SMA(close)
# pattern recoginition
df.loc[:, 'CDL2CROWS'] = talib.CDL2CROWS(open_price, high, low, close)
df.loc[:, 'CDL3BLACKCROWS'] = talib.CDL3BLACKCROWS(open_price, high, low,
close)
df.loc[:, 'CDL3INSIDE'] = talib.CDL3INSIDE(open_price, high, low, close)
df.loc[:, 'CDL3LINESTRIKE'] = talib.CDL3LINESTRIKE(open_price, high, low,
close)
# price transform
df.loc[:, 'WCLPRICE'] = talib.WCLPRICE(high, low, close)
# statistic funcitons
df.loc[:, 'BETA'] = talib.BETA(high, low, timeperiod=5)
df.loc[:, 'CORREL'] = talib.CORREL(high, low, timeperiod=30)
df.loc[:, 'STDDEV'] = talib.STDDEV(close, timeperiod=5, nbdev=1)
df.loc[:, 'TSF'] = talib.TSF(close, timeperiod=14)
df.loc[:, 'VAR'] = talib.VAR(close, timeperiod=5, nbdev=1)
# volatility indicators
df.loc[:, 'ATR'] = talib.ATR(high, low, close, timeperiod=14)
df.loc[:, 'NATR'] = talib.NATR(high, low, close, timeperiod=14)
df.loc[:, 'TRANGE'] = talib.TRANGE(high, low, close)
# volume indicators
df.loc[:, 'AD'] = talib.AD(high, low, close, volume)
df.loc[:, 'ADOSC'] = talib.ADOSC(high,
low,
close,
volume,
fastperiod=3,
slowperiod=10)
df.loc[:, 'OBV'] = talib.OBV(close, volume)
# wallet indicator to trading bot
# df.loc[:, 'wallet_{}'.format(symbol)] = 1.0
df.loc[:, 'wallet_first_symbol'] = WALLET_FIRST_SYMBOL
df.loc[:, 'wallet_second_symbol'] = WALLET_SECOND_SYMBOL
# df.loc[:, 'wallet_{}'.format(to_symbol)] = 0.0
# df.fillna(df.mean(), inplace=True)
df.dropna(inplace=True)
df.set_index('Date', inplace=True)
train_size = round(len(df) *
0.5) # 50% to train -> test with different value
df_train = df[:train_size]
df_rollout = df[train_size:]
df_train.to_csv('datasets/bot_train_{}_{}_{}.csv'.format(
symbol + to_symbol, limit, histo))
df_rollout.to_csv('datasets/bot_rollout_{}_{}_{}.csv'.format(
symbol + to_symbol, limit, histo))
return df_train, df_rollout
def HT_TRENDLINE(Series):
res = talib.HT_TRENDLINE(Series.values)
return pd.Series(res, index=Series.index)
def CalculateIndicators(startDate='', endDate=''):
client = MongoClient()
db = client.Project
stocks = [x['BBGTicker'] for x in list(db.Stocks.find({}))]
if startDate == '' and endDate == '':
db.HistSignals.delete_many({})
else:
d1 = datetime.strptime(startDate, '%Y-%m-%d')
d2 = datetime.strptime(endDate, '%Y-%m-%d')
delta = (d2 - d1).days + 1
for i in range(delta):
db.HistSignals.delete_many(
{'Date': (d1 + td(days=i)).strftime('%Y-%m-%d')})
for s in stocks:
print(s)
if startDate == '' and endDate == '':
data = GetDataSerieFromMongo(s)
else:
start = (datetime.strptime(startDate, '%Y-%m-%d') -
td(days=90)).strftime('%Y-%m-%d')
data = GetDataSerieFromMongo(s, start, endDate)
header = data[0].tolist()
header.append('SMA')
header.append('EMA')
header.append('KAMA')
header.append('ADX')
header.append('RSI')
header.append('CCI')
header.append('MACD')
header.append('MACDSIGNAL')
header.append('MACDHIST')
header.append('MFI')
header.append('AD')
header.append('ADOSCILLATOR')
header.append('ATR')
header.append('OBV')
header.append('STOCH')
header.append('MOM')
header.append('ROC')
header.append('BOLLINGERUPPER')
header.append('BOLLINGERMIDDLE')
header.append('BOLLINGERLOWER')
header.append('HILBERTTRENDLINE')
header.append('WILLIAMR')
if len(data) > 1:
closeP = numpy.array(data[1:, 1], dtype='f8')
#openP = numpy.array(data[1:,6], dtype='f8')
highP = numpy.array(data[1:, 3], dtype='f8')
lowP = numpy.array(data[1:, 4], dtype='f8')
volume = numpy.array(data[1:, 7], dtype='f8')
sma = talib.SMA(closeP, timeperiod=14)
ema = talib.EMA(closeP, timeperiod=30)
kama = talib.KAMA(closeP, timeperiod=30)
adx = talib.ADX(highP, lowP, closeP, timeperiod=14)
rsi = talib.RSI(closeP, timeperiod=14)
cci = talib.CCI(highP, lowP, closeP, timeperiod=14)
macd, signal, hist = talib.MACD(closeP,
fastperiod=12,
slowperiod=26,
signalperiod=9)
mfi = talib.MFI(highP, lowP, closeP, volume, timeperiod=14)
ad = talib.AD(highP, lowP, closeP, volume)
adOscillator = talib.ADOSC(highP,
lowP,
closeP,
volume,
fastperiod=3,
slowperiod=10)
atr = talib.ATR(highP, lowP, closeP, timeperiod=14)
obv = talib.OBV(closeP, volume)
slowk, slowd = talib.STOCH(highP,
lowP,
closeP,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
mom = talib.MOM(closeP, timeperiod=10)
roc = talib.ROC(closeP, timeperiod=10)
upperBB, middleBB, lowerBB = talib.BBANDS(closeP,
matype=MA_Type.T3)
hilbertTL = talib.HT_TRENDLINE(closeP)
williamR = talib.WILLR(highP, lowP, closeP, timeperiod=14)
res = numpy.c_[data[1:, :], sma, ema, kama, adx, rsi, cci, macd,
signal, hist, mfi, ad, adOscillator, atr, obv,
slowk, slowd, mom, roc, upperBB, middleBB, lowerBB,
hilbertTL, williamR]
records = res.tolist()
jsonDict = []
for item in records:
jsonDict.append(dict(zip(header, item)))
if startDate == '' and endDate == '':
db.HistSignals.insert_many(jsonDict)
else:
jsonDictFilter = [
a for a in jsonDict
if datetime.strptime(startDate, '%Y-%m-%d') <=
datetime.strptime(a['Date'], '%Y-%m-%d') <=
datetime.strptime(endDate, '%Y-%m-%d')
]
db.HistSignals.insert_many(jsonDictFilter)
def TA(S, s, c):
S = S.fillna(0)
ope = numpy.asfarray(S.Open)
high = numpy.asfarray(S.High)
low = numpy.asfarray(S.Low)
close = numpy.asfarray(S.Close)
volume = numpy.asfarray(S.Volume)
##ROI calculation
ROI = [(close[i + 1] - close[i]) / close[i] for i in range(len(close) - 1)]
ROI.append(0) #add zero value for last day
d = pandas.DataFrame(ROI, index=S.index, columns=['ROI'])
d.to_csv("C:\\Users\\...\\Documents\\Data_TA\\{0}\\ROI_{1}.csv".format(
s, c))
##Baselines
try:
bah.append((S.Close['2013-04-30'] - S.Close['2002-05-01']) /
S.Close['2002-05-01'])
sah.append((-S.Close['2013-04-30'] + S.Close['2002-05-01']) /
S.Close['2002-05-01'])
except:
bah.append((S.Close['2013-04-30'] - S.Close['2002-05-02']) /
S.Close['2002-05-02'])
sah.append((-S.Close['2013-04-30'] + S.Close['2002-05-02']) /
S.Close['2002-05-02'])
rp.append(
numpy.dot(numpy.random.uniform(-1, 1, len(S)), numpy.asfarray(ROI)))
##talib application
#overlap
BBANDS = ta.BBANDS(close)
DEMA = ta.DEMA(close)
EMA = ta.EMA(close)
HT_TRENDLINE = ta.HT_TRENDLINE(close)
KAMA = ta.KAMA(close)
MA = ta.MA(close)
MAMA = ta.MAMA(close)
MIDPOINT = ta.MIDPOINT(close)
MIDPRICE = ta.MIDPRICE(high, low)
SAR = ta.SAR(high, low)
SAREXT = ta.SAREXT(high, low)
SMA = ta.SMA(close)
T3 = ta.T3(close)
TEMA = ta.TEMA(close)
TRIMA = ta.TRIMA(close)
WMA = ta.WMA(close)
#momentum
ADX = ta.ADX(high, low, close)
ADXR = ta.ADXR(high, low, close)
APO = ta.APO(close)
AROON = ta.AROON(high, low)
AROONOSC = ta.AROONOSC(high, low)
BOP = ta.BOP(ope, high, low, close)
CCI = ta.CCI(high, low, close)
CMO = ta.CMO(close)
DX = ta.DX(high, low, close)
MACD = ta.MACD(close)
MACDEXT = ta.MACDEXT(close)
MFI = ta.MFI(high, low, close, volume)
MINUS_DI = ta.MINUS_DI(high, low, close)
MINUS_DM = ta.MINUS_DM(high, low)
MOM = ta.MOM(close)
PLUS_DI = ta.PLUS_DI(high, low, close)
PLUS_DM = ta.PLUS_DM(high, low)
PPO = ta.PPO(close)
ROC = ta.ROC(close)
ROCP = ta.ROCP(close)
ROCR = ta.ROCR(close)
RSI = ta.RSI(close)
STOCH = ta.STOCH(high, low, close)
STOCHF = ta.STOCHF(high, low, close)
STOCHRSI = ta.STOCHRSI(close)
TRIX = ta.TRIX(close)
ULTOSC = ta.ULTOSC(high, low, close)
WILLR = ta.WILLR(high, low, close)
#volume
AD = ta.AD(high, low, close, volume)
ADOSC = ta.ADOSC(high, low, close, volume)
OBV = ta.OBV(close, volume)
#cycle
HT_DCPERIOD = ta.HT_DCPERIOD(close)
HT_DCPHASE = ta.HT_DCPHASE(close)
HT_PHASOR = ta.HT_PHASOR(close)
HT_SINE = ta.HT_SINE(close)
HT_TRENDMODE = ta.HT_TRENDMODE(close)
#price
AVGPRICE = ta.AVGPRICE(ope, high, low, close)
MEDPRICE = ta.MEDPRICE(high, low)
TYPPRICE = ta.TYPPRICE(high, low, close)
WCLPRICE = ta.WCLPRICE(high, low, close)
#volatility
ATR = ta.ATR(high, low, close)
NATR = ta.NATR(high, low, close)
TRANGE = ta.TRANGE(high, low, close)
#pattern
CDL2CROWS = ta.CDL2CROWS(ope, high, low, close)
CDL3BLACKCROWS = ta.CDL3BLACKCROWS(ope, high, low, close)
CDL3INSIDE = ta.CDL3INSIDE(ope, high, low, close)
CDL3LINESTRIKE = ta.CDL3LINESTRIKE(ope, high, low, close)
CDL3OUTSIDE = ta.CDL3OUTSIDE(ope, high, low, close)
CDL3STARSINSOUTH = ta.CDL3STARSINSOUTH(ope, high, low, close)
CDL3WHITESOLDIERS = ta.CDL3WHITESOLDIERS(ope, high, low, close)
CDLABANDONEDBABY = ta.CDLABANDONEDBABY(ope, high, low, close)
CDLADVANCEBLOCK = ta.CDLADVANCEBLOCK(ope, high, low, close)
CDLBELTHOLD = ta.CDLBELTHOLD(ope, high, low, close)
CDLBREAKAWAY = ta.CDLBREAKAWAY(ope, high, low, close)
CDLCLOSINGMARUBOZU = ta.CDLCLOSINGMARUBOZU(ope, high, low, close)
CDLCONCEALBABYSWALL = ta.CDLCONCEALBABYSWALL(ope, high, low, close)
CDLCOUNTERATTACK = ta.CDLCOUNTERATTACK(ope, high, low, close)
CDLDARKCLOUDCOVER = ta.CDLDARKCLOUDCOVER(ope, high, low, close)
CDLDOJI = ta.CDLDOJI(ope, high, low, close)
CDLDOJISTAR = ta.CDLDOJISTAR(ope, high, low, close)
CDLDRAGONFLYDOJI = ta.CDLDRAGONFLYDOJI(ope, high, low, close)
CDLENGULFING = ta.CDLENGULFING(ope, high, low, close)
CDLEVENINGDOJISTAR = ta.CDLEVENINGDOJISTAR(ope, high, low, close)
CDLEVENINGSTAR = ta.CDLEVENINGSTAR(ope, high, low, close)
CDLGAPSIDESIDEWHITE = ta.CDLGAPSIDESIDEWHITE(ope, high, low, close)
CDLGRAVESTONEDOJI = ta.CDLGRAVESTONEDOJI(ope, high, low, close)
CDLHAMMER = ta.CDLHAMMER(ope, high, low, close)
CDLHANGINGMAN = ta.CDLHANGINGMAN(ope, high, low, close)
CDLHARAMI = ta.CDLHARAMI(ope, high, low, close)
CDLHARAMICROSS = ta.CDLHARAMICROSS(ope, high, low, close)
CDLHIGHWAVE = ta.CDLHIGHWAVE(ope, high, low, close)
CDLHIKKAKE = ta.CDLHIKKAKE(ope, high, low, close)
CDLHIKKAKEMOD = ta.CDLHIKKAKEMOD(ope, high, low, close)
CDLHOMINGPIGEON = ta.CDLHOMINGPIGEON(ope, high, low, close)
CDLIDENTICAL3CROWS = ta.CDLIDENTICAL3CROWS(ope, high, low, close)
CDLINNECK = ta.CDLINNECK(ope, high, low, close)
CDLINVERTEDHAMMER = ta.CDLINVERTEDHAMMER(ope, high, low, close)
CDLKICKING = ta.CDLKICKING(ope, high, low, close)
CDLKICKINGBYLENGTH = ta.CDLKICKINGBYLENGTH(ope, high, low, close)
CDLLADDERBOTTOM = ta.CDLLADDERBOTTOM(ope, high, low, close)
CDLLONGLEGGEDDOJI = ta.CDLLONGLEGGEDDOJI(ope, high, low, close)
CDLLONGLINE = ta.CDLLONGLINE(ope, high, low, close)
CDLMARUBOZU = ta.CDLMARUBOZU(ope, high, low, close)
CDLMATCHINGLOW = ta.CDLMATCHINGLOW(ope, high, low, close)
CDLMATHOLD = ta.CDLMATHOLD(ope, high, low, close)
CDLMORNINGDOJISTAR = ta.CDLMORNINGDOJISTAR(ope, high, low, close)
CDLMORNINGSTAR = ta.CDLMORNINGSTAR(ope, high, low, close)
CDLONNECK = ta.CDLONNECK(ope, high, low, close)
CDLPIERCING = ta.CDLPIERCING(ope, high, low, close)
CDLRICKSHAWMAN = ta.CDLRICKSHAWMAN(ope, high, low, close)
CDLRISEFALL3METHODS = ta.CDLRISEFALL3METHODS(ope, high, low, close)
CDLSEPARATINGLINES = ta.CDLSEPARATINGLINES(ope, high, low, close)
CDLSHOOTINGSTAR = ta.CDLSHOOTINGSTAR(ope, high, low, close)
CDLSHORTLINE = ta.CDLSHORTLINE(ope, high, low, close)
CDLSPINNINGTOP = ta.CDLSPINNINGTOP(ope, high, low, close)
CDLSTALLEDPATTERN = ta.CDLSTALLEDPATTERN(ope, high, low, close)
CDLSTICKSANDWICH = ta.CDLSTICKSANDWICH(ope, high, low, close)
CDLTAKURI = ta.CDLTAKURI(ope, high, low, close)
CDLTASUKIGAP = ta.CDLTASUKIGAP(ope, high, low, close)
CDLTHRUSTING = ta.CDLTHRUSTING(ope, high, low, close)
CDLTRISTAR = ta.CDLTRISTAR(ope, high, low, close)
CDLUNIQUE3RIVER = ta.CDLUNIQUE3RIVER(ope, high, low, close)
CDLUPSIDEGAP2CROWS = ta.CDLUPSIDEGAP2CROWS(ope, high, low, close)
CDLXSIDEGAP3METHODS = ta.CDLXSIDEGAP3METHODS(ope, high, low, close)
f = numpy.column_stack(
(ATR, NATR, TRANGE, HT_DCPERIOD, HT_DCPHASE, HT_PHASOR[0],
HT_PHASOR[1], HT_SINE[0], HT_SINE[1], HT_TRENDMODE, AVGPRICE,
MEDPRICE, TYPPRICE, WCLPRICE, ADX, ADXR, APO, AROON[0], AROON[1],
AROONOSC, BOP, CCI, CMO, DX, MACD[0], MACD[1], MACD[2], MACDEXT[0],
MACDEXT[1], MACDEXT[2], MFI, MINUS_DI, MINUS_DM, MOM, PLUS_DI,
PLUS_DM, PPO, ROC, ROCP, ROCR, RSI, STOCH[0], STOCH[1], STOCHF[0],
STOCHF[1], STOCHRSI[0], STOCHRSI[1], TRIX, ULTOSC, WILLR, CDL2CROWS,
CDL3BLACKCROWS, CDL3INSIDE, CDL3LINESTRIKE, CDL3OUTSIDE,
CDL3STARSINSOUTH, CDL3WHITESOLDIERS, CDLABANDONEDBABY,
CDLADVANCEBLOCK, CDLBELTHOLD, CDLBREAKAWAY, CDLCLOSINGMARUBOZU,
CDLCONCEALBABYSWALL, CDLCOUNTERATTACK, CDLDARKCLOUDCOVER, CDLDOJI,
CDLDOJISTAR, CDLDRAGONFLYDOJI, CDLENGULFING, CDLEVENINGDOJISTAR,
CDLEVENINGSTAR, CDLGAPSIDESIDEWHITE, CDLGRAVESTONEDOJI, CDLHAMMER,
CDLHANGINGMAN, CDLHARAMI, CDLHARAMICROSS, CDLHIGHWAVE, CDLHIKKAKE,
CDLHIKKAKEMOD, CDLHOMINGPIGEON, CDLIDENTICAL3CROWS, CDLINNECK,
CDLINVERTEDHAMMER, CDLKICKING, CDLKICKINGBYLENGTH, CDLLADDERBOTTOM,
CDLLONGLEGGEDDOJI, CDLLONGLINE, CDLMARUBOZU, CDLMATCHINGLOW,
CDLMATHOLD, CDLMORNINGDOJISTAR, CDLMORNINGSTAR, CDLONNECK,
CDLPIERCING, CDLRICKSHAWMAN, CDLRISEFALL3METHODS, CDLSEPARATINGLINES,
CDLSHOOTINGSTAR, CDLSHORTLINE, CDLSPINNINGTOP, CDLSTALLEDPATTERN,
CDLSTICKSANDWICH, CDLTAKURI, CDLTASUKIGAP, CDLTHRUSTING, CDLTRISTAR,
CDLUNIQUE3RIVER, CDLUPSIDEGAP2CROWS, CDLXSIDEGAP3METHODS, BBANDS[0],
BBANDS[1], BBANDS[2], DEMA, EMA, HT_TRENDLINE, KAMA, MA, MAMA[0],
MAMA[1], MIDPOINT, MIDPRICE, SAR, SAREXT, SMA, T3, TEMA, TRIMA, WMA,
AD, ADOSC, OBV))
h = numpy.apply_along_axis(nor, 0, f) # normalize columnwise
df = pandas.DataFrame(
h,
index=S.index,
columns=[
'ATR', 'NATR', 'TRANGE', 'HT_DCPERIOD', 'HT_DCPHASE',
'HT_PHASOR[0]', 'HT_PHASOR[1]', 'HT_SINE[0]', 'HT_SINE[1]',
'HT_TRENDMODE', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE', 'WCLPRICE',
'ADX', 'ADXR', 'APO', 'AROON[0]', 'AROON[1]', 'AROONOSC', 'BOP',
'CCI', 'CMO', 'DX', 'MACD[0]', 'MACD[1]', 'MACD[2]', 'MACDEXT[0]',
'MACDEXT[1]', 'MACDEXT[2]', 'MFI', 'MINUS_DI', 'MINUS_DM', 'MOM',
'PLUS_DI', 'PLUS_DM', 'PPO', 'ROC', 'ROCP', 'ROCR', 'RSI',
'STOCH[0]', 'STOCH[1]', 'STOCHF[0]', 'STOCHF[1]', 'STOCHRSI[0]',
'STOCHRSI[1]', 'TRIX', 'ULTOSC', 'WILLR', 'CDL2CROWS',
'CDL3BLACKCROWS', 'CDL3INSIDE', 'CDL3LINESTRIKE', 'CDL3OUTSIDE',
'CDL3STARSINSOUTH', 'CDL3WHITESOLDIERS', 'CDLABANDONEDBABY',
'CDLADVANCEBLOCK', 'CDLBELTHOLD', 'CDLBREAKAWAY',
'CDLCLOSINGMARUBOZU', 'CDLCONCEALBABYSWALL', 'CDLCOUNTERATTACK',
'CDLDARKCLOUDCOVER', 'CDLDOJI', 'CDLDOJISTAR', 'CDLDRAGONFLYDOJI',
'CDLENGULFING', 'CDLEVENINGDOJISTAR', 'CDLEVENINGSTAR',
'CDLGAPSIDESIDEWHITE', 'CDLGRAVESTONEDOJI', 'CDLHAMMER',
'CDLHANGINGMAN', 'CDLHARAMI', 'CDLHARAMICROSS', 'CDLHIGHWAVE',
'CDLHIKKAKE', 'CDLHIKKAKEMOD', 'CDLHOMINGPIGEON',
'CDLIDENTICAL3CROWS', 'CDLINNECK', 'CDLINVERTEDHAMMER',
'CDLKICKING', 'CDLKICKINGBYLENGTH', 'CDLLADDERBOTTOM',
'CDLLONGLEGGEDDOJI', 'CDLLONGLINE', 'CDLMARUBOZU',
'CDLMATCHINGLOW', 'CDLMATHOLD', 'CDLMORNINGDOJISTAR',
'CDLMORNINGSTAR', 'CDLONNECK', 'CDLPIERCING', 'CDLRICKSHAWMAN',
'CDLRISEFALL3METHODS', 'CDLSEPARATINGLINES', 'CDLSHOOTINGSTAR',
'CDLSHORTLINE', 'CDLSPINNINGTOP', 'CDLSTALLEDPATTERN',
'CDLSTICKSANDWICH', 'CDLTAKURI', 'CDLTASUKIGAP', 'CDLTHRUSTING',
'CDLTRISTAR', 'CDLUNIQUE3RIVER', 'CDLUPSIDEGAP2CROWS',
'CDLXSIDEGAP3METHODS', 'BBANDS[0]', 'BBANDS[1]', 'BBANDS[2]',
'DEMA', 'EMA', 'HT_TRENDLINE', 'KAMA', 'MA', 'MAMA[0]', 'MAMA[1]',
'MIDPOINT', 'MIDPRICE', 'SAR', 'SAREXT', 'SMA', 'T3', 'TEMA',
'TRIMA', 'WMA', 'AD', 'ADOSC', 'OBV'
])
df.to_csv("C:\\Users\\...\\Documents\\Data_TA\\{0}\\{1}.csv".format(s, c))
