def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.window_long = config['window_long']
self.window_short = config['window_short']
self.short_flag = config["short_flag"]
if self.window_long <= self.window_short:
print("Error: window_long must be greater than window_short.")
exit(1)
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(data_loader,
timetable, config, self.window_long + 1, False)
if config.get('portion') is not None:
self.portion = config['portion']
else:
self.portion = 1. / self.n_inst
if config.get('variant') is not None:
self.variant = config['variant']
else:
self.variant = 0
if self.variant not in {0, 1}:
print("Wrong variant. Available variants: 0, 1.")
exit(1)
if config.get('sort_method') is not None:
self.sort_method = config['sort_method']
else:
self.sort_method = 0
if self.sort_method not in {0, 1, 2, 3}:
print("Wrong sort_method. Available variants: 0, 1, 2, 3")
exit(1)
if config.get('sort_threshold') is not None:
self.sort_threshold = config['sort_threshold']
else:
self.sort_threshold = 0
if config.get('min_hold_periods') is not None:
self.min_hold_periods = config['min_hold_periods']
else:
self.min_hold_periods = 0
if config.get('sort_desc_flag') is not None:
self.sort_desc_flag = config['sort_desc_flag']
else:
self.sort_desc_flag = False
self.long_hold_counter = 0
self.short_hold_counter = 0
self.long_positions = np.zeros(self.n_inst)
self.long_positions_flags = np.zeros(self.n_inst).astype(bool)
self.long_available_money = 1.
self.short_positions = np.zeros(self.n_inst)
self.short_positions_flags = np.zeros(self.n_inst).astype(bool)
self.short_available_money = 1.
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.instruments_list = config["instruments_list"]
self.epsilon = config["epsilon"]
use_risk_free = config["use_risk_free"]
self.n_inst = len(self.instruments_list)
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, config["window"] + 1, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config["instruments_list"]
self.n_inst = len(self.instruments_list)
self.use_risk_free = config["use_risk_free"]
if self.use_risk_free:
self.n_inst += 1
self.flag = config['flag']
self.temperature = config['temperature']
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, None, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
use_risk_free = config["use_risk_free"]
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.window = config['window']
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, 2 * self.window + 1, True)
self.anticor_expert = agent_utils.anticor_expert
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.exchange = config['exchange']
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, config["fit_window"] + 1, False)
self.instruments_list = config["instruments_list"]
self.n_steps = 0
self.n_inst = len(self.instruments_list)
self.fit_frequency = config["fit_frequency"]
self.fit_window = config["fit_window"]
self.rebalance_frequency = config["rebalance_frequency"]
self.allow_short = config["allow_short"]
self.use_risk_free = config["use_risk_free"]
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.instruments_list = config["instruments_list"]
self.verbose = False
if config.get("verbose") is not None:
if config["verbose"]:
self.verbose = True
self.window_long = config['window_long']
self.window_short = config['window_short']
assert self.window_long > self.window_short, \
"window_long must be greater than window_short"
self.down_trend_threshold = config["down_trend_threshold"]
self.n_inst = len(self.instruments_list)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, self.window_long + 1, False)
self.previous_trends = None
self.down_trend_counter = np.zeros(len(self.instruments_list))
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.instruments_list = config["instruments_list"]
self.eta = config['mixture']
self.beta = config['tradeoff']
self.delta = config['heuristic_tuning']
self.n_inst = len(self.instruments_list)
self.use_risk_free = config["use_risk_free"]
if self.use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.A = np.eye(self.n_inst)
self.b = np.zeros((self.n_inst, 1))
self.temperature = config['temperature']
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, 2, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config['instruments_list']
self.n_inst = len(config['instruments_list'])
use_risk_free = config["use_risk_free"]
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.alphas = config['alphas']
self.losses = np.zeros(len(self.alphas))
self.data_phi = np.zeros((len(self.alphas), self.n_inst))
self.epsilon = config['epsilon']
self.eta = config['eta']
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, 3, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config["instruments_list"]
self.epsilon = config["epsilon"]
self.window = config["window"]
use_risk_free = config["use_risk_free"]
self.n_inst = len(self.instruments_list)
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.data_phi = np.zeros(self.n_inst)
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, self.window + 2, False)
self.arima_class = agent_utils.Arima
self.init_arma_model()
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
self.window = config['window']
self.correlation_threshold = config['correlation_threshold']
self.history_start_date = config.get("history_start_date")
self.init_history_length = config.get("init_history_length")
self.use_risk_free = config["use_risk_free"]
if self.use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.optimize_weights = agent_utils.optimize_weights
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, None, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
self.use_risk_free = config["use_risk_free"]
if self.use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.epsilon = config['epsilon']
self.phi = config['confidence']
self.lmbd = 0
# mu: last portfolio mean
self.mu = np.ones(self.n_inst) / self.n_inst
# sigma: last diagonal covariance matrix
self.sigma = np.eye(self.n_inst) / (self.n_inst**2)
self.simplex_projection = agent_utils.simplex_projection
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, 2, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
use_risk_free = config["use_risk_free"]
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.sequence_length = config["sequence_length"]
self.nearest_neighbors_number = config['nearest_neighbors']
self.exp_ret = np.ones(
(self.sequence_length, self.nearest_neighbors_number + 1))
self.exp_w = np.ones(
(self.sequence_length *
(self.nearest_neighbors_number + 1), self.n_inst)) / self.n_inst
self.optimize_weights = agent_utils.optimize_weights
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, None, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_step = 0
self.instruments_list = config["instruments_list"]
self.window = config["window"]
self.max_iter = int(config["max_iter"])
self.abstol = config["abstol"]
self.zeta = config["zeta"]
self.lmbd = config["lmbd"]
self.gamma = config["gamma"]
self.eta = config["eta"]
self.tao = self.lmbd / self.gamma
use_risk_free = config["use_risk_free"]
self.n_inst = len(self.instruments_list)
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(data_loader,
timetable, config, config["window"] + 1, False)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
self.window = config['window']
self.std_coef_open = config['std_coef_open']
self.std_coef_close = config['std_coef_close']
self.allow_short = config['allow_short']
if config.get('portion') is not None:
self.portion = config['portion']
else:
self.portion = 1. / self.n_inst
self.long_positions = np.zeros(self.n_inst)
self.long_positions_flags = np.zeros(self.n_inst).astype(bool)
self.short_positions = np.zeros(self.n_inst)
self.short_positions_flags = np.zeros(self.n_inst).astype(bool)
self.available_money = 1.
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, self.window + 1, False)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.n_steps = 0
self.instruments_list = config['instruments_list']
self.n_inst = len(self.instruments_list)
use_risk_free = config["use_risk_free"]
if use_risk_free:
self.n_inst += 1
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
self.arima_class = agent_utils.Arima
self.simplex_projection = agent_utils.simplex_projection
self.compute_L1_median = agent_utils.compute_L1_median
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.weights_projection = agent_utils.WeightsProjection(config)
self.epsilon = config['epsilon']
self.window = config['window']
self.arma = self.init_arima_model(config["config_arma"])
self.arima = self.init_arima_model(config["config_arima"])
self.predicted_prices = 0
self.estim_num = config["estim_num"]
self.estimators_weights = np.ones(self.estim_num) / self.estim_num
self.learning_rate = config["learning_rate"]
self.ons_epsilon = config["ons_eps"]
self.A = np.eye(self.estim_num) * self.ons_epsilon
self.max_window = max(
[self.window, self.arma.window + 1, self.arima.window + 2])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, self.max_window + 1, False)
if config.get("save_flag") is not None:
self.save_flag = config["save_flag"]
else:
self.save_flag = False
if self.save_flag:
self.history_losses = []
self.history_weighted_losses = []
self.history_estimators_weights = []
self.history_next_price_relatives = []
self.history_predicted_prices = []
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.simplex_projection = agent_utils.simplex_projection
self.instruments_list = config["instruments_list"]
self.instruments_number = len(self.instruments_list)
self.price_label = config["price_label"]
self.step = config['step']
self.exchange = config['exchange']
self.use_risk_free = config["use_risk_free"]
if self.use_risk_free:
self.instruments_number += 1
self.last_portfolio = np.ones(
self.instruments_number) / self.instruments_number,
self.eps = config['mean_reversion_threshold']
self.C = config['aggressive_param']
self.variant = config['variant']
self.eta = np.inf
self.daily_ret = 1.
self.n_steps = 0
self.weights_projection = agent_utils.WeightsProjection(config)
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, 2, True)
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.exchange = config['exchange']
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(data_loader,
timetable, config, 2 * config['window'] + 1, True)
self.instruments_list = config["instruments_list"]
self.n_steps = 0
self.exchange = config['exchange']
self.n_inst = len(self.instruments_list)
self.learning_rate = config['learning_rate']
# ons parameters
self.eta = config['mixture']
self.beta = config['tradeoff']
self.delta = config['heuristic_tuning']
self.A = np.eye(self.n_inst)
self.b = np.zeros((self.n_inst, 1))
# anticor parameters
self.window = config['window']
self.double_window = 2 * self.window + 1
# meta parameters
self.update_method = config["update_method"]
if self.update_method not in {"eg", "ons"}:
print("Update method is not available.")
print("Available methods: eg, ons.")
exit(1)
self.meta_update_parameter = config["meta_update_parameter"]
self.meta_num = 3
self.meta_weights = np.ones(self.meta_num) / self.meta_num
self.predictions = None
if config.get("meta_epsilon") is not None:
self.meta_epsilon = config["meta_epsilon"]
else:
self.meta_epsilon = 0
self.A_meta = np.eye(self.meta_num) * self.meta_epsilon
self.last_portfolio = np.ones(self.n_inst) / self.n_inst
def __init__(self, config, data_loader, trade_log=None):
super().__init__(config, data_loader)
self.window = config["window"]
timetable = agent_utils.ExchangeTimetable(config["exchange"])
self.data_extractor = agent_utils.DataExtractor(
data_loader, timetable, config, self.window, True)
