def forward(self, high_ts, low_ts, close_ts, volume_ts):
output_tensor = tsf.rolling_corr(
tsf.rank((
(close_ts - tsf.rolling_min(low_ts, 12)) /
(tsf.rolling_max(high_ts, 12) - tsf.rolling_min(low_ts, 12)))),
tsf.rank(volume_ts), 6)
return output_tensor
def kdj(high_ts, low_ts, close_ts, fastk_period=9, slowk_period=3, slowd_period=3):
range_ts = tsf.rolling_max(high_ts, window=fastk_period) - tsf.rolling_min(low_ts, window=fastk_period)
RSV = (close_ts - tsf.rolling_min(low_ts, fastk_period).squeeze(-1)) / torch.clamp(range_ts.squeeze(-1),min=1)
K = tsf.ema(RSV, window=slowk_period).squeeze(-1)
D = tsf.ema(K, slowd_period).squeeze(-1)
J = 3*K - 2*D
return RSV, K, D, J
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 forward(self, high_ts, low_ts, close_ts, volume_ts):
divisor = (tsf.rolling_max(high_ts, 12) -
tsf.rolling_min(low_ts, 12)).replace(0, 0.0001)
inner = (close_ts - tsf.ts_min(low_ts, 12)) / (divisor)
ts = tsf.rolling_corr(tsf.rank(inner), tsf.rank(volume_ts), 6)
output_tensor = -1 * ts
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, volume_ts, vwap_ts):
output_tensor = ((tsf.rank(
(vwap_ts - tsf.rolling_min(vwap_ts, 12)))**tsf.ts_rank(
tsf.rolling_corr(
tsf.ts_rank(vwap_ts, 20),
tsf.ts_rank(tsf.rolling_mean_(volume_ts, 60), 2), 18), 3))
* -1)
return output_tensor
def forward(self, tensor_x, tensor_y):
if tensor_x.dim() < tensor_y.dim():
tensor_x = tensor_x.expand_as(tensor_y)
residual = calc_residual3d(tensor_x,
tensor_y,
window=self._window_train,
keep_first_nan=True)
residual = residual.squeeze(-1).transpose(0, 1)
return tsf.rolling_min(residual, self._window)
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, 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, 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 wr(high_ts, low_ts, close_ts, timeperiod=14):
HT = tsf.rolling_max(high_ts, window=timeperiod)
LT = tsf.rolling_min(low_ts, window=timeperiod)
WR = (HT - close_ts) / (HT - LT) * 100
return WR
def natr(high_ts, low_ts, close_ts, timeperiod=14):
true_range = torch.max(high_ts, tsf.shift(close_ts, window=1)) - torch.min(low_ts, tsf.shift(close_ts, window=1))
TRange_max = tsf.rolling_max(true_range, window=timeperiod)
TRange_min = tsf.rolling_min(true_range, window=timeperiod)
natr = tsf.rolling_mean_((true_range - TRange_min) / (TRange_max - TRange_min), window=timeperiod)
return natr
def forward(self, tensor: torch.tensor) -> torch.tensor:
return tsf.rolling_min(data_ts=tensor, window=self._window)