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):
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, vwap_ts, low_ts, volume_ts):
output_tensor = (
tsf.rank(tsf.rolling_corr(vwap_ts, volume_ts, 4)) * tsf.rank(
tsf.rolling_corr(tsf.rank(low_ts),
tsf.rank(tsf.rolling_mean_(volume_ts, 50)),
12)))
return output_tensor
def forward(self, high_ts, low_ts, close_ts, volume_ts):
output_tensor = (tsf.rank(
tsf.rolling_corr(
((high_ts * 0.9) + (close_ts * 0.1)),
tsf.rolling_mean_(volume_ts, 30), 10))**tsf.rank(
tsf.rolling_corr(tsf.ts_rank(((high_ts + low_ts) / 2), 4),
tsf.ts_rank(volume_ts, 10), 7)))
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, 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, 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 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, 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, open_ts, volume_ts):
output_tensor = -1 * tsf.rolling_corr(tsf.rank(open_ts),
tsf.rank(volume_ts), 10)
return output_tensor
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,high, low, volume):
return -1 * tsf.rolling_corr(high/low,volume, window=self._window).squeeze(-1)
def forward(self, close, volume):
vwap = self.VWAP(close, volume)
#pdb.set_trace()
return -1 * tsf.rolling_corr(vwap, volume, window=self._window).squeeze(-1)
def forward(self, close_ts, low_ts, volume_ts):
output_tensor = ((tsf.rank(
(close_ts - tsf.rolling_max(close_ts, 5))) * tsf.rank(
tsf.rolling_corr(
(tsf.rolling_mean_(volume_ts, 40)), low_ts, 5))) * -1)
return output_tensor
def forward(self, open_ts, volume_ts):
result = -1 * tsf.rolling_corr(open_ts, volume_ts, 10)
return result
def forward(self, high_ts, volume_ts):
output_tensor = tsf.rolling_corr(high_ts, tsf.rank(volume_ts), 5)
return -1 * output_tensor
def forward(self, volume_ts, close_ts):
output_tensor = (-1 * tsf.rolling_corr(torch.log(volume_ts), close_ts), self.window)
return output_tensor
def forward(self, high_ts, volume_ts):
output_tensor = (tsf.rank(
tsf.rolling_corr(tsf.rank(high_ts),
tsf.rank(tsf.rolling_mean_(volume_ts, 15)), 9)) *
-1)
return output_tensor
def forward(self, open_ts, volume_ts):
output_tensor = (-1 * tsf.rolling_corr(open_ts, volume_ts, 10))
return output_tensor
def forward(self, volume_ts, open_ts, return_ts):
output_tensor = ((-1 * tsf.rank(tsf.diff(return_ts, 3))) *
tsf.rolling_corr(open_ts, volume_ts, 10))
return output_tensor
def forward(self, volume_ts, close_ts, open_ts):
factor1 = tsf.rank(tsf.diff(torch.log(volume_ts), 1))
factor2 = tsf.rank((close_ts - open_ts) / open_ts)
output_tensor = tsf.rolling_corr(factor1, factor2, 6)
return output_tensor
def forward(self, open_ts, close_ts):
alpha = tsf.rank(
tsf.rolling_corr(tsf.shift(open_ts - close_ts, 1), close_ts,
200)) + tsf.rank(open_ts - close_ts)
return alpha
def forward(self, high_ts, volume_ts):
alpha = -1 * tsf.rank(tsf.rolling_std(high_ts, 10)) * tsf.rolling_corr(
high_ts, volume_ts, 10)
return alpha #
def forward(self, vwap_ts, volume_ts):
output_tensor = (tsf.rank(
tsf.rolling_corr(tsf.rank(vwap_ts), tsf.rank(volume_ts), 5)) * -1)
return output_tensor
def forward(self, volume_ts, high_ts):
output_tensor = -1 * tsf.rolling_max(
tsf.rolling_corr(tsf.ts_rank(volume_ts, 5), tsf.ts_rank(
high_ts, 5), 5), 3)
return output_tensor
def forward(self, volume, returns):
return tsf.rolling_corr(volume, returns, window=self._window).squeeze(-1)
def forward(self, high, low):
return tsf.rolling_corr(high, low, window=self._window).squeeze(-1)
def forward(self, high_ts, volume_ts, close_ts):
output_tensor = (
-1 * (tsf.diff(tsf.rolling_corr(high_ts, volume_ts, 5), 5) *
tsf.rank(tsf.rolling_std(close_ts, 20))))
return output_tensor
def forward(self, volume_ts, high_ts, rank_period):
output_tensor = -1 * tsf.rolling_max(
tsf.rolling_corr(tsf.ts_rank(volume_ts, rank_period), tsf.ts_rank(high_ts, rank_period), self.window),
self.window)
return output_tensor
def forward(self, high_ts, open_ts, close_ts):
output_tensor = (tsf.rank(
tsf.rolling_corr(tsf.shift(
(open_ts - close_ts), 1), close_ts, 200)) + tsf.rank(
(open_ts - close_ts)))
return output_tensor
