qlibtrade时间

发布网友发布时间：2023-04-04 06:29

共5个回答

热心网友时间：2024-12-15 08:10

qlibtrade是一个开源的量化交易平台，它没有固定的交易时间。交易时间取决于所连接的交易所的交易时间。不同的交易所有不同的交易时间，例如，中国股市的交易时间是周一到周五的上午9:30到下午3:00。如果你使用qlibtrade连接的是中国股市，那么交易时间就是按照中国股市的交易时间来进行的。

热心网友时间：2024-12-15 08:11

qlibtrade是QuantLib的Python实现，是一种用于金融工程和量化投资的开源工具包。在使用qlibtrade进行量化投资时，需要注意时间的处理。

qlibtrade中的时间处理主要涉及以下几个方面：

1. 时间戳：qlibtrade中使用Unix时间戳来表示时间，即从1970年1月1日0时0分0秒到某一时间点的秒数。

2. 时间周期：qlibtrade中常用的时间周期包括天、分钟、秒等，可以根据需要选择合适的时间周期进行数据处理。

3. 交易日历：qlibtrade中的交易日历用于处理股票、期货等金融产品在交易日和非交易日的价格变化，可以根据实际情况进行设置。

需要注意的是，qlibtrade中的时间处理与具体的数据源和交易策略有关，不同的数据源和策略可能需要不同的时间处理方式。因此，在使用qlibtrade进行量化投资时，建议您仔细阅读相关文档和代码，了解其时间处理方式，以避免因时间处理错误而造成的投资风险和经济损失。

热心网友时间：2024-12-15 08:11

qlibtrade 是一个基于 Qlib 的量化交易框架，提供了一系列常用的交易策略和工具，适用于股票、期货、外汇等市场。

在 qlibtrade 中，时间是一个非常重要的概念，它通常与数据的处理和交易的决策密切相关。qlibtrade 中时间通常有两种表示方式：

1. 时间戳（timestamp）：时间戳是一种表示时间的数据类型，通常是一个整数或浮点数。在 qlibtrade 中，时间戳通常表示某个具体的时间点，例如 2022 年 1 月 1 日 00:00:00 的时间戳为 1640995200。

2. K 线数据（k-line data）：K 线数据通常是指一段时间内的 OHLC（开盘价、最高价、最低价、收盘价）数据，也可以包括成交量、持仓量等信息。在 qlibtrade 中，K 线数据通常是按照一定的时间间隔（例如 1 分钟、5 分钟、日线等）组织的，每个 K 线数据包括该时间段内的 OHLC 数据和其他相关信息。

在使用 qlibtrade 进行量化交易时，通常需要根据市场数据生成 K 线数据，并根据 K 线数据进行交易决策。同时，需要注意时区、交易所的开市时间、休市时间等因素，以确保交易策略的正确性和可靠性。

热心网友时间：2024-12-15 08:12

你好，Qlib的代码是以一个比较“松散”的结构，每一个模块都尽量做到可以最大程度的复用。这一点很好支撑我们的量化系统。即能够最大复用它的工程能力，又可以自主发展我们想要的功能。

今天看一下Qlib的投资组合策略。

传统的量化回测策略不同在于，Qlib的策略输出是由模型输出预测好的分数，由这个分数来构建投资组合。

策略的基类是qlib.strategy.base.BaseStrategy

class BaseStrategy:
"""Base strategy for trading"""
def __init__(
self,
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
trade_exchange: Exchange = None,
):
BaseStrategy是一个抽象类，就是定义了一些基础参数。

它的一个子类是ModelStrategy，顾名思义，基于模型的预测来交易的类。

它传入两个参数，一个是模型，一个是数据集。

class ModelStrategy(BaseStrategy):
"""Model-based trading strategy, use model to make predictions for trading"""
def __init__(
self,
model: BaseModel,
dataset: DatasetH,
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
**kwargs,
):
"""
Parameters
----------
model : BaseModel
the model used in when making predictions
dataset : DatasetH
provide test data for model
kwargs : dict
arguments that will be passed into `reset` method
"""
super(ModelStrategy, self).__init__(outer_trade_decision, level_infra, common_infra, **kwargs)
self.model = model
self.dataset = dataset
self.pred_scores = convert_index_format(self.model.predict(dataset), level="datetime")
if isinstance(self.pred_scores, pd.DataFrame):
self.pred_scores = self.pred_scores.iloc[:, 0]
使用model.predict(dataset)生成预测分数pred_scores。

源码中可以看出，qlib实现了两个关于强化学习的策略类，但它们都还没有具体的实现类。

传入重要参数是policy。

class RLStrategy(BaseStrategy):
"""RL-based strategy"""
def __init__(
self,
policy,
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
**kwargs,
):
"""
Parameters
----------
policy :
RL policy for generate action
"""
super(RLStrategy, self).__init__(outer_trade_decision, level_infra, common_infra, **kwargs)
self.policy = policy
还有一个子类，带state和action的翻译器的类。

class RLIntStrategy(RLStrategy):
"""(RL)-based (Strategy) with (Int)erpreter"""
def __init__(
self,
policy,
state_interpreter: Union[dict, StateInterpreter],
action_interpreter: Union[dict, ActionInterpreter],
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
**kwargs,
):
"""
Parameters
----------
state_interpreter : Union[dict, StateInterpreter]
interpretor that interprets the qlib execute result into rl env state
action_interpreter : Union[dict, ActionInterpreter]
interpretor that interprets the rl agent action into qlib order list
start_time : Union[str, pd.Timestamp], optional
start time of trading, by default None
end_time : Union[str, pd.Timestamp], optional
end time of trading, by default None
"""
super(RLIntStrategy, self).__init__(policy, outer_trade_decision, level_infra, common_infra, **kwargs)

self.policy = policy
self.state_interpreter = init_instance_by_config(state_interpreter, accept_types=StateInterpreter)
self.action_interpreter = init_instance_by_config(action_interpreter, accept_types=ActionInterpreter)
当前qlib仅有一个真正的策略实现类：TopKDropoutStrategy，继承自ModelStrategy。

class TopkDropoutStrategy(ModelStrategy):
# TODO:
# 1. Supporting leverage the get_range_limit result from the decision
# 2. Supporting alter_outer_trade_decision
# 3. Supporting checking the availability of trade decision
def __init__(
self,
model,
dataset,
topk,
n_drop,
method_sell="bottom",
method_buy="top",
risk_degree=0.95,
hold_thresh=1,
only_tradable=False,
trade_exchange=None,
level_infra=None,
common_infra=None,
**kwargs,
):
它的核心逻辑如下：

TopK=5，表示持有分数最高的前5支股票；Drop=3，TopK好理解，就是得分最高的前N个，但DropN这个有点奇怪，代码里解释是要提高换手率，这有点不符合交易逻辑，可以把这个设置成零。

图片

它的核心函数是generate_trade_decision，类似传统回测系统里的on_bar。

传统回测系统里的on_bar会自己调api执行这些订单，而qlib只是返回这些order_list，这样倒也简洁。

def generate_trade_decision(self, execute_result=None):
# get the number of trading step finished, trade_step can be [0, 1, 2, ..., trade_len - 1]
其实，这里的逻辑，就是“轮动”策略，传统量化里的动量轮动，我们就是取动量最大的前N名持有。区别在于，根据当前的bar的指标，规则选择，但多支股票轮动最终一定会有一个排序，就是类似这个topK的逻辑。而规则就是模型给出的pred_score。

最后backtest_loop，调用strategy每一步产生交易订单，交给执行器去执行。

with tqdm(total=trade_executor.trade_calendar.get_trade_len(), desc="backtest loop") as bar:
_execute_result = None
while not trade_executor.finished():
_trade_decision: BaseTradeDecision = trade_strategy.generate_trade_decision(_execute_result)
_execute_result = yield from trade_executor.collect_data(_trade_decision, level=0)
bar.update(1)
客观讲，qlib这一块写得不好，也是我打算使用自己的回测引擎的原因。我仔细读过像Backtrader，PyalgoTrade的源码，不知为何qlib重新造了一个逻辑不太一样的轮子。

热心网友时间：2024-12-15 08:12

Qlib的代码是以一个比较“松散”的结构，每一个模块都尽量做到可以最大程度的复用。这一点很好支撑我们的量化系统。即能够最大复用它的工程能力，又可以自主发展我们想要的功能。

今天看一下Qlib的投资组合策略。

传统的量化回测策略不同在于，Qlib的策略输出是由模型输出预测好的分数，由这个分数来构建投资组合。

策略的基类是qlib.strategy.base.BaseStrategy

class BaseStrategy:
"""Base strategy for trading"""
def __init__(
self,
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
trade_exchange: Exchange = None,
):
BaseStrategy是一个抽象类，就是定义了一些基础参数。

它的一个子类是ModelStrategy，顾名思义，基于模型的预测来交易的类。

它传入两个参数，一个是模型，一个是数据集。

class ModelStrategy(BaseStrategy):
"""Model-based trading strategy, use model to make predictions for trading"""
def __init__(
self,
model: BaseModel,
dataset: DatasetH,
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
**kwargs,
):
"""
Parameters
----------
model : BaseModel
the model used in when making predictions
dataset : DatasetH
provide test data for model
kwargs : dict
arguments that will be passed into `reset` method
"""
super(ModelStrategy, self).__init__(outer_trade_decision, level_infra, common_infra, **kwargs)
self.model = model
self.dataset = dataset
self.pred_scores = convert_index_format(self.model.predict(dataset), level="datetime")
if isinstance(self.pred_scores, pd.DataFrame):
self.pred_scores = self.pred_scores.iloc[:, 0]
使用model.predict(dataset)生成预测分数pred_scores。

源码中可以看出，qlib实现了两个关于强化学习的策略类，但它们都还没有具体的实现类。

传入重要参数是policy。

class RLStrategy(BaseStrategy):
"""RL-based strategy"""
def __init__(
self,
policy,
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
**kwargs,
):
"""
Parameters
----------
policy :
RL policy for generate action
"""
super(RLStrategy, self).__init__(outer_trade_decision, level_infra, common_infra, **kwargs)
self.policy = policy
还有一个子类，带state和action的翻译器的类。

class RLIntStrategy(RLStrategy):
"""(RL)-based (Strategy) with (Int)erpreter"""
def __init__(
self,
policy,
state_interpreter: Union[dict, StateInterpreter],
action_interpreter: Union[dict, ActionInterpreter],
outer_trade_decision: BaseTradeDecision = None,
level_infra: LevelInfrastructure = None,
common_infra: CommonInfrastructure = None,
**kwargs,
):
"""
Parameters
----------
state_interpreter : Union[dict, StateInterpreter]
interpretor that interprets the qlib execute result into rl env state
action_interpreter : Union[dict, ActionInterpreter]
interpretor that interprets the rl agent action into qlib order list
start_time : Union[str, pd.Timestamp], optional
start time of trading, by default None
end_time : Union[str, pd.Timestamp], optional
end time of trading, by default None
"""
super(RLIntStrategy, self).__init__(policy, outer_trade_decision, level_infra, common_infra, **kwargs)

self.policy = policy
self.state_interpreter = init_instance_by_config(state_interpreter, accept_types=StateInterpreter)
self.action_interpreter = init_instance_by_config(action_interpreter, accept_types=ActionInterpreter)
当前qlib仅有一个真正的策略实现类：TopKDropoutStrategy，继承自ModelStrategy。

class TopkDropoutStrategy(ModelStrategy):
# TODO:
# 1. Supporting leverage the get_range_limit result from the decision
# 2. Supporting alter_outer_trade_decision
# 3. Supporting checking the availability of trade decision
def __init__(
self,
model,
dataset,
topk,
n_drop,
method_sell="bottom",
method_buy="top",
risk_degree=0.95,
hold_thresh=1,
only_tradable=False,
trade_exchange=None,
level_infra=None,
common_infra=None,
**kwargs,
):
它的核心逻辑如下：

TopK=5，表示持有分数最高的前5支股票；Drop=3，TopK好理解，就是得分最高的前N个，但DropN这个有点奇怪，代码里解释是要提高换手率，这有点不符合交易逻辑，可以把这个设置成零。

图片

它的核心函数是generate_trade_decision，类似传统回测系统里的on_bar。

传统回测系统里的on_bar会自己调api执行这些订单，而qlib只是返回这些order_list，这样倒也简洁。

def generate_trade_decision(self, execute_result=None):
# get the number of trading step finished, trade_step can be [0, 1, 2, ..., trade_len - 1]
其实，这里的逻辑，就是“轮动”策略，传统量化里的动量轮动，我们就是取动量最大的前N名持有。区别在于，根据当前的bar的指标，规则选择，但多支股票轮动最终一定会有一个排序，就是类似这个topK的逻辑。而规则就是模型给出的pred_score。

最后backtest_loop，调用strategy每一步产生交易订单，交给执行器去执行。

with tqdm(total=trade_executor.trade_calendar.get_trade_len(), desc="backtest loop") as bar:
_execute_result = None
while not trade_executor.finished():
_trade_decision: BaseTradeDecision = trade_strategy.generate_trade_decision(_execute_result)
_execute_result = yield from trade_executor.collect_data(_trade_decision, level=0)
bar.update(1)
客观讲，qlib这一块写得不好，也是我打算使用自己的回测引擎的原因。我仔细读过像Backtrader，PyalgoTrade的源码，不知为何qlib重新造了一个逻辑不太一样的轮子