package com.estate.expert.admin.service.impl;
|
|
import com.estate.expert.admin.domain.business.device.Device;
|
import com.estate.expert.admin.domain.business.device.DeviceType;
|
import com.estate.expert.admin.domain.common.request.PageReq;
|
import com.estate.expert.admin.domain.common.response.PageResp;
|
import com.estate.expert.admin.domain.exam.eval.score.*;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorRecord;
|
import com.estate.expert.admin.domain.exam.task.check.CheckTask;
|
import com.estate.expert.admin.domain.plan.PlanType;
|
import com.estate.expert.admin.domain.standard.expert.Expert;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
|
import com.estate.expert.admin.service.eval.EvalScoreService;
|
import com.estate.expert.admin.service.eval.EvalServiceImpl;
|
import com.estate.expert.admin.service.expert.DeviceExpertService;
|
import com.estate.expert.admin.service.expert.SysExpertService;
|
import com.estate.expert.admin.utils.tree.helper.TreeHelper;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeMap;
|
import java.util.stream.Stream;
|
|
/**
|
* 评分算法服务实现
|
*/
|
@Service
|
public class EvalScoreServiceImpl extends EvalServiceImpl<EvalScoreResult, EvalScoreResultDto, EvalScoreResultInfo, ScoreResult> implements EvalScoreService {
|
|
private static final Logger log = LoggerFactory.getLogger(EvalScoreServiceImpl.class);
|
@Resource
|
private EvalScoreResultRepository repository;
|
|
@Override
|
public PageResp<EvalScoreResultInfo> list(Integer clientId, List<Integer> planIds, List<Integer> taskIds,
|
LocalDateTime startDate, LocalDateTime endDate, PageReq pageReq) {
|
var page = repository.list(clientId, planIds, taskIds, startDate, endDate,pageReq.toPageRequest());
|
return PageResp.of(page, page.getContent());
|
}
|
|
@Override
|
public List<EvalScoreResultMiniInfo> listMini(List<Integer> projectIds, PlanType planType) {
|
return repository.list(projectIds, planType);
|
}
|
|
@Override
|
public EvalScoreResult getByCheckTaskId(Integer checkTaskId) {
|
return repository.getFirstByTaskIdAndDeleted(checkTaskId, false);
|
}
|
|
@Override
|
public boolean enableByPass() {
|
return true;
|
}
|
|
/**
|
* 打分算法
|
*
|
* 扣除分数：所选记录，对应的，问题的问题数量集合中，
|
* 应得分数：体系层级中
|
* 权重：在专家管理，打分算法，权重值，需要归一化；如果找不到，就从层级中取
|
* (应得分数 - 扣除分数) * 权重，每层累加上去
|
* 上一级的得分= 下级得分之和/下级应得分之和 * 上一级的总分
|
* 叶子节点小问题只能出现一次
|
*
|
* 叶子节点的得分计算逻辑
|
*
|
* 假定一个节点为10分，每发现其下属的一个问题，就扣除相应的分数
|
* 最终得到该节点的分数
|
*/
|
@Override
|
public ScoreResult evaluate(Expert scoreExpert, SysExpertService expertService, List<ErrorRecord> records, List<String> byPassPaths){
|
// 初始化问题映射表
|
var problemMap = initProblemMap(scoreExpert, expertService);
|
|
// 根据专家的模型，构建评分树
|
var scoreResult = initSysResult(scoreExpert, expertService);
|
return commonEvaluate(problemMap, scoreResult, records, byPassPaths, 6);
|
}
|
|
@Override
|
protected ScoreResult evaluate(Expert expert, DeviceType deviceType,
|
DeviceExpertService expertService, List<ErrorRecord> errorRecords, List<String> byPassPaths) {
|
// 初始化问题映射表
|
var deviceScoreResult = initDeviceResult(deviceType, expert, expertService);
|
var problemMap = initDeviceProblemMap(deviceType, expert, expertService);
|
return commonEvaluate(problemMap, deviceScoreResult, errorRecords, byPassPaths, 4);
|
}
|
|
@Override
|
protected EvalScoreResult saveResult(CheckTask checkTask, ScoreResult sysRes, Map<Integer, ScoreResult> devResMap, List<Device> devices) {
|
if(sysRes != null && sysRes.root() != null)
|
checkTask.setSystemScore(sysRes.root().getData().getScore());
|
else
|
checkTask.setSystemScore(null);
|
|
var deviceScoreMap = new TreeMap<Integer, Float>();
|
devResMap.forEach((k, v) -> {
|
if(v != null && v.root() != null)
|
deviceScoreMap.put(k, v.root().getData().getScore());
|
else
|
deviceScoreMap.put(k, null);
|
});
|
checkTask.setDeviceScoreMap(deviceScoreMap);
|
return add(null , new EvalScoreResult(checkTask, sysRes, devResMap, devices));
|
}
|
|
private ScoreResult commonEvaluate(TreeMap<Integer, Boolean> problemMap, ScoreResult scoreResult,
|
List<ErrorRecord> records, List<String> byPassPaths, int leafDepth){
|
// 计数错误记录，将记录的扣分，累加到对应的节点上
|
count(problemMap, scoreResult, records, byPassPaths);
|
|
// 标记要参与评分的节点
|
mark(scoreResult);
|
|
// 优化掉没有参与评分的节点
|
scoreResult = prune(scoreResult, leafDepth);
|
|
// 按照树结构，逐层计算得分
|
compute(scoreResult, leafDepth);
|
|
prettyDisplay(scoreResult);
|
return scoreResult;
|
}
|
|
private ScoreResult initSysResult(Expert expert, SysExpertService expertService) {
|
var tree = expertService.getHierarchyTree(expert.getId());
|
var root = TreeHelper.<HierarchyData, ScoreValue>convertTree(tree.root(), (node, newNode) ->
|
ScoreValue.builder()
|
.total(node.getData().getScore())
|
.weight(node.getData().getWeight())
|
.build());
|
return new ScoreResult(root);
|
}
|
|
private ScoreResult initDeviceResult(DeviceType deviceType, Expert expert, DeviceExpertService expertService){
|
var tree = expertService.getHierarchyTree(expert.getId());
|
var root = TreeHelper.<HierarchyData, ScoreValue>convertTree(tree.root(), (node, newNode) ->
|
ScoreValue.builder()
|
.total(node.getData().getScore())
|
.weight(node.getData().getWeight())
|
.build(), (n) -> {
|
//删除掉非相关掉设备类型的节点
|
return n.getDepth() != 1 || deviceType.hierarchyPath().equals(n.getPath());
|
});
|
|
return new ScoreResult(root);
|
}
|
|
private void count(TreeMap<Integer, Boolean> problemMap, ScoreResult scoreResult, List<ErrorRecord> records, List<String> byPassPaths) {
|
// 打分算法
|
// 将每个问题记录的扣分，累加到对应的节点上
|
if(records != null) {
|
records.forEach(errorRecord -> {
|
var problem = errorRecord.getProblem();
|
var ps = problemMap.get(problem.getId());
|
|
// 如果问题不在模型中，不计算
|
// 如果问题已经计算过，也不计算（同一问题的记录只计算一次）
|
if (ps == null || ps)
|
return;
|
|
problemMap.put(problem.getId(), true);
|
|
// 数据出错，不计算
|
if (problem.getNumberFactors().isEmpty() || errorRecord.getNumberFactorIndex() >= problem.getNumberFactors().size())
|
return;
|
|
// 计算应扣除的分数
|
var node = scoreResult.get(problem.getHierarchyPath());
|
if(node == null)
|
return;
|
var numberFactor = problem.getNumberFactors().get(errorRecord.getNumberFactorIndex());
|
var scoreValue = node.getData();
|
scoreValue.setDeduct(scoreValue.getDeduct() + numberFactor.getDeductPoint());
|
scoreValue.setInclude(true);
|
scoreValue.addError(errorRecord.getLevel());
|
node.setData(scoreValue);
|
});
|
}
|
|
// 轮空项，如果设置了，则需要参与计算
|
if(byPassPaths != null){
|
byPassPaths.forEach(path -> {
|
var node = scoreResult.get(path);
|
if(node == null)
|
return;
|
var scoreValue = node.getData();
|
scoreValue.setInclude(true);
|
node.setData(scoreValue);
|
});
|
}
|
|
// 累加到上一级
|
TreeHelper.travel(scoreResult.root(), (node) -> {
|
var nodeData = node.getData();
|
for(var child : node.getChildren().values()) {
|
var childData = child.getData();
|
for(var i = 0; i < 4; i++) {
|
nodeData.getChildErrorCounts()[i] += childData.getErrorCounts()[i] + childData.getChildErrorCounts()[i];
|
}
|
}
|
});
|
}
|
|
/**
|
* 标记节点，用于裁剪不需要参与计算的节点
|
*/
|
private void mark(ScoreResult scoreResult)
|
{
|
TreeHelper.travel(scoreResult.root(), (node) -> {
|
// 只去更新非叶子节点的include属性
|
if(node.getChildren().isEmpty())
|
return;
|
|
// 如果有子节点参与评分，当前节点也参与评分
|
boolean include = false;
|
for (var child : node.getChildren().values()) {
|
if(child.getData().isInclude())
|
include = true;
|
}
|
node.getData().setInclude(include);
|
});
|
}
|
|
// 对个别需要显示的数值进行更新，便于前端展示
|
private void prettyDisplay(ScoreResult result) {
|
TreeHelper.travel(result.root(), (node) -> {
|
var fuzzyValue = node.getData();
|
// totalErrorCounts = errorCounts + childErrorCounts
|
fuzzyValue.setTotalErrorCounts(Stream.of(0,1,2,3)
|
.map(i -> fuzzyValue.getErrorCounts()[i] + fuzzyValue.getChildErrorCounts()[i])
|
.mapToInt(Integer::intValue)
|
.toArray());
|
});
|
}
|
|
/**
|
* 根据层级和权重，计算得分
|
*/
|
private void compute(ScoreResult scoreResult, int leafDepth) {
|
TreeHelper.travel(scoreResult.root(), (node) -> {
|
log.debug("计算节点: {}", node);
|
float totalWeight = 0;
|
float totalDeduct = 0;
|
|
if(node.getDepth() >= (leafDepth - 2))
|
{
|
// 最下的两层的计算逻辑不一样，只计算得分，不计算权重
|
float total = 0;
|
for(var child : node.getChildren().values()) {
|
if (!child.getData().isInclude())
|
continue;
|
|
// 计算总扣分
|
var sv = child.getData();
|
totalDeduct += Math.min(sv.getTotal(), sv.getDeduct() + sv.getChildrenDeduct());
|
total += sv.getTotal();
|
}
|
|
var value = node.getData();
|
if(node.getDepth() != leafDepth)
|
value.setTotal(total);
|
|
value.setChildrenDeduct(totalDeduct);
|
value.setTotalDeduct(value.getDeduct() + value.getChildrenDeduct());
|
value.setScore(Math.max(value.getTotal() - value.getTotalDeduct(), 0));
|
value.setNormalizedWeight(1.0f);
|
|
log.info("计算节点: {}，得分: {}", node, value.getScore());
|
}else {
|
var total = 0.0f;
|
|
// 计算总权重
|
for (var child : node.getChildren().values()) {
|
if (!child.getData().isInclude())
|
continue;
|
|
totalWeight += Math.max(child.getData().getWeight(), 1e-3f); // 防止权重为0
|
}
|
|
// 归一化权重，计算总扣分
|
for (var child : node.getChildren().values()) {
|
if (!child.getData().isInclude())
|
continue;
|
|
var sv = child.getData();
|
sv.setNormalizedWeight(Math.max(sv.getWeight(), 1e-3f) / totalWeight);
|
|
// 最大扣分不能超过总分, 节点的扣分包含两部分
|
totalDeduct += Math.min(sv.getTotal(), sv.getDeduct() + sv.getChildrenDeduct()) / sv.getTotal() * sv.getNormalizedWeight();
|
total += sv.getTotal();
|
}
|
|
var value = node.getData();
|
value.setChildrenDeduct(totalDeduct * value.getTotal());
|
value.setTotalDeduct(value.getDeduct() + value.getChildrenDeduct());
|
// 当前节点的得分 = 下级分数之和（换算成当前节点的） - 当前节点的扣分
|
value.setScore(Math.max(value.getTotal() - value.getTotalDeduct(), 0));
|
value.setNormalizedWeight(1.0f);
|
|
log.info("计算节点: {}，得分: {}", node, value.getScore());
|
}
|
});
|
}
|
|
/**
|
* 优化掉没有参与评分的节点
|
*/
|
private ScoreResult prune(ScoreResult scoreResult, int depth){
|
var root = TreeHelper.pruneTree(scoreResult.root(), (n) -> {
|
return n.getData().isInclude() || n.getDepth() == depth;
|
});
|
|
return new ScoreResult(root);
|
}
|
|
}
|
