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
