def forward(self, close_ts, volume_ts): ts = tsf.rolling_corr(close_ts, volume_ts, 2) return -1 * (tsf.rank(tsf.rolling_mean_(tsf.shift(close_ts, 5), 20)) * ts * tsf.rank( tsf.rolling_corr(tsf.rolling_sum_(close_ts, 5), tsf.rolling_sum_(close_ts, 20), 2)) ) # .values
def forward(self, close_ts, volume_ts): output_tensor = (-1 * ( (tsf.rank((tsf.rolling_sum_(tsf.shift(close_ts, 5), 20) / 20)) * tsf.rolling_corr(close_ts, volume_ts, 2)) * tsf.rank( tsf.rolling_corr(tsf.rolling_sum_(close_ts, 5), tsf.rolling_sum_(close_ts, 20), 2)))) return output_tensor
def forward(self, close_ts, volume_ts): output_tensor = (-1 * ((tsf.rank( ((torch.sign((close_ts - tsf.shift(close_ts, 1))) + torch.sign( (tsf.shift(close_ts, 1) - tsf.shift(close_ts, 2)))) + torch.sign((tsf.shift(close_ts, 2) - tsf.shift(close_ts, 3)))))) * tsf.rolling_sum_(volume_ts, 5)) / tsf.rolling_sum_(volume_ts, 20)) return output_tensor
def forward(self, close_ts, volume_ts): delta_close = tsf.diff(close_ts, 1) inner = torch.sign(delta_close) + torch.sign(tsf.shift( delta_close, 1)) + torch.sign(tsf.shift(delta_close, 2)) alpha = ( (1.0 - tsf.rank(inner)) * tsf.rolling_sum_(volume_ts, 5)) / tsf.rolling_sum_(volume_ts, 20) return alpha
def forward(self, high_ts, low_ts, close_ts): zeros = torch.zeros(high_ts.size()) output_tensor = tsf.rolling_sum_( torch.max(zeros, high_ts - tsf.shift(close_ts, 1)), 20) / tsf.rolling_sum_( torch.max(zeros, tsf.shift(close_ts, 1) - low_ts), 20) * 100 return output_tensor
def forward(self, low_ts, return_ts, volume_ts): output_tensor = (( ((-1 * tsf.rolling_min(low_ts, 5)) + tsf.shift(tsf.rolling_min(low_ts, 5), 5)) * tsf.rank( ((tsf.rolling_sum_(return_ts, 240) - tsf.rolling_sum_(return_ts, 20)) / 220))) * tsf.rolling_min(volume_ts, 5)) return output_tensor
def mfi(high_ts, low_ts, close_ts, total_turnover_ts, timeperiod=14): TP = (high_ts + low_ts + close_ts) / 3 MF = TP * total_turnover_ts zero = torch.zeros_like(high_ts) PMF = torch.where(MF > tsf.shift(MF, window=1), MF, zero) NMF = torch.where(MF < tsf.shift(MF, window=1), MF, zero) MR = tsf.rolling_sum_(PMF, window=timeperiod) / tsf.rolling_sum_(NMF, window=timeperiod) MFI = 100 - (100 / (1 + MR)) return MFI
def forward(self, high_ts, low_ts, volume_ts, vwap_ts, close_ts): output_tensor = ((tsf.rank( tsf.shift(((high_ts - low_ts) / (tsf.rolling_sum_(close_ts, 5) / 5)), 2)) * tsf.rank(tsf.rank(volume_ts))) / (((high_ts - low_ts) / (tsf.rolling_sum_(close_ts, 5) / 5)) / (vwap_ts - close_ts))) return output_tensor
def forward(self, close_ts): cond = ((tsf.diff((tsf.rolling_sum_(close_ts, 100) / 100), 100) / tsf.shift(close_ts, 100)) < 0.05) | ( (tsf.diff((tsf.rolling_sum_(close_ts, 100) / 100), 100) / tsf.shift(close_ts, 100)) == 0.05) consequence1 = (-1 * (close_ts - tsf.rolling_min(close_ts, 100))) consequence2 = (-1 * tsf.diff(close_ts, 3)) output_tensor = torch.where(cond, consequence1, consequence2) return output_tensor
def forward(self, vwap_ts, volume_ts, low_ts): output_tensor = (tsf.rank( tsf.rolling_corr( tsf.rolling_sum_(((low_ts * 0.35) + (vwap_ts * 0.65)), 20), tsf.rolling_sum_(tsf.rolling_mean_(volume_ts, 40), 20), 7)) + tsf.rank( tsf.rolling_corr(tsf.rank(vwap_ts), tsf.rank(volume_ts), 6))) return output_tensor
def forward(self, high_ts, close_ts, volume_ts, vwap_ts): output_tensor = ((((tsf.rank( (1 / close_ts)) * volume_ts) / tsf.rolling_mean_(volume_ts, 20)) * ((high_ts * tsf.rank((high_ts - close_ts))) / (tsf.rolling_sum_(high_ts, 5) / 5))) - tsf.rank( (vwap_ts - tsf.shift(vwap_ts, 5)))) return output_tensor
def ad(high_ts, low_ts, close_ts, volume_ts, fastperiod=3, slowperiod=10): zero = torch.zeros_like(high_ts, dtype=high_ts.dtype, device=high_ts.device) CLV = torch.where(high_ts == low_ts, zero, (2*close_ts-high_ts-low_ts)/(high_ts-low_ts)) AD = tsf.rolling_sum_(volume_ts*CLV, window=2) AD[0] = CLV[0] ADOSC = tsf.ema(AD, window=fastperiod) - tsf.ema(AD, window=slowperiod) return AD, ADOSC
def forward(self, open_ts, low_ts): cond = open_ts >= tsf.shift(open_ts, 1) zeros = torch.zeros(open_ts.size()) inner = torch.where( cond, zeros, torch.max((open_ts - low_ts), (open_ts - tsf.shift(open_ts, 1)))) output_tensor = tsf.rolling_sum_(inner, 20) return output_tensor
def forward(self, close_ts, volume_ts): cond1 = close_ts > tsf.shift(close_ts, 1) zeros = torch.zeros(close_ts.size()) inner1 = torch.where(cond1, volume_ts, zeros) cond2 = close_ts <= tsf.shift(close_ts, 1) inner2 = tsf.rolling_sum_(torch.where(cond2, volume_ts, zeros), self.window) output_tensor = inner1 / inner2 return output_tensor
def forward(self, close_ts, low_ts, high_ts): cond1 = tsf.diff(close_ts, 1) > 0 zeros = torch.zeros(close_ts.size()) inner = torch.where(cond1, torch.min(low_ts, tsf.shift(close_ts, 1)), torch.max(high_ts, tsf.shift(close_ts, 1))) cond2 = tsf.diff(close_ts, 1) == 0 inner = torch.where(cond2, zeros, inner) output_tensor = tsf.rolling_sum_(inner, 20) return output_tensor
def forward(self, close_ts, returns_ts): return tsf.rolling_min( tsf.rank( tsf.rank( tsf.rolling_scale( torch.log( tsf.rolling_sum_( tsf.rank( tsf.rank(-1 * tsf.rank( tsf.diff((close_ts - 1), 5)))), 2))))), 5) + tsf.ts_rank(tsf.shift((-1 * returns_ts), 6), 5)
def uos(high_ts, low_ts, close_ts, timeperiod1=7, timeperiod2=14, timeperiod3=28, timeperiod4=6): TH = torch.max(high_ts, tsf.shift(close_ts, window=1)) TL = torch.min(low_ts, tsf.shift(close_ts, window=1)) ACC1 = tsf.rolling_sum_(close_ts-TL, window=timeperiod1) / tsf.rolling_sum_(TH-TL, window=timeperiod1) ACC2 = tsf.rolling_sum_(close_ts-TL, window=timeperiod2) / tsf.rolling_sum_(TH-TL, window=timeperiod2) ACC3 = tsf.rolling_sum_(close_ts-TL, window=timeperiod3) / tsf.rolling_sum_(TH-TL, window=timeperiod3) UOS = (ACC1*timeperiod2*timeperiod3 + ACC2*timeperiod1*timeperiod3 + ACC3*timeperiod1*timeperiod2) * 100 / (timeperiod1*timeperiod2 + timeperiod1*timeperiod3 + timeperiod2*timeperiod3) MAUOS = tsf.ema(UOS, window=timeperiod4) return UOS, MAUOS
def forward(self, close_ts, open_ts, high_ts, low_ts): inner1 = tsf.rolling_sum_( 16 * (close_ts - tsf.shift(close_ts, 1) + (close_ts - open_ts) / 2 + tsf.shift(close_ts, 1) - tsf.shift(open_ts, 1))) cond1 = (torch.abs(high_ts - tsf.shift(close_ts, 1)) > torch.abs(low_ts - tsf.shift(close_ts, 1))) & ( torch.abs(high_ts - tsf.shift(close_ts, 1)) > torch.abs(high_ts - tsf.shift(low_ts, 1))) sequence1 = torch.abs(high_ts - tsf.shift(close_ts, 1)) + torch.abs( low_ts - tsf.shift(close_ts, 1)) / 2 + torch.abs( tsf.shift(close_ts, 1) - tsf.shift(open_ts, 1)) / 4 cond2 = (torch.abs(low_ts - tsf.shift(close_ts, 1)) > torch.abs(high_ts - tsf.shift(low_ts, 1))) & ( torch.abs(low_ts - tsf.shift(close_ts, 1)) > torch.abs(high_ts - tsf.shift(close_ts, 1))) sequence2 = torch.abs(high_ts - tsf.shift(low_ts, 1)) + torch.abs( tsf.shift(close_ts, 1) - tsf.shift(open_ts, 1)) / 4 inner2 = torch.where((~cond1 & ~cond2), sequence2, sequence1) output_tensor = inner1 / inner2 return output_tensor
def forward(self, high_ts, low_ts, close_ts): zeros = torch.zeros(high_ts.size()) LD = tsf.shift(low_ts, 1) - low_ts HD = high_ts - tsf.shift(high_ts, 1) TR = torch.max( torch.max(high_ts - low_ts, torch.abs(high_ts - tsf.shift(close_ts, 1))), torch.abs(low_ts - tsf.shift(close_ts, 1))) cond1 = (LD > 0) & (LD > HD) inner1 = torch.where(cond1, LD, zeros) cond2 = (HD > 0) & (HD > LD) inner2 = torch.where(cond2, HD, zeros) cond3 = (LD > 0) & (LD > HD) inner3 = torch.where(cond3, LD, zeros) cond4 = (HD > 0) & (HD > LD) inner4 = torch.where(cond4, HD, zeros) output_tensor = tsf.rolling_mean_( tsf.rolling_sum_(inner1, 14) * 100 / tsf.rolling_sum_(TR, 14) - tsf.rolling_sum_(inner2, 14) * 100 / tsf.rolling_sum_(TR, 14) / (tsf.rolling_sum_(inner3, 14) * 100 / tsf.rolling_sum_(TR, 14) + tsf.rolling_sum_(inner4, 14) * 100 / tsf.rolling_sum_(TR, 14)) * 100, 6) return output_tensor
def forward(self, high_ts, close_ts, low_ts): output_tensor = (close_ts - tsf.rolling_sum_( torch.min(low_ts, tsf.shift(close_ts, 1)), 6)) / tsf.rolling_sum_( torch.max(high_ts, tsf.shift(close_ts, 1)) - torch.min(low_ts, tsf.shift(close_ts, 1)), 6) * 12 * 24 + ( close_ts - tsf.rolling_sum_( torch.min(low_ts, tsf.shift(close_ts, 1)), 12) ) / tsf.rolling_sum_( torch.max(high_ts, tsf.shift(close_ts, 1)) - torch.min(low_ts, tsf.shift(close_ts, 1)), 12) * 6 * 24 + (close_ts - tsf.rolling_sum_( torch.min(low_ts, tsf.shift(close_ts, 1)), 24)) / tsf.rolling_sum_( torch.max(high_ts, tsf.shift(close_ts, 1)) - torch.min(low_ts, tsf.shift(close_ts, 1)), 24) * 6 * 24 * 100 / (6 * 12 + 6 * 24 + 12 * 24) return output_tensor
def forward(self, high_ts, low_ts, close_ts, volume_ts): output_tensor = tsf.rolling_sum_(((close_ts - low_ts) - (high_ts - close_ts)) / (high_ts - low_ts) * volume_ts, self.window) return output_tensor
def forward(self, close_ts): cond = tsf.diff(close_ts, 1) > 0 zeros = torch.zeros(close_ts.size()) output_tensor = tsf.rolling_sum_(torch.where(cond, close_ts - tsf.shift(close_ts, 1), zeros), self.window) return output_tensor
def forward(self, high_ts, close_ts): zeros = torch.zeros(high_ts.size()) cond = tsf.diff(close_ts, 1) < 0 output_tensor = tsf.rolling_sum_(torch.where(cond, torch.abs(tsf.diff(close_ts, 1)), zeros), self.window) return output_tensor
def forward(self, close_ts, volume_ts): sign = torch.sign(tsf.diff(close_ts, 1)) output_tensor = tsf.rolling_sum_(sign * volume_ts, self.window) return output_tensor
def forward(self, open_ts, returns_ts): output_tensor = -1 * (tsf.rank( ((tsf.rolling_sum_(open_ts, 5) * tsf.rolling_sum_(returns_ts, 5)) - tsf.shift((tsf.rolling_sum_(open_ts, 5) * tsf.rolling_sum_(returns_ts, 5)), 10)))) return output_tensor
def forward(self, low_ts, volume_ts, returns_ts): return ((-1 * tsf.diff(tsf.rolling_min(low_ts, 5), 5)) * tsf.rank( ((tsf.rolling_sum_(returns_ts, 60) - tsf.rolling_sum_( returns_ts, 20)) / 55))) * tsf.ts_rank(volume_ts, 5)
def forward(self, high_ts, low_ts, open_ts): output_tensor = tsf.rolling_sum_(high_ts - open_ts, 20) / tsf.rolling_sum_( open_ts - low_ts, 20) * 100 return output_tensor
def forward(self, close_ts, returns_ts): alpha = ((-1 * torch.sign( (close_ts - tsf.shift(close_ts, 7)) + tsf.diff(close_ts, 7))) * (1 + tsf.rank(1 + tsf.rolling_sum_(returns_ts, 210)))) return alpha
def forward(self, high_ts, volume_ts): df = tsf.rolling_cov(tsf.rank(high_ts), tsf.rank(volume_ts), 3) alpha = -1 * tsf.rolling_sum_(tsf.rank(df), 3) return alpha
def obv(close_ts, volume_ts): zero = torch.zeros_like(volume_ts, dtype=volume_ts.dtype, device=volume_ts.device) volume_new = torch.where(close_ts == tsf.shift(close_ts, window=1), zero, torch.where(close_ts > tsf.shift(close_ts, window=1), volume_ts, -volume_ts)) volume_new[0] = volume_ts[0] OBV = tsf.rolling_sum_(volume_new, window=2) return OBV