def forward(self, close_ts, volume_ts):
output_tensor = tsf.rolling_std(
torch.abs((close_ts / tsf.shift(close_ts, 1) - 1)) / volume_ts,
20) / tsf.rolling_mean_(
torch.abs(
(close_ts / tsf.shift(close_ts, 1) - 1)) / volume_ts, 20)
return output_tensor
def forward(self, close_ts, low_ts, high_ts):
zeros = torch.zeros(low_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_(
torch.abs(
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) + tsf.shift(
tsf.rolling_mean_(
torch.abs(
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), 6)) / 2
return output_tensor
def forward(self, high_ts, low_ts, close_ts):
output_tensor = tsf.rolling_mean_(
torch.max(
torch.max((high_ts - low_ts),
torch.abs(tsf.shift(close_ts, 1) - high_ts)),
torch.abs(tsf.shift(close_ts, 1) - low_ts)), 6)
return output_tensor
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, 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, 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, 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):
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):
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 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):
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, 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, low_ts, high_ts):
cond1 = close_ts == tsf.shift(close_ts, 1)
cond2 = close_ts > tsf.shift(close_ts, 1)
zeros = torch.zeros(close_ts.size())
consequance1 = close_ts - torch.min(low_ts, tsf.shift(close_ts, 1))
consequance2 = close_ts - torch.max(high_ts, tsf.shift(close_ts, 1))
inner = torch.where(cond2, consequance1, consequance2)
output_tensor = torch.where(cond1, zeros, inner)
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, close_ts):
cond1 = close_ts < tsf.shift(close_ts, 5)
cond2 = close_ts == tsf.shift(close_ts, 5)
inner = (close_ts - tsf.shift(close_ts, 5)) / tsf.shift(close_ts, 5)
zeros = torch.zeros(close_ts.size())
output_tensor = torch.where(
cond1, inner, (close_ts - tsf.shift(close_ts, 5)) / close_ts)
output_tensor = torch.where((~cond1 & cond2), zeros, output_tensor)
return output_tensor
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 dmi(high_ts, low_ts, close_ts, timeperiod=14):
up = high_ts - tsf.shift(high_ts, window=1)
down = tsf.shift(low_ts, window=1) - low_ts
zero = torch.zeros_like(high_ts, dtype=high_ts.dtype, device=high_ts.device)
PDM = torch.where(up>torch.max(down, zero), up, zero)
MDM = torch.where(down>torch.max(up, zero), down, zero)
TR14 = tsf.rolling_mean_(torch.max(high_ts, tsf.shift(close_ts, window=1)) - torch.min(low_ts, tsf.shift(close_ts, window=1)), window=14)
PDI = PDM / TR14[-1] * 100
MDI = MDM / TR14[-1] * 100
DX = torch.abs(PDI - MDI) / torch.abs(PDI + MDI)
ADX = tsf.ema(DX, window=timeperiod)
ADXR = tsf.ema(ADX, window=timeperiod)
return PDM, MDM, PDI, MDI, DX, ADX, ADXR
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, 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 forward(self, tensor):
"""defalt input is close"""
returns = tsf.pct_change(tensor, period=1)
sharp_ratio = tsf.rolling_mean_(returns,
window=self._window) / tsf.rolling_std(
returns, window=self._window)
return tsf.shift(sharp_ratio, window=self._lag_window).squeeze(-1)
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, 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, 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, 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 test_shift_backward(self):
output_diff = tsf.shift(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([[2, 4], [3, 3], [4, 2], [5, 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_shift_backward 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, 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, open, close):
shift_tensor = tsf.shift(close, window=1)
diff = open - shift_tensor
output = diff.div(shift_tensor)
output_ts = tsf.pct_change(output, period=self._window)
return output_ts
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, close_ts):
output_tensor = close_ts / tsf.shift(close_ts, self.window)
return output_tensor
