def get_barwidth(self, X, width=None):
# The Xaxis could be dates and so on, so we want to calculate
# the with of this bastard independently of that
if (len(X.shape)):
X = X.flatten()
print(X.shape)
print("X axis type: ", type(X[0]).__name__)
if (type(width) == type(None)):
width = 1
# print width
if (type(X[0]).__name__ == "Timestamp"
): # or (type(X[0]).__name__ == "datetime64" )
width_size = min(bMl.diff(X)[1:])
width_size = (width_size.total_seconds()) / (24.0 * 60 * 60)
else:
width_size = min(bMl.diff(X)[1:]) # (X[1] - X[0])
# print type(X[0,0])
# print X.shape
# width_size = min(bMa.diff(X, cval = 10000))
# width_size = (width_size.total_seconds())/ (24.0*60*60)
width = width_size * width
# print type(X[0])
width = float(width)
print("width is: ", width)
return width
def get_RSI(prices, n=14):
"""
The relative strength index (RSI) is a momentum indicator that
compares the magnitude of recent gains and losses
over a specified time period to measure
speed and change of price movements of a security.
It is primarily used to attempt to identify overbought
or oversold conditions in the trading of an asset.
"""
# First we calculate the increases to then separate them into
# increasing instances and decreasing instances
deltas = bMa.diff(prices, lag = 1)
# For the first N samples we will not be able to do it properli
## What we do is a rolling mean of the positive and the negative
dUp, dDown = deltas.copy(), deltas.copy()
## Vector of positive and negative
dUp[dUp < 0] = 0
dDown[dDown > 0] = 0
# Calculate the rolling mean, the Window !!
# Calculates the average dUp and dDown in time
RolUp = pd.rolling_mean(dUp, n)
RolDown = np.abs(pd.rolling_mean(dDown, n))
# print RolUp[0:30]
# To avoid division by 0
RS = RolUp / (RolDown +0.0000001)
RSI = 100. - 100. / (1. + RS)
return RSI
def get_Residuals_LinearModel(X_data, price, lag = 20):
# This functions gets the residuals when we train a linear model with
# the X_data into predictiong the price return with a given lag.
## Prediction of the thingies
Y_data = bMA.diff(price, lag = lag, cval = np.NaN)
Y_data = bMA.shift(Y_data, lag = -lag, cval = np.NaN)
## Eliminate the Nans !! Even if they appear in just one dim
mask_X = np.sum(np.isnan(X_data), axis = 1) == 0
mask_Y = np.isnan(Y_data) == 0
mask = mask_X & mask_Y[:,0]
# Create linear regression object
regr = linear_model.LinearRegression()
# Train the model using the training sets
regr.fit(X_data[mask,:], Y_data[mask,:])
# coeffs = np.array([regr.intercept_, regr.coef_])[0]
coeffs = np.append(regr.intercept_, regr.coef_)
params = np.array(coeffs)
residual = regr.residues_
residual = regr.score(X_data[mask,:], Y_data[mask,:])
return residual
def get_Residuals_LinearModel(X_data, price, lag=20):
# This functions gets the residuals when we train a linear model with
# the X_data into predictiong the price return with a given lag.
## Prediction of the thingies
Y_data = bMA.diff(price, lag=lag, cval=np.NaN)
Y_data = bMA.shift(Y_data, lag=-lag, cval=np.NaN)
## Eliminate the Nans !! Even if they appear in just one dim
mask_X = np.sum(np.isnan(X_data), axis=1) == 0
mask_Y = np.isnan(Y_data) == 0
mask = mask_X & mask_Y[:, 0]
# Create linear regression object
regr = linear_model.LinearRegression()
# Train the model using the training sets
regr.fit(X_data[mask, :], Y_data[mask, :])
# coeffs = np.array([regr.intercept_, regr.coef_])[0]
coeffs = np.append(regr.intercept_, regr.coef_)
params = np.array(coeffs)
residual = regr.residues_
residual = regr.score(X_data[mask, :], Y_data[mask, :])
return residual
def get_momentum (time_series, N = 1):
"""
The Momentum Technical Indicator measures the amount that a
security's price has changed over a given time span.
It is used with the closed price
There are several variations of the momentum indicator,
but whichever version is used, the momentum (M) is a
comparison between the current closing price (CP) a closing price
"n" periods ago (CPn). The "n" is determined by you.
In the attached chart, Momentum is set to "10," so the indicator
is comparing the current price to the price 10 time instances ago
(because it is a 1-minute chart).
"""
# diff = bMa.diff(time_series, lag = 1, n = 2)
# diff = bMa.diff([1,2,3,4,5,6,7,8], lag = 1, n = 2)
# print diff[0:10,:]
# print time_series[0:10,:]
momentum = bMa.diff(time_series, lag = N, n = 2)
return momentum
def get_barwidth(self, X, width):
# The Xaxis could be dates and so on, so we want to calculate
# the with of this bastard independently of that
if (width < 0):
width = 1
# print width
if (type(X[0]).__name__ == "Timestamp"):
width_size = min(ul.diff(X))
width_size = (width_size.total_seconds()) / (24.0 * 60 * 60)
else:
width_size = (X[1] - X[0])
width_size = min(bMa.diff(X, cval=10000))
width = width_size * width
# print type(X[0])
width = float(width)
return width
if (preprocessing_data):
timeData = tut.preprocess_data(timeData, sdate, edate)
## Get the valid trading days sorted
days_keys, day_dict = timeData.get_indexDictByDay()
Ndays = len(days_keys)
timeData_daily = tut.get_daily_timedata(timeData, symbols[0])
H, L, O, C, V = np.array(
timeData_daily.TD[["High", "Low", "Open", "Close", "Volume"]][:]).T
if (extract_features):
"""
Create the target for the regressing and classifier systems
"""
Target = bMl.diff(C).flatten() # Continuous target .Target[0] = NaN
Target_bin = np.zeros(Target.shape) # Binarized target
Target_bin[np.where(Target >= 0)] = 1
data_df = None
## Create Pandas Data Frame for the information of the ML problem
data_df = pd.DataFrame({
'Time': days_keys,
'Target_clas': Target_bin,
'Target_reg': Target
})
data_df.set_index('Time', inplace=True)
## Every feature that is computed for each day has to be lagged before introducing
## it into the dataframe so that the input features do not contain information
## from their target day
yerr = ypred - y # Difference at each point, between the predicted and the real.
for i in range (Ns):
yerr_i = yerr[[i],:]
logpred += np.log(np.linalg.det(SigmaYYpredList[i]))
logpred += (yerr_i.T).dot(np.linalg.inv(SigmaYYpredList[i])).dot(yerr_i)
logpred = -logpred/2
logpred -= Ns/np.log(np.pi * 2)
return logpred
if (KM == 1):
# Kalman Filter !
timeSeries = timeData.get_timeSeries(["Close"]);
returns = timeData.get_timeSeriesReturn() # Variable to estimate. Nsig x Ndim
returns = bMA.diff(timeSeries, cval = 0.000001)
dates = timeData.get_dates()
dates = ul.fnp(ul.datesToNumbers(dates))
dates = ul.fnp(range(dates.size))
############################ Create the data #######################################
Matrix_tr = np.concatenate([timeSeries,returns], axis = 1) # Nsam * 4
Ns,Nd = Matrix_tr.shape
########################### AR matrix ###############################
# We assume as simple relationship
# P_t = P_(t-1) + vP_(t-1) -> The dinamics of the next price
# vxt = vx_(t-1) -> The dinamics of the next return
A = np.array([[1,0.99],
[0,1]])
######################### C Matrix ###################################
# We get now the moving averages indx = 1 lag = 35 ## MACD Parameters !! n_fast = 12 n_slow = 26 n_smooth = 9 EMAfast = Cartera.EMA(n=n_fast) EMAslow = Cartera.EMA(n=n_slow) MACD = EMAfast - EMAslow MACD = pd.ewma(MACD, span=n_smooth, min_periods=n_smooth - 1) # Smoothin of velocity, we want to enter when it is falling MACD_vel = bMA.diff(MACD, n=1) nsmooth_vel = 4 MACD_vel = indl.get_SMA(MACD_vel, L=nsmooth_vel) ## RSI Parameter ! RSI = Cartera.RSI(n=14) RSI_vel = bMA.diff(RSI, n=1) #RSI_vel = indl.get_SMA(RSI_vel, L = nsmooth_vel) ## ATR Parameter ! ATR = Cartera.ATR(n=14) ATR_vel = bMA.diff(ATR, n=1) RSI_vel = indl.get_SMA(ATR_vel, L=nsmooth_vel) ########################################################### ################# PREPARE THE DATA ########################
yerr = ypred - y # Difference at each point, between the predicted and the real.
for i in range (Ns):
yerr_i = yerr[[i],:]
logpred += np.log(np.linalg.det(SigmaYYpredList[i]))
logpred += (yerr_i.T).dot(np.linalg.inv(SigmaYYpredList[i])).dot(yerr_i)
logpred = -logpred/2
logpred -= Ns/np.log(np.pi * 2)
return logpred
if (KM == 1):
# Kalman Filter !
timeSeries = timeData.get_timeSeries(["Close"]);
returns = timeData.get_timeSeriesReturn() # Variable to estimate. Nsig x Ndim
returns = bMA.diff(timeSeries, cval = 0.000001)
dates = timeData.get_dates()
dates = ul.fnp(ul.datesToNumbers(dates))
dates = ul.fnp(range(dates.size))
############################ KALMAN FILTER !! #######################################
Matrix_tr = np.concatenate([timeSeries,returns], axis = 1) # Nsam * 4
Ns,Nd = Matrix_tr.shape
Nout = 1 # Number of output
# System of equations A
# Xt = A*Xt-1 + B*Ut + SystemNoise
# Yt = Cx_k + MeasurementNoise
# In the normal formulation Xt is a column vector !!
timeData.set_csv(storage_folder,file_name) # Load the data into the model
if (preprocessing_data):
timeData = tut.preprocess_data(timeData, sdate,edate)
## Get the valid trading days sorted
days_keys, day_dict = timeData.get_indexDictByDay()
Ndays = len(days_keys)
timeData_daily = tut.get_daily_timedata(timeData, symbols[0])
H,L,O,C,V = np.array(timeData_daily.TD[["High","Low","Open","Close","Volume"]][:]).T
"""
Create the target for the classifier:
"""
Target = bMl.diff(C).flatten() # Continuous target Target[0] = NaN
Target_bin = np.zeros(Target.shape) # Binarized
Target_bin[np.where(Target >=0)] = 1
## Create Pandas Data Frame for the information of the ML problem
data_df = pd.DataFrame({'Time': days_keys, 'Target_clas': Target_bin, 'Target_reg': Target}) # 'Current_diff': Target}
data_df.set_index('Time',inplace = True)
"""
#########################################################
CREATE WINDOWED VECTOR OF FEATURES !!
#########################################################
"""
Nlast_Close = 2 # The last Diff in Close and increase
prices = Cartera.get_timeSeries() dates = Cartera.get_dates(period, Cartera.symbol_names[0]) # We get now the moving averages indx = 1 lag = 35 ## MACD Parameters !! n_fast = 12; n_slow = 26; n_smooth = 9 EMAfast = Cartera.EMA(n = n_fast) EMAslow = Cartera.EMA(n = n_slow) MACD = EMAfast - EMAslow MACD = pd.ewma(MACD, span = n_smooth, min_periods = n_smooth - 1) # Smoothin of velocity, we want to enter when it is falling MACD_vel = bMA.diff(MACD,n = 1) nsmooth_vel = 4 MACD_vel = indl.get_SMA(MACD_vel, L = nsmooth_vel) ## RSI Parameter ! RSI = Cartera.RSI(n = 14) RSI_vel = bMA.diff(RSI,n = 1) #RSI_vel = indl.get_SMA(RSI_vel, L = nsmooth_vel) ## ATR Parameter ! ATR = Cartera.ATR(n = 14) ATR_vel = bMA.diff(ATR,n = 1) RSI_vel = indl.get_SMA(ATR_vel, L = nsmooth_vel) ########################################################### ################# PREPARE THE DATA ########################
