cnhkmcp 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

cnhkmcp/untracked/APP/trailSomeAlphas/skills/brain-feature-implementation/scripts/parsetab.py

@@ -0,0 +1,60 @@
+
+# parsetab.py
+# This file is automatically generated. Do not edit.
+# pylint: disable=W,C,R
+_tabversion = '3.10'
+
+_lr_method = 'LALR'
+
+_lr_signature = 'ASSIGN BOOLEAN CATEGORY COMMA DIVIDE EQUAL FIELD FUNCTION GREATER GREATEREQUAL IDENTIFIER LESS LESSEQUAL LPAREN MINUS NOTEQUAL NUMBER PLUS RPAREN STRING TIMESexpression : comparison\n| expression EQUAL comparison\n| expression NOTEQUAL comparison\n| expression GREATER comparison\n| expression LESS comparison\n| expression GREATEREQUAL comparison\n| expression LESSEQUAL comparisoncomparison : term\n| comparison PLUS term\n| comparison MINUS termterm : factor\n| term TIMES factor\n| term DIVIDE factorfactor : NUMBER\n| STRING\n| FIELD\n| CATEGORY\n| IDENTIFIER\n| BOOLEAN\n| MINUS factor\n| LPAREN expression RPAREN\n| function_callfunction_call : FUNCTION LPAREN args RPARENargs : arg_list\n| emptyarg_list : arg\n| arg_list COMMA argarg : expression\n| IDENTIFIER ASSIGN expressionempty :'
+    
+_lr_action_items = {'NUMBER':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,]),'STRING':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,]),'FIELD':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,]),'CATEGORY':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,]),'IDENTIFIER':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[10,10,10,10,10,10,10,10,10,10,10,10,10,44,44,10,]),'BOOLEAN':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,]),'MINUS':([0,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,21,22,23,24,25,27,28,29,30,31,32,33,34,35,36,37,38,44,45,46,47,],[4,22,-8,4,-11,-14,-15,-16,-17,-18,-19,4,-22,4,4,4,4,4,4,4,4,4,4,-20,4,22,22,22,22,22,22,-9,-10,-12,-13,-21,-18,-23,4,4,]),'LPAREN':([0,4,12,14,15,16,17,18,19,20,21,22,23,24,27,46,47,],[12,12,12,27,12,12,12,12,12,12,12,12,12,12,12,12,12,]),'FUNCTION':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,]),'$end':([1,2,3,5,6,7,8,9,10,11,13,25,28,29,30,31,32,33,34,35,36,37,38,45,],[0,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,-23,]),'EQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[15,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,15,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,15,-18,-23,15,]),'NOTEQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[16,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,16,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,16,-18,-23,16,]),'GREATER':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[17,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,17,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,17,-18,-23,17,]),'LESS':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[18,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,18,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,18,-18,-23,18,]),'GREATEREQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[19,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,19,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,19,-18,-23,19,]),'LESSEQUAL':([1,2,3,5,6,7,8,9,10,11,13,25,26,28,29,30,31,32,33,34,35,36,37,38,43,44,45,49,],[20,-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,20,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,20,-18,-23,20,]),'RPAREN':([2,3,5,6,7,8,9,10,11,13,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,48,49,],[-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,38,-30,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,45,-24,-25,-26,-28,-18,-23,-27,-29,]),'COMMA':([2,3,5,6,7,8,9,10,11,13,25,28,29,30,31,32,33,34,35,36,37,38,40,42,43,44,45,48,49,],[-1,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,-2,-3,-4,-5,-6,-7,-9,-10,-12,-13,-21,46,-26,-28,-18,-23,-27,-29,]),'PLUS':([2,3,5,6,7,8,9,10,11,13,25,28,29,30,31,32,33,34,35,36,37,38,44,45,],[21,-8,-11,-14,-15,-16,-17,-18,-19,-22,-20,21,21,21,21,21,21,-9,-10,-12,-13,-21,-18,-23,]),'TIMES':([3,5,6,7,8,9,10,11,13,25,34,35,36,37,38,44,45,],[23,-11,-14,-15,-16,-17,-18,-19,-22,-20,23,23,-12,-13,-21,-18,-23,]),'DIVIDE':([3,5,6,7,8,9,10,11,13,25,34,35,36,37,38,44,45,],[24,-11,-14,-15,-16,-17,-18,-19,-22,-20,24,24,-12,-13,-21,-18,-23,]),'ASSIGN':([44,],[47,]),}
+
+_lr_action = {}
+for _k, _v in _lr_action_items.items():
+   for _x,_y in zip(_v[0],_v[1]):
+      if not _x in _lr_action:  _lr_action[_x] = {}
+      _lr_action[_x][_k] = _y
+del _lr_action_items
+
+_lr_goto_items = {'expression':([0,12,27,46,47,],[1,26,43,43,49,]),'comparison':([0,12,15,16,17,18,19,20,27,46,47,],[2,2,28,29,30,31,32,33,2,2,2,]),'term':([0,12,15,16,17,18,19,20,21,22,27,46,47,],[3,3,3,3,3,3,3,3,34,35,3,3,3,]),'factor':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[5,25,5,5,5,5,5,5,5,5,5,36,37,5,5,5,]),'function_call':([0,4,12,15,16,17,18,19,20,21,22,23,24,27,46,47,],[13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,]),'args':([27,],[39,]),'arg_list':([27,],[40,]),'empty':([27,],[41,]),'arg':([27,46,],[42,48,]),}
+
+_lr_goto = {}
+for _k, _v in _lr_goto_items.items():
+   for _x, _y in zip(_v[0], _v[1]):
+       if not _x in _lr_goto: _lr_goto[_x] = {}
+       _lr_goto[_x][_k] = _y
+del _lr_goto_items
+_lr_productions = [
+  ("S' -> expression","S'",1,None,None,None),
+  ('expression -> comparison','expression',1,'p_expression','validator.py',383),
+  ('expression -> expression EQUAL comparison','expression',3,'p_expression','validator.py',384),
+  ('expression -> expression NOTEQUAL comparison','expression',3,'p_expression','validator.py',385),
+  ('expression -> expression GREATER comparison','expression',3,'p_expression','validator.py',386),
+  ('expression -> expression LESS comparison','expression',3,'p_expression','validator.py',387),
+  ('expression -> expression GREATEREQUAL comparison','expression',3,'p_expression','validator.py',388),
+  ('expression -> expression LESSEQUAL comparison','expression',3,'p_expression','validator.py',389),
+  ('comparison -> term','comparison',1,'p_comparison','validator.py',396),
+  ('comparison -> comparison PLUS term','comparison',3,'p_comparison','validator.py',397),
+  ('comparison -> comparison MINUS term','comparison',3,'p_comparison','validator.py',398),
+  ('term -> factor','term',1,'p_term','validator.py',405),
+  ('term -> term TIMES factor','term',3,'p_term','validator.py',406),
+  ('term -> term DIVIDE factor','term',3,'p_term','validator.py',407),
+  ('factor -> NUMBER','factor',1,'p_factor','validator.py',414),
+  ('factor -> STRING','factor',1,'p_factor','validator.py',415),
+  ('factor -> FIELD','factor',1,'p_factor','validator.py',416),
+  ('factor -> CATEGORY','factor',1,'p_factor','validator.py',417),
+  ('factor -> IDENTIFIER','factor',1,'p_factor','validator.py',418),
+  ('factor -> BOOLEAN','factor',1,'p_factor','validator.py',419),
+  ('factor -> MINUS factor','factor',2,'p_factor','validator.py',420),
+  ('factor -> LPAREN expression RPAREN','factor',3,'p_factor','validator.py',421),
+  ('factor -> function_call','factor',1,'p_factor','validator.py',422),
+  ('function_call -> FUNCTION LPAREN args RPAREN','function_call',4,'p_function_call','validator.py',450),
+  ('args -> arg_list','args',1,'p_args','validator.py',454),
+  ('args -> empty','args',1,'p_args','validator.py',455),
+  ('arg_list -> arg','arg_list',1,'p_arg_list','validator.py',462),
+  ('arg_list -> arg_list COMMA arg','arg_list',3,'p_arg_list','validator.py',463),
+  ('arg -> expression','arg',1,'p_arg','validator.py',470),
+  ('arg -> IDENTIFIER ASSIGN expression','arg',3,'p_arg','validator.py',471),
+  ('empty -> <empty>','empty',0,'p_empty','validator.py',478),
+]

cnhkmcp/untracked/APP/trailSomeAlphas/skills/template_final_enhance/op/321/206/320/220/342/225/227/321/207/342/225/227/320/243.md

@@ -0,0 +1,434 @@
+先给个小计划：
+1）用一个统一的单因子例子（比如 anl11_esgreg_industryperc）来思考“哪些区间有信号、哪些是噪音”。
+2）按算子类别，一一说明典型适用场景，重点围绕你提到的“只一部分区间有信号 / 极值是噪音 / 时序更重要”等情况。
+
+下面我按类别来梳理，每个只讲“什么时候应该想起它”。
+
+一、简单算术类（add / subtract / multiply / reverse / power / signed_power / log / sqrt / s_log_1p / abs）
+
+add(A, c) / subtract(A, c)
+
+场景：想把阈值移动到别的区间，例如 A 本来 0–100，你想用 “(A-50)>0” 判断高于中位；
+简单平移，用于配合逻辑算子（greater/less）做“高于某个基准”的判断。
+multiply(A, c)（c>0）
+
+场景：你已经认可当前形状/排序，只想调整“力度”（控制尾部放大还是压缩）或和其他因子对齐量级；
+调权重，不改变好坏排序。
+reverse(A)（-A）
+
+场景：你发现指标“值越小越好”（比如利差、成本），想改成“值越大越好”的方向；
+或同一个原始字段想同时挖 value/momentum 两方向信号，一个用 A，一个用 -A。
+power(A, y)（A≥0）
+
+场景：你希望放大高端或低端：
+y>1：突出极端高值（比如只关心极高 ESG 的公司—tail 强调）；
+0<y<1：压缩差距，只保留大致排序，不让极端值太主导。
+
+signed_power(A, y)
+场景：A 有正负，正负号本身有含义（好/坏），你只想“非线性放大极端程度”，不能把符号毁掉；
+比如盈利 surprise zscore，高正/高负都想被放大，而 0 附近缩小。
+log(A) / sqrt(A)（A>0）
+
+场景：A 分布高度右偏，极个别超大值是噪音，想压扁右尾；
+例如成交量类、规模类字段拉得太长，用 log 把大公司压回来，但顺序还保留。
+s_log_1p(A)
+
+场景：想把正负两边都压短，但不破坏“正是好、负是坏”的结构；
+尤其适用于 zscore 后的因子，避免少数极端 zscore>5 的点主导。
+abs(A)
+
+场景：你不在乎正负方向，只关心“离中性多远”：
+如“极端 ESG 无论好坏都可能带来风险溢价”，先做 zscore，再 abs 找两端。
+二、逻辑算子（greater / less / greater_equal / less_equal / equal / not_equal / and / or / not / if_else / is_nan / trade_when）
+
+greater(A, threshold) / less(A, threshold)
+
+场景：你认为只有高于某阈值的区域才有信号，中间区间全是噪音；
+如：greater(A, 80) 把 ESG 行业分位 >80% 的打上标签。
+if_else(cond, x, y)
+
+场景：要做“分段函数”：
+例如 A>80 用 A 自己，A 在 20–80 之间直接给 0，A<20 用 -A；
+用来实现“头尾有含义，中间视为 0”。
+trade_when(cond, new_value, old_value)
+
+场景：你想在满足条件时改变 alpha 值 / 关闭仓位：
+如：trade_when(less(A,20), NAN, A) → 低于 20 分的 ESG 直接不持仓；
+或只在 “A 显著好/差” 时 trade，其他时间保持昨天的权重。
+and / or / not
+
+场景：组合多条件，例如“ESG 高且 盈利高 才算好”，“ESG 差或 盈利差 就算差”；
+在你刚才举的 ESG×盈利例子、区间过滤里非常关键。
+is_nan(A)
+
+场景：处理缺失数据，过滤掉“看似极值其实是缺数据”的点；
+或建立“有无披露”的信号（披露本身可能有含义）。
+三、截面预处理&形状控制（winsorize / zscore / normalize / quantile / truncate / scale）
+
+winsorize(A, std=4)
+
+场景：你怀疑极小区间（最极端头/尾）是噪音，但又不想完全扔掉：
+用标准差裁剪，把极值“拉回”可控范围，保留排序；
+如 ESG 分数里个别公司数据错误/极端，先 winsorize 再用。
+zscore(A)
+
+场景：
+你想把不同尺度的指标放到统一标准（利于后续组合或理解强度）；
+或直接用 “相对平均的偏离程度”衡量好坏，而不是原始值；
+复杂场景下，“只有某段区间有信号” 之前，一般都会先 winsorize+zscore 做“干净版本”。
+normalize(A, useStd=false)
+
+场景：
+想让 alpha 向量满足一些约束（如和为 0、绝对和为 1 等）以方便模拟；
+已经认定好坏排序无误，只需要变成实际可交易权重。
+quantile(A, driver=gaussian|cauchy|uniform)
+
+场景：
+只信 rank，不信原始间距；
+想把头尾拉长、中间压缩，使“头尾区域贡献更大，中间区间噪音影响更小”；
+比如：quantile(A,"gaussian") 把中间堆在 0 附近，两头往远处拉。
+truncate(A, maxPercent=0.01)
+
+场景：
+想严格限制任一股票最大权重，即便因子极端也不能超出；
+如“即便最好的 ESG 也最多只占 1% booksize”，挤出一部分极端风险。
+scale(A, scale=1, longscale=1, shortscale=1)
+
+场景：
+控制多空强度，比如多头总权重=1，空头总权重=-1；
+或者想让“好公司”仓位更集中、坏公司更分散：用不同的 longscale/shortscale。
+四、分组算子（group_rank / group_zscore / group_scale / group_normalize / group_mean / group_backfill / group_cartesian_product）
+
+group_rank(A, group)
+
+场景：
+你觉得“信号只在组内排序上有意义”，不同组之间原始水平不能比；
+如 ESG 按行业比，行业间 ESG 水平不具可比性。
+group_zscore(A, group)
+
+场景：
+你想在行业内做“高于行业平均几个标准差”的度量；
+尤其当某些行业整体 ESG 水平很高/很低时，需要去掉这一层偏移。
+group_scale(A, group)
+
+场景：
+想要每个行业内的 A 从 0～1 线性分布，方便配合逻辑/桶化；
+比如只做“行业内 Top 20%”选股，之前先 group_scale 再用阈值。
+group_normalize(A, group)
+
+场景：
+想做到每天每个行业“净多空为 0 / 杠杆受控”，避免行业间暴露；
+单因子 A 决定组内排序，同时这个算子决定组内权重如何平衡。
+group_backfill(A, group, d)
+
+场景：
+某个行业里个别股票 ESG 缺数据，你想用同组历史均值/邻近值填充，用于维持样本量；
+防止某些组因缺值导致权重集中在少数有数据的成员。
+group_cartesian_product(g1, g2)
+
+场景：
+想在“行业 × 国家”“行业 × size”等更细粒度 group 内排序；
+对于只在特定子群（如小盘高 ESG）才有信号的因子特别有用。
+五、变换/筛选类（bucket / right_tail / left_tail / trade_when）
+
+bucket(rank(A), range="0,1,0.1")
+
+场景：
+你相信“只有前 10%/后 10% 的 A 有信号，中间是噪音”，想做分组处理；
+分桶后可以对不同桶施加不同逻辑（比如头部多、尾部空、中间 0）。
+right_tail(A, minimum)
+
+场景：
+想把“低于某值”的都视为噪音（NaN），只在右尾上做信号；
+例如只关心 ESG 行业分位>70%的公司，中低段看成无信号。
+left_tail(A, maximum)
+
+场景：
+想把“高于某值”的都视为噪音，只在左尾（差公司）上建反向信号；
+如“只做最低 ESG 10% 的反向因子”，其余不参与。
+trade_when(A, ...)
+
+场景：
+将“某区间内”的值替换为 0 / NaN / 别的逻辑输出，从而只在有信号区间交易；
+用于构造“区间择时”：例如仅当 A 超过某阈值时，才重新调整权重。
+六、时间序列算子（ts_mean / ts_rank / ts_delta / ts_zscore / ts_scale / ts_sum / ts_std_dev / ts_decay_linear / hump / hump_decay / ts_target_tvr_ / ts_backfill / ts_median / ts_quantile / ts_arg_max / ts_arg_min / ts_corr / ts_covariance / last_diff_value / days_from_last_change / ts_product / ts_step / ts_count_nans / ts_regression / kth_element / inst_tvr）*
+
+这些主要用于“时序上更好才是更好”的场景。
+
+ts_mean(A, d) / ts_median(A,d)
+
+场景：
+你认为“持续高 ESG / 高盈利”的公司更可靠，而不是只看某一时点；
+则用近 d 天平均/中位数来平滑一次性噪音。
+ts_delta(A, d)
+
+场景：
+“变好”比“绝对高”更重要，例如 ESG 评分持续上升；
+A_t - A_{t-d} > 0 代表在改善，可用作单独因子或与水平因子叠加。
+ts_rank(A, d) / ts_zscore(A,d) / ts_scale(A,d)
+
+场景：
+你关心 A 在自身过去窗口中的位置，“历史高位/低位”是否预示未来表现；
+如 ESG 刚刷新历史高值是否会带来短期 alpha。
+ts_decay_linear(A, d) / ts_decay_exp_window(A,d)
+
+场景：
+A 每天抖动大，但方向稳定，希望平滑，用“加权平均最近几天”的方式；
+控制周频/日频噪音，不改变整体趋势。
+hump(A, hump=0.01) / hump_decay(A, ...)
+
+场景：
+控制日间权重变化幅度，忽略太小的变化，降低 turnover；
+当你知道因子信号慢变，不需要对小抖动频繁调仓时。
+ts_target_tvr_* 一族
+
+场景：
+有明确 turnover 目标，想自动调整 decay 相关参数；
+对于已经验证有信号但过于频繁交易的因子，做“统一降速”。
+ts_backfill(A, lookback, ...) / kth_element
+
+场景：
+在时间维度上填补缺失 A，减少由于少数缺值导致的随机信号。
+days_from_last_change(A) / last_diff_value(A,d)
+
+场景：
+因子是“事件驱动型”的（评级变动、ESG 评级更新等），只在变动后若干天内才有信号；
+可以构造“距上次变化时间”的信号。
+七、Reduce / Combo 等（reduce_ / combo_a / self_corr 等）*
+
+这些更多在多因子/多 Alpha 组合层面用，但单因子也有场景：
+
+reduce_*（avg / max / min / stddev / percentage等）
+
+场景：
+你想从一个“多维度向量”提炼单值，例如同一公司的多条 ESG 子项合成一个指标；
+或在历史上把 A 的波动性/偏度/峰度作为新的单因子。
+combo_a(alphas, ...)
+
+场景：
+多个不同构造方式的同主题因子（比如多个 ESG 变体）组合，提升稳健性；
+单一指标不够可靠，想自动根据历史 IR 给权重。
+self_corr(A)
+
+场景：
+研究同因子在截面上的相关结构，比如 ESG 因子和某个 sector pattern 是否极度重叠；
+更偏研究/调试，不是直接构造单因子。
+小结（对应你说的那些“现实情景”）：
+
+只头部/尾部有信号：
+想起：rank + bucket + 逻辑算子（greater/less/if_else/trade_when）、right_tail / left_tail。
+中间区间是噪音：
+想起：用阈值+逻辑把中段置 0 / NaN（if_else/trade_when），或 quantile 把中间压在 0 附近。
+极值是噪音：
+想起：winsorize、truncate、log/s_log_1p 以及 group 版处理。
+时序上持续更好才是“好”：
+想起：ts_mean / ts_median / ts_rank / ts_delta / ts_zscore / ts_decay_linear 与 hump。
+只在某些 group 中有用信号（行业/国家/size）：
+想起：group_rank / group_zscore / group_scale / group_normalize / group_cartesian_product。
+如果你愿意，下一步我可以挑一个具体字段（比如 anl11_esgreg_industryperc），分别用“头尾信号型 / 极值噪音型 / 时序改善型 / group 内相对型”4 种典型场景，各写一个短而实战的 Alpha 表达式，让你一眼看到这些算子在真实情境下的用法差别。
+
+
+---------------------------------------------------------------------------------------------
+先说思路，再按算子类别给“B 的安全用法模板”。
+
+目标回顾
+
+已有主信号 A（决定方向和主排序）。
+从属信号 B 只能：
+放大/缩小 A 的力度；
+或在“已确定阵营”的前提下微调排序；
+不能：翻转方向、让 B 在全局上主导排序。
+下面假设 A 已经是你认可的版本（例如 A = zscore(winsorize(returns,4))），我们只讨论 “在 A 基础上怎样用 B”。
+
+一、Arithmetic 类算子（add / subtract / multiply / reverse / power / signed_power / log / sqrt / s_log_1p / abs / inverse / max / min）
+
+这里关键：让 B 进入一个受控区间，再影响 A。
+
+add(B,c) / subtract(B,c)
+
+用途：给 B 平移到围绕 0 的小区间。
+模板：
+b = zscore(winsorize(B,4))
+b_clip = winsorize(b, 2)
+再进入其他结构（见 multiply）。
+multiply(A, something(B))
+
+安全范式：
+factor = 1 + k * b_clip，其中 b_clip 已限制在[-1,1]，k 小于 1；
+core = A * factor
+示例：
+b = zscore(winsorize(B,4))
+b_clip = winsorize(b,2)
+factor = add(1, multiply(0.5, b_clip)) （≈ 0.5~1.5）
+core = multiply(A, factor, filter=true)
+这样：
+sign(core) = sign(A)；
+|core| 随 B 增大/减小。
+reverse(B) / inverse(B)（1/B）
+
+只适合作为 构造 factor 的中间步骤，仍要映射到有限区间：
+如：b_inv = inverse(B) → 再 zscore + winsorize + 映射到 [0.5,1.5]；
+不要 A * inverse(B) 直接上，会把稀奇小值放大得乱七八糟。
+power(B,y) / signed_power(B,y)
+
+用途：
+y>1：强调高 B；0<y<1：压平 B。
+模式：
+b = zscore(B) → b_clip = winsorize(b,2) → b2 = signed_power(b_clip, y) → 再缩放成 factor。
+依然走 “factor = 1 + k*b2” 的套路。
+log(B) / sqrt(B)
+
+用途：B>0 且右偏时压尾，避免少数巨大成交量/市值主导因子。
+一般流程：b = log(B) 或 sqrt(B) → 标准化、截断 → 做 factor。
+s_log_1p(B)
+
+用途：既压缩幅度又保留正负号，适合已 zscore 的 B：
+b = zscore(winsorize(B,4)) → b2 = s_log_1p(b)；b2 自动收在有限范围。
+abs(B) / max(A,B) / min(A,B)
+
+用途：
+abs(B)：我们只关心“B 极端程度”而非方向，例如极大成交量时更值得放大；
+可用：factor = 1 + k * s_log_1p(abs(zscore(B)))。
+max/min 不用于 A×B，而常用来在两种 factor 中选更强/更弱的一个。
+二、Logical 类（and / or / not / greater / less / equal / not_equal / if_else / is_nan）
+
+这里 B 更像“开关/权重档位”。
+
+区间筛选：只在某些 B 区间放大或允许交易
+
+例：B 为 volume，成交量太小的股票不想重仓：
+high_liq = greater(B, thresh)
+core = if_else(high_liq, A, 0.5*A) 或 trade_when(not high_liq, 0.5*A, A)。
+模式：
+B 只决定“用 A 还是 c*A”，而不是参与算术组合。
+多条件：B 只是辅助条件，不决定符号
+
+如：收益为正，且成交量高时才加大多头：
+long = greater(A,0)
+high_vol = greater(B, thresh)
+boost = and(long, high_vol)
+core = trade_when(boost, 1.5*A, A)。
+is_nan(B)
+
+用 B 的缺失与否控制是否用其影响：
+has_B = not(is_nan(B))
+core = trade_when(has_B, A * factor(B), A)。
+三、Cross-sectional 形状控制（winsorize / zscore / normalize / quantile / rank / truncate / scale）
+
+这些几乎是所有 “B 处理” 的第一步。
+
+对 B 做“干净版处理”：
+
+标准套路：
+b = zscore(winsorize(B,4))
+或 b_rank = rank(B)
+或 b_q = quantile(B,"gaussian")。
+关键：B 必须先被裁剪和标准化，再参与任何与 A 的组合。
+用 rank(B) 时特别注意：
+
+若你直接 A * rank(B)，B 会在[0,1]里直接线性放大/缩小 A（可接受）；
+真正危险的是 rank(A) * rank(B) 类型，“双 rank 全局扭曲排序”；
+安全模式：
+core = A * f(rank(B))，且 f 在有限区间（比如 [0.5,1.5]）。
+quantile(B, driver)
+
+适合把 B 的中间区间压到 0 附近，让“只有极高/极低的 B 才明显放大/抑制 A”；
+再映射到小系数范围即可。
+truncate / scale
+
+truncate(A, x)：作用于合成后的 core，保证任何单股票权重不爆；
+scale：多空总和、booksize 控制，与 B 关系不大，但最后一步常用。
+四、Group 类（group_rank / group_zscore / group_scale / group_normalize / group_backfill / group_mean）
+
+当 B 的含义“只在 group 内比较有意义”（如行业内量能/市值）：
+
+Group 内标准化 B：
+
+b = group_zscore(B, industry) 或 b_rank = group_rank(B, industry)；
+然后用作 factor 的原材料。
+典型安全模式：
+
+factor = 1 + k * group_zscore(B, industry) 截断在[-1,1]；
+或在多头/空头阵营内用 group_rank(B, group) 调整权重。
+不要用 group 结果去改变 A 的方向，只影响幅度和组内排序。
+
+五、Transformational（bucket / right_tail / left_tail / trade_when / right_tail/left_tail 已讲）
+
+bucket(rank(B), ...)
+
+场景：把 B 分为“极高 / 高 / 中 / 低 / 极低”，然后每个桶给不同放大倍数：
+模式：
+b_rank = rank(B)
+b_bucket = bucket(b_rank, "0,1,0.2")
+再 if_else / trade_when：
+极高桶：乘 1.5；高桶：乘 1.2；中桶：乘 1；低桶：乘 0.7；极低桶：乘 0.5。
+注意：始终是 “A * f(bucket(B))”。
+right_tail / left_tail
+
+提前把“无意义区间”的 B 变 NaN，然后只在 B 有意义区间里做放大；
+如：b_sig = right_tail(zscore(B), minimum=0) → 只对高量能时放大 A，其余 factor=1。
+trade_when（上面已部分提过）
+
+是最通用的 “条件改变 A 倍数或关闭仓位” 工具。
+样板：
+cond = some_function_of_B
+core = trade_when(cond, A * factor1, A * factor2)。
+六、Time Series 类（ts_mean / ts_rank / ts_delta / ts_zscore / ts_decay_linear / hump 等）
+
+这里 B 是时序信号，比如 volume, adv, 波动率等。
+
+基础清洗：
+
+b_ts = ts_zscore(B, d) 或 ts_rank(B,d)；
+用于识别“这个股票近期 volume 特别高/特别低”。
+安全组合范式：
+
+factor = 1 + k * ts_zscore(B,d) 截断；
+或 factor = f(ts_rank(B,d)) 映射到 [0.5,1.5]；
+再 core = A * factor。
+Turnover 控制相关（ts_decay_linear / hump / ts_target_tvr_*）：
+
+这些更多用于平滑最终 Alpha，而不是直接处理 B；
+可在合成 core 后：core_smooth = ts_decay_linear(core, 3)；B 的作用已经体现在 core 里。
+ts_delta(B,d) / days_from_last_change(B)
+
+把“最近量能/波动突变”作为从属放大器；
+例如 volume 爆量那几天放大 A，平时保持中立：
+b_spike = greater(ts_delta(B,1), thresh)
+core = trade_when(b_spike, 1.5*A, A)。
+七、Reduce / Combo 等
+
+多数用于多维/多因子的情况，不再一一展开；简单原则：
+
+若 B 其实是一组值（如多个 volume 相关字段），先用 reduce_avg/reduce_max 合成一个 B_agg，再按前面逻辑当作单一 B 处理。
+最后给一个总的“使用从属 B 的模板公式”
+
+可以抽象成：
+
+先得到干净的主信号：
+
+A_clean = some_transform_on_A(...)（你已完成）
+再把 B 变成有限、解释清晰的放大器：
+
+结构 1：线性缩放
+
+B_clean = standardize_and_clip(B)
+factor = 1 + k * B_clean （k 小于 1，B_clean 在[-1,1]）
+core = A_clean * factor
+结构 2：按阵营分配
+
+基于 A 确定阵营：long_mask = A_clean>0，short_mask = A_clean<0
+在每个阵营内部，用 rank(B) / group_rank(B,industry) 再调节：
+factor_long = f(rank(B | long_mask))
+factor_short = g(rank(B | short_mask))
+core = trade_when(long_mask, A_clean*factor_long, A_clean) 再对空头同理。
+最后再 normalize / scale / truncate 做可交易化。
+只要你保证“B 只出现在 factor 里，且 factor 不会跨 0”，主信号 A 的方向和骨干排序就不会被 B 颠覆。
+
+### Smoothing Operators
+- **ts_mean vs ts_decay_linear**:
+    - `ts_mean(x, N)` puts equal weight on all N days.
+    - `ts_decay_linear(x, N)` puts linearly decreasing weight (N, N-1, ..., 1).
+    - **Turnover Impact**: `ts_decay_linear` results in **much higher turnover** than `ts_mean` for the same window size, because it emphasizes recent data.
+    - Example: `ts_mean(x, 20)` -> Turnover 16%. `ts_decay_linear(x, 20)` -> Turnover 73%.
+    - **Recommendation**: Use `ts_mean` for reducing turnover. Use `ts_decay_linear` only if you need faster reaction and can afford the turnover.

cnhkmcp/untracked/APP/trailSomeAlphas/skills/template_final_enhance/sample_prompt.md

@@ -0,0 +1,62 @@
+An alpha template is a reusable recipe that captures an economic idea and leaves “slots” (data fields, operators, groups, decay, neutralization choices, etc.) to instantiate many candidate alphas. Typical structure: clean data (backfill, winsorize) → transform/compare across time or peers → rank/neutralize → (optionally) decay/turnover tune. Templates encourage systematic search, reuse, and diversification while keeping an explicit economic rationale.
+
+Some Example Templates and rationales
+
+CAPM residual (market/sector-neutral return): ts_regression(returns, group_mean(returns, log(ts_mean(cap,21)), sector), 252, rettype=0) after backfill+winsorize. Rationale: strip market/sector beta to isolate idiosyncratic alpha; sector-weighted by smoothed log-cap to reduce large-cap dominance.
+CAPM beta (slope) template: same regression with rettype=2; pre-clean target/market (ts_backfill(...,63) + winsorize(std=4)). Rationale: rank stocks by relative risk within sector; long low-β, short high-β, or study β dispersion across groups.
+CAPM generalized to any feature: data = winsorize(ts_backfill(<data>,63),std=4); data_gpm = group_mean(data, log(ts_mean(cap,21)), sector); resid = ts_regression(data, data_gpm, 252, rettype=0). Rationale: pull out the component unexplained by group average of same feature; reduces common-mode exposure.
+Actual vs estimate spread (analyst): group_zscore( group_zscore(<act>, industry) – group_zscore(<est>, industry), industry ) or the abstracted group_compare(diff(group_compare(act,...), group_compare(est,...)), ...). Rationale: surprise/beat-miss signal within industry, normalized to peers to avoid level bias.
+Analyst term-structure (fp1 vs fy1/fp2/fy2): group_zscore( group_zscore(anl14_mean_eps_<period1>, industry) – group_zscore(anl14_mean_eps_<period2>, industry), industry ) with operator/group slots. Rationale: cross-period expectation steepness; rising near-term vs long-term forecasts can flag momentum/inflection.
+Option Greeks net spread: group_operator(<put_greek> - <call_greek>, <grouping_data>) over industry/sector (Delta/Gamma/Vega/Theta). Rationale: options-implied sentiment/convexity skew vs peers; outlier net Greeks may precede spot moves; extend with multi-Greek composites or time-series deltas.
+
+
+based on the following guidance of how to make a data collation template into a signal, and guidance on how to utilize the best of operators.
+
+guidance of how to make a data collation template into a signal
+--------------
+D:\BRAINProject\cnhkmcp\cnhkmcp\untracked\APP\trailSomeAlphas\skills\template_final_enhance\单因子思考逻辑链.md
+--------------
+'guidance on how to use the best of operators'
+D:\BRAINProject\cnhkmcp\cnhkmcp\untracked\APP\trailSomeAlphas\skills\template_final_enhance\op总结.md
+--------------
+improve the following raw template
+{  "template": "({disclosed_intangibles} + {goodwill}) / {tot_asset} * {sales_rev_turn}",
+    "idea": "Intangible asset intensity scaled by revenue productivity to measure efficiency of non-physical capital."
+}  
+in the template, {} represent datafield set so keep it as that way, you should just return your new template with the operators you choose and properparameter. the output keey the same in json format and try to output as much diverse enhanced template as you can.
+[{
+    "enhanced_template": "",
+    "idea": ""
+},{
+    "enhanced_template": "",
+    "idea": ""
+},
+]
+
+
+
+--------------
+sample output
+
+[
+    {
+        "enhanced_template": "signed_power(group_zscore(winsorize((ts_backfill({disclosed_intangibles},63) + ts_backfill({goodwill},63)) / ts_backfill({tot_asset},63), std=4) * winsorize(ts_backfill({sales_rev_turn},63), std=4), sector), 0.5)",
+        "idea": "Sector-neutral intangible capital efficiency with concave transformation (sqrt). Assumes mid-range efficiency differentials are noisy; sub-linear scaling prevents extreme outliers from dominating while preserving rank order."
+    },
+    {
+        "enhanced_template": "trade_when(greater(rank(winsorize(ts_backfill({sales_rev_turn},63), std=4)), 0.6), group_zscore(winsorize((ts_backfill({disclosed_intangibles},63) + ts_backfill({goodwill},63)) / ts_backfill({tot_asset},63), std=4), sector), 0)",
+        "idea": "Intangible intensity signal conditioned on high asset productivity (top 40% turnover only). Filters out low-turnover value traps and focuses on efficient knowledge-capital deployers within sector peers."
+    },
+    {
+        "enhanced_template": "ts_zscore(ts_delta(winsorize((ts_backfill({disclosed_intangibles},126) + ts_backfill({goodwill},126)) / ts_backfill({tot_asset},126), std=4), 63), 252) * s_log_1p(group_zscore(winsorize(ts_backfill({sales_rev_turn},21), std=4), sector))",
+        "idea": "Time-series momentum in intangible capital intensity (quarterly change) scaled by recent productivity. Captures corporate investment shifts into knowledge assets while compressing extreme productivity outliers via symmetric log transform."
+    },
+    {
+        "enhanced_template": "ts_regression(winsorize((ts_backfill({disclosed_intangibles},63) + ts_backfill({goodwill},63)) / ts_backfill({tot_asset},63) * ts_backfill({sales_rev_turn},63), std=4), group_mean(winsorize((ts_backfill({disclosed_intangibles},63) + ts_backfill({goodwill},63)) / ts_backfill({tot_asset},63) * ts_backfill({sales_rev_turn},63), std=4), log(ts_mean(ts_backfill({close},1),21)), sector), 252, rettype=0)",
+        "idea": "CAPM-style residual extracting idiosyncratic intangible efficiency unexplained by size-weighted sector averages. Strips common capital-structure exposure to isolate firm-specific capital allocation skill."
+    },
+    {
+        "enhanced_template": "bucket(rank(group_zscore(winsorize((ts_backfill({disclosed_intangibles},63) + ts_backfill({goodwill},63)) / ts_backfill({tot_asset},63), std=4) * winsorize(ts_backfill({sales_rev_turn},63), std=4), sector)), '0,1,0.2')",
+        "idea": "Quintile bucketing of sector-adjusted intangible productivity creating discrete long-short portfolios. Treats middle quintiles as noise (neutral weight), isolating extreme efficient vs inefficient capital allocators."
+    }
+]