搜索了720组参数后：创业板动量收益率提升至26.48%，回撤率下降至43%

最近的思路，从“七年实现财富自由”（七年赚到500万实现财富自由，这是我的计划，也适合大多数普通人）演化到“以交易为生”。

大类资产配置计划，恒定市场定投，这个基本上不需要花太多时间，算是一个“被动收入”管道，静待花开即可。

因此，星球引入下一个目标：我想测试一下，拿10%的本金，测试一下是否能够以交易为生。

这里有一个悖论就是：最合适以交易为生的人，是那些不需要以交易为生的人。

仔细读这句话，不是绕口令。

世间事，很多都是如此。

你对它没有执念了，反倒更容易成功。

这就好比财富自由的人，创业更容易成功。因为不受当下波动所扰，可以目光长远，格局就大。不着急赚钱，就能坚持长期主义正确的事情。

如果你把交易看成是一个游戏，只想看看如何晋级和通关，修炼自己的认知和技术，不断精进。

从我自己的背景出发，即便是交易为生，也是从构建自动化（智能化）系统开始的。能交给系统的，都交给系统，系统开发对我而言是很简单的事情。

超参数优化对于CTA策略非常重要：

from backtesting import Strategy
from utils.indicators import ROC


class RocPickTime(Strategy):
    n = 20
    upper_bound = 0.02
    lower_bound = 0

    def init(self):
        #print(self.data.Close)
        self.roc = self.I(ROC, self.data.Close, self.n)

    def next(self):
        if self.roc[-1] > self.upper_bound:
            if self.position.size < 0:
                self.position.close()
            self.buy()

        if self.roc[-1] < self.lower_bound:
            if self.position.size > 0:
                self.position.close()

self.sell()

咱们这个策略，有三个参数，一是动量的周期，二是做多和空的两个值：

   n = 20
    upper_bound = 0.08
    lower_bound = 0

优化之后，收益率提升至26.48%，回撤率下降至43%。

最优参数是：n=20，upper_bound=0.02, lower_bound=0.0。

也就是20日动量（之前很多同学问我，为什么设为20，因为机器优化的），动量值超过0.02时做多，低于0时做空（或者平仓）。

代码在如下位置，notebook里AI量化实验室——2024量化投资的星辰大海：

国际知名交易者——埃尔德，有一个交易系统叫“三重滤网”。

它引用了不同的时间周期，比如周线上看大势，日线上看反转，小时线上看入场点。这就需要支持多时间窗口的指标计算。

1、把日线数据resample为周线，在周线上计算指标后，然后把index还原成日线的频率，用ffill前向填充的方式对齐。

2、这里有一个问题，只能小周期往大周期resample，日线数据肯定无法拆分小时线。如果要使用三重滤网小时操作的话，回测数据应该使用小时线的数据即可以，然后resample为日线和周线。

def resample_apply(rule: str,
                   func: Optional[Callable[..., Sequence]],
                   series: Union[pd.Series, pd.DataFrame, _Array],
                   *args,
                   agg: Optional[Union[str, dict]] = None,
                   **kwargs):
    """
    
    if func is None:
        def func(x, *_, **__):
            return x

    if not isinstance(series, (pd.Series, pd.DataFrame)):
        assert isinstance(series, _Array), \
            'resample_apply() takes either a `pd.Series`, `pd.DataFrame`, ' \
            'or a `Strategy.data.*` array'
        series = series.s

    if agg is None:
        agg = OHLCV_AGG.get(getattr(series, 'name', ''), 'last')
        if isinstance(series, pd.DataFrame):
            agg = {column: OHLCV_AGG.get(column, 'last')
                   for column in series.columns}

    resampled = series.resample(rule, label='right').agg(agg).dropna()
    resampled.name = _as_str(series) + '[' + rule + ']'

    # Check first few stack frames if we are being called from
    # inside Strategy.init, and if so, extract Strategy.I wrapper.
    frame, level = currentframe(), 0
    while frame and level <= 3:
        frame = frame.f_back
        level += 1
        if isinstance(frame.f_locals.get('self'), Strategy):  # type: ignore
            strategy_I = frame.f_locals['self'].I             # type: ignore
            break
    else:
        def strategy_I(func, *args, **kwargs):
            return func(*args, **kwargs)

    def wrap_func(resampled, *args, **kwargs):
        result = func(resampled, *args, **kwargs)
        if not isinstance(result, pd.DataFrame) and not isinstance(result, pd.Series):
            result = np.asarray(result)
            if result.ndim == 1:
                result = pd.Series(result, name=resampled.name)
            elif result.ndim == 2:
                result = pd.DataFrame(result.T)
        # Resample back to data index
        if not isinstance(result.index, pd.DatetimeIndex):
            result.index = resampled.index
        result = result.reindex(index=series.index.union(resampled.index),
                                method='ffill').reindex(series.index)
        return result

    wrap_func.__name__ = func.__name__

    array = strategy_I(wrap_func, resampled, *args, **kwargs)
    return array