1{
2  "op": "replace",
3  "filename": "qlib/custom_model.py",
4  "content": "class CustomModel(Model):\n    \"\"\"RICE: Recency-weighted IC optimization with contrastive extremes.\n\n    Linear scorer over Alpha360 features, but trained for the actual downstream\n    objective: cross-sectional ranking. The algorithm combines:\n    1) daily IC maximization,\n    2) tail pairwise ranking between top/bottom label buckets,\n    3) recency weighting for regime adaptation,\n    4) feature normalization across both time-within-stock and date cross-section.\n    \"\"\"\n\n    def __init__(self):\n        super().__init__()\n        self.device = torch.device(DEVICE)\n        self.epochs, self.batch_days, self.lr = 10, 32, 0.03\n        self.tail_k, self.tail_w, self.reg = 12, 0.25, 1e-4\n        self.coef_, self.bias_, self.fitted = None, 0.0, False\n\n    def _transform(self, feat: pd.DataFrame):\n        x = np.nan_to_num(\n            feat.values.astype(\"float32\"), nan=0.0, posinf=0.0, neginf=0.0\n        )\n        x = x.reshape(len(x), 6, 60)\n        mu = x.mean(axis=2, keepdims=True)\n        sd = x.std(axis=2, keepdims=True) + 1e-5\n        x = (0.65 * x + 0.35 * (x - mu) / sd).reshape(len(x), -1)\n        dates = feat.index.get_level_values(0).values\n        starts = np.r_[0, np.flatnonzero(dates[1:] != dates[:-1]) + 1]\n        counts = np.diff(np.r_[starts, len(dates)])\n        groups = list(zip(starts.tolist(), counts.tolist()))\n        for st, ct in groups:\n            sl = slice(st, st + ct)\n            xm = x[sl].mean(axis=0, keepdims=True)\n            xs = x[sl].std(axis=0, keepdims=True) + 1e-4\n            x[sl] = (x[sl] - xm) / xs\n        return x, feat.index, groups\n\n    def _day_loss(self, score, label):\n        s = score - score.mean()\n        y = label - label.mean()\n        corr = (s * y).mean() / (\n            torch.sqrt((s.square()).mean() + 1e-6)\n            * torch.sqrt((y.square()).mean() + 1e-6)\n        )\n        sz = s / torch.sqrt((s.square()).mean() + 1e-6)\n        yz = y / torch.sqrt((y.square()).mean() + 1e-6)\n        point = (F.smooth_l1_loss(sz, yz, reduction=\"none\") * (1.0 + y.abs())).mean()\n        if len(label) >= 6:\n            k = max(3, min(self.tail_k, len(label) // 8))\n            idx = torch.argsort(label)\n            gap = score[idx[-k:]].unsqueeze(1) - score[idx[:k]].unsqueeze(0)\n            rank = F.softplus(-gap).mean()\n        else:\n            rank = 0.0 * point\n        return -corr + 0.2 * point + self.tail_w * rank\n\n    def _eval_ic(self, x, y, groups, coef, bias):\n        pred = x @ coef + bias\n        vals = []\n        for st, ct in groups:\n            p = pred[st : st + ct]\n            t = y[st : st + ct]\n            p = p - p.mean()\n            t = t - t.mean()\n            vals.append((p * t).mean() / (np.sqrt((p * p).mean() * (t * t).mean()) + 1e-8))\n        return float(np.mean(vals))\n\n    def fit(self, dataset: DatasetH):\n        np.random.seed(0)\n        torch.manual_seed(0)\n        df_train, df_valid = dataset.prepare(\n            [\"train\", \"valid\"], col_set=[\"feature\", \"label\"], data_key=DataHandlerLP.DK_L\n        )\n        x_tr, _, g_tr = self._transform(df_train[\"feature\"])\n        y_tr = df_train[\"label\"].values.reshape(-1).astype(\"float32\")\n        x_va, _, g_va = self._transform(df_valid[\"feature\"])\n        y_va = df_valid[\"label\"].values.reshape(-1).astype(\"float32\")\n\n        w0 = (x_tr * y_tr[:, None]).mean(axis=0)\n        w = nn.Parameter(torch.tensor(w0, dtype=torch.float32, device=self.device))\n        b = nn.Parameter(torch.zeros(1, dtype=torch.float32, device=self.device))\n        opt = torch.optim.Adam([w, b], lr=self.lr)\n        day_w = np.exp(np.linspace(-1.0, 0.0, len(g_tr))).astype(\"float32\")\n        best_ic, best = -1e9, None\n        patience = 0\n\n        for _ in range(self.epochs):\n            order = np.random.permutation(len(g_tr))\n            for i in range(0, len(order), self.batch_days):\n                opt.zero_grad()\n                loss = torch.zeros((), device=self.device)\n                norm = torch.zeros((), device=self.device)\n                for d in order[i : i + self.batch_days]:\n                    st, ct = g_tr[d]\n                    xb = torch.tensor(x_tr[st : st + ct], device=self.device)\n                    yb = torch.tensor(y_tr[st : st + ct], device=self.device)\n                    loss = loss + day_w[d] * self._day_loss(xb @ w + b, yb)\n                    norm = norm + day_w[d]\n                (loss / norm + self.reg * w.square().mean()).backward()\n                opt.step()\n            coef = w.detach().cpu().numpy()\n            vic = self._eval_ic(x_va, y_va, g_va, coef, float(b.item()))\n            if vic > best_ic:\n                best_ic, best, patience = vic, (coef.copy(), float(b.item())), 0\n            else:\n                patience += 1\n                if patience >= 3:\n                    break\n\n        self.coef_, self.bias_ = best\n        self.fitted = True\n\n    def predict(self, dataset: DatasetH, segment=\"test\"):\n        if not self.fitted:\n            raise ValueError(\"Model is not fitted yet!\")\n        feat = dataset.prepare(segment, col_set=\"feature\", data_key=DataHandlerLP.DK_I)\n        x, index, groups = self._transform(feat)\n        pred = x @ self.coef_ + self.bias_\n        for st, ct in groups:\n            sl = slice(st, st + ct)\n            p = pred[sl]\n            pred[sl] = (p - p.mean()) / (p.std() + 1e-6)\n        return pd.Series(pred, index=index, name=\"score\")",
5  "after_line": 18,
6  "start_line": 19,
7  "end_line": 103
8}

1{
2  "op": "replace",
3  "filename": "qlib/workflow_config.yaml",
4  "content": "          infer_processors: []",
5  "after_line": 30,
6  "start_line": 31,
7  "end_line": 38
8}

1{
2  "op": "replace",
3  "filename": "qlib/custom_model.py",
4  "content": "class CustomModel(Model):\n    \"\"\"DARTS-GBM: Dual-Objective Adaptive Rank-Temporal Smoothing.\n\n    Novel contribution:\n    - pointwise regression tree for return magnitude\n    - per-date LambdaRank tree on discretized cross-sectional relevance\n    - recency-decayed sample weighting for regime adaptation\n    - validation-selected blending of the two objectives\n    - causal per-instrument EMA smoothing to reduce turnover noise\n    \"\"\"\n\n    def __init__(self):\n        super().__init__()\n        self.num_boost_round = 500\n        self.early_stopping_rounds = 50\n        self.rank_weight = 0.5\n        self.ema_alpha = 1.0\n        base = {\n            \"colsample_bytree\": 0.8879,\n            \"learning_rate\": 0.0421,\n            \"subsample\": 0.8789,\n            \"lambda_l1\": 205.6999,\n            \"lambda_l2\": 580.9768,\n            \"max_depth\": 8,\n            \"num_leaves\": 210,\n            \"num_threads\": 20,\n            \"verbosity\": -1,\n            \"force_col_wise\": True,\n        }\n        self.reg_params = {**base, \"objective\": \"mse\", \"metric\": \"l2\"}\n        self.rank_params = {\n            **base,\n            \"objective\": \"lambdarank\",\n            \"metric\": \"ndcg\",\n            \"eval_at\": [10, 20, 50],\n            \"label_gain\": list(range(16)),\n        }\n        self.reg_model = None\n        self.rank_model = None\n\n    def _groups(self, index):\n        dates = index.get_level_values(0).values\n        starts = np.r_[0, np.flatnonzero(dates[1:] != dates[:-1]) + 1]\n        counts = np.diff(np.r_[starts, len(index)])\n        return list(zip(starts.tolist(), counts.tolist()))\n\n    def _prepare(self, df):\n        feat = df[\"feature\"]\n        label = df[\"label\"]\n        y = label.values.reshape(-1).astype(\"float32\")\n        mask = np.isfinite(y)\n        x = feat.values[mask].astype(\"float32\")\n        y = y[mask]\n        index = feat.index[mask]\n        return x, y, index, self._groups(index)\n\n    def _date_weights(self, groups):\n        day_w = np.exp(np.linspace(np.log(0.35), 0.0, len(groups))).astype(\"float32\")\n        return np.repeat(day_w, [ct for _, ct in groups])\n\n    def _rank_labels(self, y, groups):\n        rel = np.zeros(len(y), dtype=np.int32)\n        bins = np.array([0.08, 0.2, 0.35, 0.5, 0.65, 0.8, 0.92])\n        for st, ct in groups:\n            order = np.argsort(y[st : st + ct], kind=\"mergesort\")\n            q = np.empty(ct, dtype=\"float32\")\n            q[order] = (np.arange(ct, dtype=\"float32\") + 0.5) / ct\n            rel[st : st + ct] = np.digitize(q, bins)\n        return rel\n\n    def _cs_zscore(self, pred, groups):\n        out = pred.astype(\"float32\", copy=True)\n        for st, ct in groups:\n            p = out[st : st + ct]\n            out[st : st + ct] = (p - p.mean()) / (p.std() + 1e-6)\n        return out\n\n    def _metric(self, pred, y, groups):\n        ic_l, ric_l, spread_l = [], [], []\n        for st, ct in groups:\n            p = pred[st : st + ct]\n            t = y[st : st + ct]\n            p0 = p - p.mean()\n            t0 = t - t.mean()\n            ic_l.append((p0 * t0).mean() / (np.sqrt((p0 * p0).mean() * (t0 * t0).mean()) + 1e-8))\n            rp = np.argsort(np.argsort(p, kind=\"mergesort\"), kind=\"mergesort\").astype(\"float32\")\n            rt = np.argsort(np.argsort(t, kind=\"mergesort\"), kind=\"mergesort\").astype(\"float32\")\n            rp -= rp.mean()\n            rt -= rt.mean()\n            ric_l.append((rp * rt).mean() / (np.sqrt((rp * rp).mean() * (rt * rt).mean()) + 1e-8))\n            k = max(5, min(50, ct // 6))\n            order = np.argsort(p)\n            spread_l.append(float(t[order[-k:]].mean() - t[order[:k]].mean()))\n        return float(np.mean(ic_l) + np.mean(ric_l) + 0.05 * np.mean(spread_l))\n\n    def _ema(self, index, pred, alpha):\n        if alpha >= 0.999:\n            return pred\n        s = pd.Series(pred, index=index, dtype=\"float32\")\n        s = s.groupby(level=1, sort=False, group_keys=False).apply(\n            lambda z: z.sort_index(level=0).ewm(alpha=alpha, adjust=False).mean()\n        )\n        return s.reindex(index).values.astype(\"float32\")\n\n    def fit(self, dataset: DatasetH):\n        import lightgbm as lgb\n\n        df_train, df_valid = dataset.prepare(\n            [\"train\", \"valid\"], col_set=[\"feature\", \"label\"], data_key=DataHandlerLP.DK_L\n        )\n        x_tr, y_tr, _, g_tr = self._prepare(df_train)\n        x_va, y_va, idx_va, g_va = self._prepare(df_valid)\n        w_tr = self._date_weights(g_tr)\n        w_va = self._date_weights(g_va)\n\n        dtr_reg = lgb.Dataset(x_tr, label=y_tr, weight=w_tr, free_raw_data=False)\n        dva_reg = lgb.Dataset(x_va, label=y_va, weight=w_va, reference=dtr_reg, free_raw_data=False)\n        self.reg_model = lgb.train(\n            self.reg_params,\n            dtr_reg,\n            num_boost_round=self.num_boost_round,\n            valid_sets=[dva_reg],\n            callbacks=[lgb.early_stopping(self.early_stopping_rounds, verbose=False)],\n        )\n\n        yr_tr = self._rank_labels(y_tr, g_tr)\n        yr_va = self._rank_labels(y_va, g_va)\n        dtr_rank = lgb.Dataset(\n            x_tr, label=yr_tr, group=[ct for _, ct in g_tr], weight=w_tr, free_raw_data=False\n        )\n        dva_rank = lgb.Dataset(\n            x_va,\n            label=yr_va,\n            group=[ct for _, ct in g_va],\n            weight=w_va,\n            reference=dtr_rank,\n            free_raw_data=False,\n        )\n        self.rank_model = lgb.train(\n            self.rank_params,\n            dtr_rank,\n            num_boost_round=self.num_boost_round,\n            valid_sets=[dva_rank],\n            callbacks=[lgb.early_stopping(self.early_stopping_rounds, verbose=False)],\n        )\n\n        p_reg = self._cs_zscore(\n            self.reg_model.predict(x_va, num_iteration=self.reg_model.best_iteration), g_va\n        )\n        p_rank = self._cs_zscore(\n            self.rank_model.predict(x_va, num_iteration=self.rank_model.best_iteration), g_va\n        )\n        best_score = -1e18\n        for rw in np.linspace(0.0, 1.0, 11):\n            base = self._cs_zscore((1.0 - rw) * p_reg + rw * p_rank, g_va)\n            for alpha in [1.0, 0.9, 0.8, 0.7]:\n                pred = self._cs_zscore(self._ema(idx_va, base, alpha), g_va)\n                score = self._metric(pred, y_va, g_va)\n                if score > best_score:\n                    best_score = score\n                    self.rank_weight = float(rw)\n                    self.ema_alpha = float(alpha)\n\n    def predict(self, dataset: DatasetH, segment=\"test\"):\n        if self.reg_model is None or self.rank_model is None:\n            raise ValueError(\"model is not fitted yet!\")\n        feat = dataset.prepare(segment, col_set=\"feature\", data_key=DataHandlerLP.DK_I)\n        x = feat.values.astype(\"float32\")\n        index = feat.index\n        groups = self._groups(index)\n        p_reg = self._cs_zscore(\n            self.reg_model.predict(x, num_iteration=self.reg_model.best_iteration), groups\n        )\n        p_rank = self._cs_zscore(\n            self.rank_model.predict(x, num_iteration=self.rank_model.best_iteration), groups\n        )\n        pred = self._cs_zscore((1.0 - self.rank_weight) * p_reg + self.rank_weight * p_rank, groups)\n        pred = self._cs_zscore(self._ema(index, pred, self.ema_alpha), groups)\n        return pd.Series(pred, index=index, name=\"score\")",
5  "after_line": 18,
6  "start_line": 19,
7  "end_line": 141
8}

1{
2  "n": 2
3}