个人博客：无奈何杨（wnhyang）
个人语雀：wnhyang
共享语雀：在线知识共享
Github：wnhyang - Overview
想必大家都有听过或做过职业和性格测试吧，尤其是现在的毕业生，在投了简历之后经常会收到一个什么测评，那些测评真的是又臭又长，做的简直让人崩溃，很多时候都是边骂边做，都什么玩意！？
然而，本篇就由此出发，把整个测评作为一个策略的话，其中每一项都是一条规则，通常每一条规则（问答）需要我们输入一个类似1-9的分数，1和9分别代表两个极端，最终这个策略会结合所有的问答结果计算出我们的性格/职业。这是如何做的呢？其实就是一种分类算法，就拿二维平面直角坐标系举例吧！
如下二维平面直角坐标系下分出了4个区域，性格/职业测评的每条问答可以理解为其中一条经过原点的直线，1-9分别指示两个方向，你的答案最终会是一个由原点出发的n条直线，这n条直线可以绘成一个多边形，而这个多边形就构成了最终结果，长得有点类似雷达图。
当然这只是二维平面直角坐标系的例子，实际上现实往往比这个更复杂，高于三维的我也举不出例子啊🙂↔️
总之最后结果绝大多数情况下都会是一个不规则的东西（我实在不知道更高维的该怎么描述），这种测评会取出凸点作为我们的倾向性格/职业。
好吧，关于文章开篇就到这里了，下面就可以正式开始了。不过我还是想讲一个题外话，小时候接触的数学函数（方程）可以很轻易的表示在二维直角坐标系下，随着对于数学的深入探索，出现了越来越多的奇奇怪怪的字母和方程，有人也讲"数学的尽头是字母"🤔然而当我们换一个坐标系，这些是不是也会变个模样呢？所以说有时候换个角度看问题就会有不同收获，或者说换个角度问题就会迎刃而解。
策略
策略组件大致实现如下，编排时会使用p_cn.tag("code")，运行FOR(p_fn).DO(r_cn).BREAK(p_bn);或FOR(p_fn).parallel(true).DO(r_cn);，前者适用于顺序模式，其他皆适用于后者。
java
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = LFUtil.POLICY_COMMON_NODE, nodeType = NodeTypeEnum.COMMON, nodeName = "策略普通组件")
public void policy(NodeComponent bindCmp) {
PolicyContext policyContext = bindCmp.getContextBean(PolicyContext.class);
PolicyContext.PolicyCtx policy = PolicyConvert.INSTANCE.convert2Ctx(policyMapper.selectByCode(bindCmp.getTag()));
policyContext.addPolicy(policy.getCode(), policy);
log.info("当前策略(code:{}, name:{}, code:{})", policy.getCode(), policy.getName(), policy.getCode());
if (PolicyMode.ORDER.equals(policy.getMode())) {
bindCmp.invoke2Resp(LFUtil.P_F, policy.getCode());
} else {
bindCmp.invoke2Resp(LFUtil.P_FP, policy.getCode());
}
}循环次数组件p_fn如下，查询策略下的所有规则（规则还没做版本控制，后面再改），返回规则列表大小。
java
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_FOR, nodeId = LFUtil.POLICY_FOR_NODE, nodeType = NodeTypeEnum.FOR, nodeName = "策略for组件")
public int policyFor(NodeComponent bindCmp) {
PolicyContext policyContext = bindCmp.getContextBean(PolicyContext.class);
String policyCode = bindCmp.getSubChainReqData();
List<PolicyContext.RuleCtx> ruleList = RuleConvert.INSTANCE.convert2Ctx(ruleMapper.selectByPolicyCode(policyCode));
policyContext.addRuleList(policyCode, ruleList);
return ruleList.size();
}循环中断组件p_bn如下，当策略上下文中有命中风险规则时就可以停止循环了。
java
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS_BOOLEAN, nodeId = LFUtil.POLICY_BREAK_NODE, nodeType = NodeTypeEnum.BOOLEAN, nodeName = "策略break组件")
public boolean policyBreak(NodeComponent bindCmp) {
PolicyContext policyContext = bindCmp.getContextBean(PolicyContext.class);
String policyCode = bindCmp.getSubChainReqData();
return policyContext.isHitRisk(policyCode);
}另外在使用异步循环编排时需要注意并发操作问题，尤其是对上下文的操作。
剩下的规则组件r_cn和策略上下文PolicyContext请往下看。
顺序：按部就班、循序渐进
顺序模式是最好理解，就是顺序运行策略下的所有规则，默认在第一条设定的风险规则触发后结束，其实更准确的叫法应该是首次。如下表在顺序模式下执行，到规则2就结束了，因为默认pass之外的才是风险规则。
| 规则 | 是否命中 | 处置方式 |
|---|---|---|
| 1 | true | pass |
| 2 | true | reject |
| 3 | false | sms |
| 4 | true | review |
最坏：未雨绸缪，防患未然
与顺序模式不同，需要执行所有的规则，综合最坏的作为结果。如下表在最坏模式下，最终结果是reject（因为reject>review>pass，这个是配置的）。
| 规则 | 是否命中 | 处置方式 |
|---|---|---|
| 1 | true | pass |
| 2 | true | reject |
| 3 | false | sms |
| 4 | true | review |
投票：集体智慧，共同决策
同上，需要执行完所有规则，以命中规则的结果最多的作为最终结果。如下表在投票模式下，结果是pass。
| 规则 | 是否命中 | 处置方式 |
|---|---|---|
| 1 | true | pass |
| 2 | true | reject |
| 3 | false | review |
| 4 | true | pass |
可以使用这样的计数器，但是考虑到策略集下有不一样的策略集，想必还要再包一层Map<String,ConcurrentHashMap<String, AtomicInteger>>，以策略code作为键。
java
private final ConcurrentHashMap<String, AtomicInteger> counters = new ConcurrentHashMap<>();
/**
* 增加指定 key 的计数值。
* 如果 key 不存在，则初始化为 1；如果存在，则将当前值加 1。
*/
public void increment(String key) {
// 使用 computeIfAbsent 方法来确保只在第一次遇到该 key 时创建新的 AtomicInteger
counters.computeIfAbsent(key, k -> new AtomicInteger(0)).incrementAndGet();
}
/**
* 获取指定 key 的当前计数值。
* 如果 key 不存在，则返回 0。
*/
public int get(String key) {
// 获取指定 key 的 AtomicInteger，并调用 get() 方法获取其值
AtomicInteger counter = counters.get(key);
return (counter != null) ? counter.get() : 0;
}本来考虑的是在规则True组件中根据策略不同做不同的事情，但后来放弃了，还是统一放在上下文中吧，且往下看。
权重：量化评估，科学分配
一样，需要运行完所有规则，综合权重模式阈值配置得出最终结论。如下表在权重模式下，结果是23+21+20=64，注意！！！这里只是得到一个数字，在策略设置为权重模式后额外还需要配置一个阈值表，拿这个数字去匹配对应的阈值区间得出最终结论。当然这只是个最简单例子，下面将展开，讨论其丰富的应用场景和更灵活的使用方法。
| 规则 | 是否命中 | 得分 |
|---|---|---|
| 1 | true | 23 |
| 2 | true | 21 |
| 3 | false | 30 |
| 4 | true | 20 |
阈值配置表
| 得分 | 结果 |
|---|---|
| (-214,20] | pass |
| (20,45] | review |
| (45,70] | sms |
| (70,900) | reject |
设计过程
阶段一：规则增加简单的分数属性，命中时累计就好，如：规则1命中时+10，规则2命中时-2，这样最为简单，也因此适用场景最少，最不灵活。
阶段二：固定公式计算，如下规则附加这些属性，在规则命中时计算一下，这种只适合简单的线性相关的规则计算。
java
/**
* 计算公式为：base + al aOpType(加/减/乘/除) ${value}(取决于opType类型，是指标还是字段)，结果范围[lowerLimit,upperLimit]
*
* @author wnhyang
* @date 2024/12/9
**/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Weight {
private Double base; // 基础权重
private Double al; // 权重调整因子
private String aOpType; // 操作类型：加/减/乘/除
private String opType; // 指标还是字段
private String value; // 指标名称或字段名称
private Double upperLimit; // 上限
private Double lowerLimit; // 下限
/**
* 计算最终权重
*
* @param trueValue 实际值，当 opType 为 "zb" (指标) 时使用
* @return 最终计算出的权重
*/
public double compute(double trueValue) {
if (al == null || trueValue == 0 && ("/".equals(aOpType))) {
throw new IllegalArgumentException("Invalid parameters for computation.");
}
double adjustment = 0;
switch (aOpType) {
case "+":
adjustment = al + trueValue;
break;
case "-":
adjustment = al - trueValue;
break;
case "*":
adjustment = al * trueValue;
break;
case "/":
adjustment = al / trueValue;
break;
default:
throw new UnsupportedOperationException("Unsupported operation type: " + aOpType);
}
double result = base + adjustment;
return Math.min(upperLimit, Math.max(lowerLimit, result));
}
public static void main(String[] args) {
Weight weight = new Weight(10.41, -2.154, "*", "zb", "count", 5000.545, -56.654);
double compute = weight.compute(25.21);
System.out.println("Computed weight: " + compute);
}
}阶段三：灵活公式，使用QLExpress实现。如下讲计算公式作为规则的一个属性，通过getOutVarNames获取需要用到的外部变量名，在运行表达式之前通过LiteFlow上下文取值塞到QLExpress的上下文中。
当然还有可以优化的地方，1、设计上下文时实现QLExpress的IExpressContext接口，也就不用获取后在塞，直接拿LiteFlow上下文作为QLExpress上下文用就行；2、还有就是min(upperLimit, max({}, lowerLimit))是否要放在表达式中，其实也是没必要，可以放在表达式计算完成之后嘛。3、是否要计算平均值，现在是权重之和，是否要做加权平均呢？4、等等
java
@Test
public void test3() throws Exception {
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<>();
String fun = "base + al * value";
String express = StrUtil.format("min(upperLimit, max({}, lowerLimit))", fun);
log.info(express);
String[] outVarNames = runner.getOutVarNames(express);
log.info(Arrays.toString(outVarNames));
context.put("base", 45.434);
context.put("al", 3.352);
context.put("value", 24.3264);
context.put("lowerLimit", -35.342);
context.put("upperLimit", 3463.57);
Object r = runner.execute(express, context, null, true, false);
log.info("{}", r);
}注意点
对于像这种可输入的、脚本类的、在系统中运行的，一定要做好安全性校验，避免直接操作系统资源，稍微不注意控制就会有安全漏洞。在保证安全的前提下，再考虑如何优化用户使用体验，如用户需要使用一些系统字段时，在编辑器文本域输入特殊字符（像"@"或"#"），监听到输入后显示候选列表，可以关键词匹配并选择需要的字段，一旦选中，这个将作为一个整体，只能整体操作，就像我们在发邮件，或者聊天时输入"@"一样，另外再做一个内置运算符的提示符，这样编辑公式就更加便捷，且能降低出错率。再进一步就是做一个常用公式库，提示列表中有直接选中就行，剩下的就是填充需要的字段就行。
应用场景
比如在做密码登录时，设置了两条规则，一条正向规则y1=f(x1)，x1表示最近人脸登录成功次数，其与结果负相关，人脸登录成功次数越多得到的负数越大；一条反向规则y2=f(x2)，x2表示最近密码登录失败次数，其与结果正相关，密码登录失败次数越多得到的分数越大，而且保证其"增长率"大于f(x1)。
可以大致表示为下面的曲线，最近人脸登录成功次数少时，风险高一些，多时也会存在上限，因为再多也没有意义了；最新密码登录错误次数少时风险低，但密码登录次数越多风险急剧增加，这样的话在整合y=y1+y2=f(x1)+f(x2)后，风险受密码登录错误次数的影响更大。
当然将两个公式整合到一块做为一个规则也是可以的，差别就是是否需要独立的规则条件。
| 条件 | 公式 | |
|---|---|---|
| 不合并 | condition1 | f(x1) |
| condition2 | f(x2) | |
| 合并 | condition1 | f(x1)+f(x2) |
还有就是在信贷计算信用时，需要计算收入稳定性+信用历史+就业情况+债务水平+资产情况的场景时，当然这依赖多方数据，而且一般的信用评估不是简单的规则配置能解决的。
模型：智能学习，进化升级
最终都将到这一步的，虽然现在做的项目中还没有集成模型，但是我之后一定会做。先立flag嘛，实现不是实现另说吧🧐可别连立flag的勇气都没有了！
关于模型我也不是专业的，也是仅有一点点了解。我一直认为学习能力、看待、解决问题的思想是最重要的，特别是我看了几个关于机器学习的视频后，虽然其中很多的公式我都不懂，但是能理解到其看待、解决问题的思路方法，很受益，很有启发。
规则
以下分别是规则组件（包含isAccess实现）、命中规则、未命中规则组件。在规则命中时额外计算规则配置的权重表达式。
java
@LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = LFUtil.RULE_COMMON_NODE, nodeType = NodeTypeEnum.COMMON)
public boolean ruleAccess(NodeComponent bindCmp) {
String policyCode = bindCmp.getSubChainReqData();
int index = bindCmp.getLoopIndex();
PolicyContext policyContext = bindCmp.getContextBean(PolicyContext.class);
PolicyContext.RuleCtx rule = policyContext.getRule(policyCode, index);
return !RuleStatus.OFF.equals(rule.getStatus());
}
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = LFUtil.RULE_COMMON_NODE, nodeType = NodeTypeEnum.COMMON, nodeName = "规则普通组件")
public void rulProcess(NodeComponent bindCmp) {
String policyCode = bindCmp.getSubChainReqData();
int index = bindCmp.getLoopIndex();
PolicyContext policyContext = bindCmp.getContextBean(PolicyContext.class);
PolicyContext.RuleCtx rule = policyContext.getRule(policyCode, index);
bindCmp.invoke2Resp(StrUtil.format(LFUtil.RULE_CHAIN, rule.getCode()), rule);
}
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = LFUtil.RULE_TRUE, nodeType = NodeTypeEnum.COMMON, nodeName = "规则true组件")
public void ruleTrue(NodeComponent bindCmp) {
PolicyContext policyContext = bindCmp.getContextBean(PolicyContext.class);
PolicyContext.RuleCtx rule = bindCmp.getSubChainReqData();
log.info("命中规则(name:{}, code:{})", rule.getName(), rule.getCode());
if (RuleStatus.MOCK.equals(rule.getStatus())) {
policyContext.addHitMockRuleVO(rule.getPolicyCode(), rule);
} else {
// 权重
if (PolicyMode.WEIGHT.equals(policyContext.getPolicy(rule.getPolicyCode()).getMode())) {
try {
Double value = (Double) QLExpressUtil.execute(rule.getExpress(), bindCmp.getContextBean(FieldContext.class));
rule.setExpressValue(value);
} catch (Exception e) {
log.error("规则表达式执行异常", e);
}
}
policyContext.addHitRuleVO(rule.getPolicyCode(), rule);
}
}
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = LFUtil.RULE_FALSE, nodeType = NodeTypeEnum.COMMON, nodeName = "规则false组件")
public void ruleFalse(NodeComponent bindCmp) {
log.info("规则未命中");
}策略上下文
直接上代码了。
java
/**
* @author wnhyang
* @date 2024/4/3
**/
public class PolicyContext {
/**
* 处置方式集合
*/
private final Map<String, DisposalCtx> disposalMap = new ConcurrentHashMap<>();
/**
* 策略集
*/
private PolicySetCtx policySet;
/**
* 初始化
*
* @param disposalCtxList 处置方式集合
* @param policySet 策略集
*/
public void init(List<DisposalCtx> disposalCtxList, PolicySetCtx policySet) {
for (DisposalCtx disposalCtx : disposalCtxList) {
disposalMap.put(disposalCtx.getCode(), disposalCtx);
}
this.policySet = policySet;
}
/**
* 策略集合
*/
private final Map<String, PolicyCtx> policyMap = new ConcurrentHashMap<>();
/**
* 添加策略
*
* @param policyCode 策略code
* @param policy 策略
*/
public void addPolicy(String policyCode, PolicyCtx policy) {
policyMap.put(policyCode, policy);
}
/**
* 获取策略
*
* @param policyCode 策略code
* @return 策略
*/
public PolicyCtx getPolicy(String policyCode) {
return policyMap.get(policyCode);
}
/**
* 规则集合
*/
private final Map<String, List<RuleCtx>> ruleListMap = new ConcurrentHashMap<>();
/**
* 添加规则集合
*
* @param policyCode 策略code
* @param ruleList 规则列表
*/
public void addRuleList(String policyCode, List<RuleCtx> ruleList) {
ruleListMap.put(policyCode, ruleList);
}
/**
* 获取规则
*
* @param policyCode 策略code
* @param index 规则索引
* @return 规则
*/
public RuleCtx getRule(String policyCode, int index) {
return ruleListMap.get(policyCode).get(index);
}
/**
* 命中规则集合
*/
private final Map<String, List<RuleCtx>> hitRuleListMap = new ConcurrentHashMap<>();
/**
* 添加命中规则
*
* @param policyCode 策略code
* @param rule 规则
*/
public void addHitRuleVO(String policyCode, RuleCtx rule) {
if (!hitRuleListMap.containsKey(policyCode)) {
hitRuleListMap.put(policyCode, CollUtil.newArrayList());
}
hitRuleListMap.get(policyCode).add(rule);
}
/**
* 是否命中风险规则
*
* @param policyCode 策略code
* @return true/false
*/
public boolean isHitRisk(String policyCode) {
if (CollUtil.isNotEmpty(hitRuleListMap.get(policyCode))) {
for (RuleCtx ruleCtx : hitRuleListMap.get(policyCode)) {
if (!DisposalConstant.PASS_CODE.equals(ruleCtx.getDisposalCode())) {
return true;
}
}
}
return false;
}
/**
* 命中模拟规则集合
*/
private final Map<String, List<RuleCtx>> hitMockRuleListMap = new ConcurrentHashMap<>();
/**
* 添加命中模拟规则
*
* @param policyCode 策略code
* @param rule 规则
*/
public void addHitMockRuleVO(String policyCode, RuleCtx rule) {
if (!hitMockRuleListMap.containsKey(policyCode)) {
hitMockRuleListMap.put(policyCode, CollUtil.newArrayList());
}
hitMockRuleListMap.get(policyCode).add(rule);
}
/**
* 转策略集结果
*
* @return 策略集结果
*/
public PolicySetResult convert() {
PolicySetResult policySetResult = new PolicySetResult(policySet.getName(), policySet.getCode(), policySet.getChain(), policySet.getVersion());
for (Map.Entry<String, PolicyCtx> entry : policyMap.entrySet()) {
PolicyCtx policy = entry.getValue();
PolicyResult policyResult = new PolicyResult(policy.getName(), policy.getCode(), policy.getMode());
// 最坏
String maxDisposalCode = DisposalConstant.PASS_CODE;
int maxGrade = Integer.MIN_VALUE;
// 投票
Map<String, Integer> votes = new HashMap<>();
// 权重
double weight = 0.0;
List<RuleCtx> ruleList = hitRuleListMap.get(policy.getCode());
if (CollUtil.isNotEmpty(ruleList)) {
for (RuleCtx rule : ruleList) {
if (PolicyMode.VOTE.equals(policy.getMode())) {
// 投票
votes.put(rule.getDisposalCode(), votes.getOrDefault(rule.getDisposalCode(), 0) + 1);
} else if (PolicyMode.WEIGHT.equals(policy.getMode())) {
// 权重
weight += rule.getExpressValue();
}
RuleResult ruleResult = new RuleResult(rule.getName(), rule.getCode(), rule.getExpress());
// 最坏和顺序
DisposalCtx disposal = disposalMap.get(rule.getDisposalCode());
if (null != disposal) {
ruleResult.setDisposalName(disposal.getName());
ruleResult.setDisposalCode(disposal.getCode());
if (disposal.getGrade() > maxGrade) {
maxGrade = disposal.getGrade();
maxDisposalCode = disposal.getCode();
}
}
// 模拟/正式规则区分开
if (RuleStatus.MOCK.equals(rule.getStatus())) {
policyResult.addMockRuleResult(ruleResult);
} else {
policyResult.addRuleResult(ruleResult);
}
}
}
if (PolicyMode.VOTE.equals(policy.getMode())) {
String maxVoteDisposalCode = DisposalConstant.PASS_CODE;
int maxVoteCount = Integer.MIN_VALUE;
for (Map.Entry<String, Integer> entry1 : votes.entrySet()) {
if (entry1.getValue() > maxVoteCount) {
maxVoteCount = entry1.getValue();
maxVoteDisposalCode = entry1.getKey();
}
}
policyResult.setDisposalName(disposalMap.get(maxVoteDisposalCode).getName());
policyResult.setDisposalCode(maxVoteDisposalCode);
} else if (PolicyMode.WEIGHT.equals(policy.getMode())) {
List<Th> thList = policy.getThList();
// 排序
thList.sort(Comparator.comparing(Th::getScore));
for (Th th : thList) {
if (weight <= th.getScore()) {
policyResult.setDisposalName(disposalMap.get(th.getCode()).getName());
policyResult.setDisposalCode(th.getCode());
break;
}
}
} else {
policyResult.setDisposalName(disposalMap.get(maxDisposalCode).getName());
policyResult.setDisposalCode(maxDisposalCode);
}
policySetResult.addPolicyResult(policyResult);
}
// TODO 入度大于1？考虑投票、加权平均等方法：不考虑
policySetResult.setDisposalName(DisposalConstant.PASS_NAME);
policySetResult.setDisposalCode(DisposalConstant.PASS_CODE);
return policySetResult;
}
}策略集
策略集是用来编排策略的，即前面的策略组件p_cn.tag("code")，从前面已知策略会有结果的，那么编排他们的策略集如何取这个结果呢？
这就要考虑如何设计策略集的编排了，两种情况，入度为1，入度大于1。
如下，图1并行运行策略1、2，并最终都返回到结束节点，这时就要考虑如何处理策略1、2的结果了，投票？加权平均？随机选一个？还是其他什么方法？图2通过分流结束节点只会接收到一个策略，那么此时就不会有冲突，分流到哪个就返回哪个。
当然这块还没想好怎么做，只是一些想法。
小结
本来还想分享一下项目进展的，但转眼一看好像写的已经有点多了，那就下次吧！
写在最后
拙作艰辛，字句心血，望诸君垂青，多予支持，不胜感激。
个人博客：无奈何杨（wnhyang）
个人语雀：wnhyang
共享语雀：在线知识共享
Github：wnhyang - Overview
