def forward(self, volume_ts, close_ts): output_tensor = ( ((-1 * tsf.rank(tsf.ts_rank(close_ts, 10))) * tsf.rank(tsf.diff(tsf.diff(close_ts, 1), 1))) * tsf.rank( tsf.ts_rank( (volume_ts / tsf.rolling_mean_(volume_ts, 20)), 5))) return output_tensor
def forward(self, close_ts): cond = (tsf.diff(tsf.rolling_mean_(close_ts, 100), 100) / tsf.shift(close_ts, 100) <= 0.05).squeeze() alpha = -1 * tsf.diff(close_ts, 3).squeeze() result = torch.where( cond, -1 * (close_ts - tsf.rolling_min(close_ts, 100)).squeeze(), alpha) return result
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, volume_ts): adv20 = tsf.rolling_mean_(volume_ts, 20) alpha = -1 * tsf.ts_rank(abs(tsf.diff(close_ts, 7)), 60) * torch.sign( tsf.diff(close_ts, 7)) cond = adv20 >= volume_ts ones = torch.ones(close_ts.size()) output_tensor = torch.where( cond, -1 * ones, alpha.float()) # confusing why must .float() 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, tensor_close): DIF, DEA, MACD = talib_func.macdfix(tensor_close, signalperiod=9) norm_DIF = torch.clamp(DIF, min=-1, max=1).squeeze(-1) norm_DEA = torch.clamp(DEA, min=-1, max=1).squeeze(-1) norm_MACD = torch.clamp(MACD, min=-1, max=1).squeeze(-1) norm_DIF_diff = torch.clamp(tsf.diff(DIF), min=-1, max=1).squeeze(-1) norm_DEA_diff = torch.clamp(tsf.diff(DEA), min=-1, max=1).squeeze(-1) norm_MACD_diff = torch.clamp(tsf.diff(MACD), min=-1, max=1).squeeze(-1) return norm_DIF, norm_DEA, norm_MACD, norm_DIF_diff, norm_DEA_diff, norm_MACD_diff
def forward(self, close_ts): delta_close = tsf.diff(close_ts, 1) cond_1 = (tsf.rolling_max(delta_close, self.window) > 0).squeeze() cond_2 = (tsf.rolling_max(delta_close, self.window) < 0).squeeze() alpha = -1 * delta_close result = torch.where((cond_1 | cond_2), alpha, delta_close) return result
def forward(self, close_ts, open_ts, vwap_ts, volume_ts): output_tensor = ( tsf.rank(tsf.diff( ((close_ts * 0.6 + open_ts * 0.4)), 1)) * tsf.rank( tsf.rolling_corr(vwap_ts, tsf.rolling_mean_( volume_ts, 150), 15))) return output_tensor
def forward(self, tensor_close): DIF, DEA, MACD = talib_func.macdext(tensor_close, fastperiod=self.fastperiod, fastmatype=self.fastmatype, slowperiod=self.slowperiod, slowmatype=self.slowmatype, signalperiod=self.signalperiod, signalmatype=self.signalmatype) norm_DIF = torch.clamp(DIF, min=-1, max=1).squeeze(-1) norm_DEA = torch.clamp(DEA, min=-1, max=1).squeeze(-1) norm_MACD = torch.clamp(MACD, min=-1, max=1).squeeze(-1) norm_DIF_diff = torch.clamp(tsf.diff(DIF), min=-1, max=1).squeeze(-1) norm_DEA_diff = torch.clamp(tsf.diff(DEA), min=-1, max=1).squeeze(-1) norm_MACD_diff = torch.clamp(tsf.diff(MACD), min=-1, max=1).squeeze(-1) return norm_DIF, norm_DEA, norm_MACD, norm_DIF_diff, norm_DEA_diff, norm_MACD_diff
def forward(self, tensor): DIF, DEA, MACD = talib_func.macd(tensor, fastperiod=self.fastperiod, slowperiod=self.slowperiod, signalperiod=self.signalperiod) #norm_macd = np.minimum(np.maximum(np.nan_to_num(macd), -1), 1) # norm norm_DIF = torch.clamp(DIF, min=-1, max=1).squeeze(-1) norm_DEA = torch.clamp(DEA, min=-1, max=1).squeeze(-1) norm_MACD = torch.clamp(MACD, min=-1, max=1).squeeze(-1) #pdb.set_trace() # diff norm_DIF_diff = torch.clamp(tsf.diff(DIF), min=-1, max=1).squeeze(-1) norm_DEA_diff = torch.clamp(tsf.diff(DEA), min=-1, max=1).squeeze(-1) norm_MACD_diff = torch.clamp(tsf.diff(MACD), min=-1, max=1).squeeze(-1) return norm_DIF, norm_DEA, norm_MACD, norm_DIF_diff, norm_DEA_diff, norm_MACD_diff
def forward(self, high_ts, low_ts, close_ts): inner = (close_ts - low_ts).squeeze() constant = 0.0001 * torch.ones(close_ts.size()).squeeze() cond = inner == 0 inner = torch.where(cond, constant, inner) result = -1 * tsf.diff((((close_ts - low_ts) - (high_ts - close_ts)).squeeze() / inner), 9) return result
def forward(self, close_ts): inner = (((tsf.shift(close_ts, 20) - tsf.shift(close_ts, 10)) / 10) - ((tsf.shift(close_ts, 10) - close_ts) / 10)).squeeze() alpha = (-1 * tsf.diff(close_ts)).squeeze() ones = torch.ones(close_ts.size()).squeeze() cond = (inner < -0.05).squeeze() result = torch.where(cond, ones, alpha) return result
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, close_ts): inner = ((tsf.shift(close_ts, 20) - tsf.shift(close_ts, 10)) / 10).squeeze() - ( (tsf.shift(close_ts, 10) - close_ts) / 10).squeeze() cond_1 = inner < 0 cond_2 = inner > 0.25 alpha = (-1 * tsf.diff(close_ts).squeeze()) ones = torch.ones(close_ts.size()).squeeze() result = torch.where((cond_1 | cond_2), -1 * ones, alpha) return result
def test_diff_inverse(self): output_diff = tsf.diff(self.test_2d_change, -1) output_diff = torch.where(torch.isnan(output_diff), torch.full_like(output_diff, 666), output_diff) # fillna expected = torch.tensor([[-1, 1], [-1, 1], [-1, 1], [-1, 1], [np.nan, np.nan]]) expected = torch.where(torch.isnan(expected), torch.full_like(expected, 666), expected) result = (expected == output_diff).all().item() self.assertTrue(result, 'test_diff_inverse failed')
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 forward(self, high_ts): cond = (tsf.rolling_mean_(high_ts, 20) < high_ts).squeeze() zeros = torch.zeros(high_ts.size()).squeeze() result = torch.where(cond, -1 * tsf.diff(high_ts, 2).squeeze(), zeros) return result
def forward(self, close_ts, high_ts, low_ts): output_tensor = (-1 * tsf.diff((((close_ts - low_ts) - (high_ts - close_ts)) / (high_ts - low_ts)), 1)) 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, high_ts): cond = tsf.rolling_mean(high_ts, self.window) < high_ts zeros = torch.zeros(high_ts.size()) output_tensor = torch.where(cond, (-1 * tsf.diff(high_ts, 2)), zeros) return output_tensor
def forward(self, volume_ts, return_ts): output_tensor = (-1 * tsf.rolling_corr(tsf.diff(torch.log(volume_ts), 1), return_ts), self.window) return output_tensor
def forward(self, close_ts): output_tensor = tsf.diff(close_ts, self.window) return output_tensor
def forward(self, close_ts, volume_ts): return torch.sign(tsf.diff(volume_ts, 1)) * (-1 * tsf.diff(close_ts, 1))
def forward(self, open_ts, close_ts, volume_ts): # volume output_tensor = -1 * tsf.rolling_corr( tsf.rank(tsf.diff(torch.log(volume_ts), 2)), tsf.rank((close_ts - open_ts) / open_ts), 6) return output_tensor
def forward(self, close_ts, returns_ts): inner = tsf.rolling_std(returns_ts, 2) / tsf.rolling_std(returns_ts, 5) return tsf.rank(2 - tsf.rank(inner) - tsf.rank(tsf.diff(close_ts, 1))) # .values
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, close_ts, volume_ts): adv20 = tsf.rolling_mean_(volume_ts, 20) alpha = tsf.ts_rank(volume_ts / adv20, 20) * tsf.ts_rank( (-1 * tsf.diff(close_ts, 7)), 8) return alpha
def forward(self, high_ts, close_ts, volume_ts): ts = tsf.rolling_cov(high_ts, volume_ts, 5) alpha = -1 * tsf.diff(ts, 5) * tsf.rank(tsf.rolling_std(close_ts, 20)) return alpha