package com.smtaiserver.smtaiserver.javaai.qwen.agent;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.Set;
|
import java.util.TreeMap;
|
import org.apache.commons.text.similarity.JaccardSimilarity;
|
import org.dom4j.Document;
|
import org.dom4j.Element;
|
import org.dom4j.Node;
|
|
import com.smtaiserver.smtaiserver.core.SMTAIServerApp;
|
import com.smtaiserver.smtaiserver.core.SMTAIServerRequest;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecord;
|
import com.smtaiserver.smtaiserver.javaai.SMTJavaAIError;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTCubeRecs;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTCubeRecs.ASTCubeRecsType;
|
import com.smtaiserver.smtaiserver.javaai.metrics.base.SMTDimensionDef;
|
import com.smtaiserver.smtaiserver.javaai.metrics.base.SMTMetricsDef;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTCubeRecsValue;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTDBMap;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTMergeResult;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTResult;
|
import com.smtaiserver.smtaiserver.javaai.llm.core.SMTLLMConnect;
|
import com.smtservlet.util.Json;
|
import com.smtservlet.util.SMTJsonWriter;
|
import com.smtservlet.util.SMTStatic;
|
|
public class SMTQwenAgentMetrics extends SMTQwenAgent
|
{
|
|
//////////////////////////////////////////////////////////////////
|
private boolean _questionToStep = false;
|
private String _promptVPROP;
|
private List<String> _metricsAlisList = new ArrayList<>();
|
private static Map<String, String[]> _mapGroupType2Match = new HashMap<>();
|
private static Map<String, String[]> _mapDiffType2Match = new HashMap<>();
|
|
static
|
{
|
_mapGroupType2Match.put("AVG", new String[]{"平均值", "平均", "AVG","sum","实时"});
|
_mapGroupType2Match.put("SUM", new String[]{"累计值", "累计", "SUM","sum","求和"});
|
_mapGroupType2Match.put("MAX", new String[]{"最大值", "最大", "MAX","max"});
|
_mapGroupType2Match.put("MIN", new String[]{"最小值", "MIN","min","最小"});
|
_mapGroupType2Match.put("COUNT", new String[]{"个数", "COUNT","count"});
|
|
_mapDiffType2Match.put("ADD", new String[]{"求和", "ADD","add","相加", "累计"});
|
_mapDiffType2Match.put("SUB", new String[]{"求差", "SUB","sub","相减", "差值"});
|
_mapDiffType2Match.put("YOY", new String[]{"同比", "YOY","yoy"});
|
_mapDiffType2Match.put("MOM", new String[]{"环比", "MOM","mom"});
|
}
|
|
@Override
|
public void initInstance(DBRecord rec) throws Exception
|
{
|
super.initInstance(rec);
|
|
try
|
{
|
Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + rec.getString("clz_arguments") + "</ROOT>");
|
Element xmlPrompt = (Element)doc.selectSingleNode("ROOT/PROMPT");
|
|
_questionToStep = "true".equals(SMTStatic.getXmlAttr(xmlPrompt, "question_to_step", "false"));
|
|
_promptVPROP = SMTStatic.trimStrLines(xmlPrompt.getText())
|
.replace("{{{DIM_NAME_LIST}}}", getDimNameList())
|
.replace("{{{METRICS_NAME_LIST}}}", getMetricsAliasList())
|
;
|
Node nodeMetricsAlias = doc.selectSingleNode("ROOT/METRICS_ALIAS");
|
if(nodeMetricsAlias != null)
|
{
|
String sMetricsAlias = SMTStatic.getXmlAttr((Element)nodeMetricsAlias, "names");
|
if(!SMTStatic.isNullOrEmpty(sMetricsAlias))
|
{
|
for(String s : sMetricsAlias.split(","))
|
{
|
_metricsAlisList.add(s);
|
}
|
}
|
}
|
}
|
catch(Exception ex)
|
{
|
throw new Exception("init mertic agent error : " + this._agentId, ex);
|
}
|
}
|
|
@Override
|
public SMTJavaAIError mergeASTList(List<Json> listASTSrc, List<Json> r_listASTTag)
|
{
|
StringBuilder sbQuestion = new StringBuilder();
|
for(Json jsonASTSrc : listASTSrc)
|
{
|
String question = jsonASTSrc.getJson("args").getJson("question").asString();
|
sbQuestion.append("问题:" + question + "\n");
|
}
|
|
Json jsonTag = Json.object(
|
"call", this.getAgentId(),
|
"args", Json.object(
|
"question", sbQuestion.toString()
|
)
|
);
|
|
r_listASTTag.add(jsonTag);
|
|
return null;
|
}
|
|
@Override
|
protected String getToolDesc(Element xmlTitle) throws Exception
|
{
|
String toolDesc = super.getToolDesc(xmlTitle);
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
if(mapId2Metrics.size() > 0)
|
{
|
toolDesc += "\n此操作包含以下指标:\n";
|
for(SMTMetricsDef metricsDef : mapId2Metrics.values())
|
{
|
toolDesc += " " + metricsDef.getTitle() + "\n";
|
}
|
}
|
return toolDesc;
|
}
|
|
private String getMetricsAliasList() throws Exception
|
{
|
Set<String> setAlias = new HashSet<>();
|
StringBuilder sbResult = new StringBuilder();
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
for(SMTMetricsDef metricsDef : mapId2Metrics.values())
|
{
|
metricsDef.addMetricsAliasToSet(setAlias);
|
}
|
|
for(String alias : setAlias)
|
{
|
sbResult.append(alias + "\n");
|
}
|
|
return sbResult.toString();
|
}
|
|
private String getDimNameList() throws Exception
|
{
|
Set<String> setExistDim = new HashSet<>();
|
StringBuilder sbResult = new StringBuilder();
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
for(SMTMetricsDef metricsDef : mapId2Metrics.values())
|
{
|
Map<String, SMTDimensionDef> mapId2DimDef = metricsDef.getDimensionMap();
|
if(mapId2DimDef == null)
|
continue;
|
|
for(SMTDimensionDef dimDef : mapId2DimDef.values())
|
{
|
if(setExistDim.contains(dimDef.getId()))
|
continue;
|
setExistDim.add(dimDef.getId());
|
sbResult.append(" " + dimDef.getId() + ":" + dimDef.getPrompt() + "\n");
|
}
|
}
|
|
return sbResult.toString();
|
}
|
|
public SMTJavaAIError callSupervisorJson(String agentId, String jsonPath, Json jsonSupervisorArg, Json jsonAST, SMTJsonWriter jsonWr, SMTAIServerRequest tranReq) throws Exception
|
{
|
tranReq.traceLLMDebug("callAgents：[\n" + SMTStatic.formatJson(jsonAST) + "\n]");
|
|
jsonWr.addKeyValue("answer_type", "summary");
|
jsonWr.beginArray("summary");
|
SMTJavaAIError aiError = queryRecordByAST(jsonPath, jsonAST.asJsonList(), tranReq);
|
jsonWr.endArray();
|
|
return aiError;
|
}
|
|
|
|
@Override
|
public SMTJavaAIError callAgents(String jsonPath, Json jsonArgs, SMTLLMConnect llm, String question, SMTAIServerRequest tranReq) throws Exception
|
{
|
long tick = System.currentTimeMillis();
|
|
// 如果发生要把问题变成步骤，调用大模型
|
if(_questionToStep)
|
{
|
tranReq.sendChunkedBlock("begin", "将问题拆解成步骤");
|
String promptToStep = (String)SMTAIServerApp.getApp().getGlobalConfig("prompt.question_to_step");
|
question = llm.callWithMessage(new String[] {promptToStep}, question, tranReq).replace("\r", "");
|
tranReq.traceLLMDebug("questionToStep:[\n" + question + "\n]");
|
tranReq.traceLLMPrompt(promptToStep);
|
tranReq.sendChunkedBlock("end", "拆解后的步骤是：" + question.replace("\r", "").replace("\n", " "));
|
}
|
|
String answer = llm.callWithMessage(new String[] {_promptVPROP}, question, tranReq).replace("\r", "");
|
Json jsonAST = SMTStatic.convLLMAnswerToJson(answer, true);
|
|
tranReq.appendCallFuncJson(jsonPath, jsonAST);
|
tranReq.traceLLMDebug("callAgents：[" + ((double)(System.currentTimeMillis() - tick) / 1000) + "秒] [\n" + SMTStatic.formatJson(jsonAST) + "\n]");
|
|
if(jsonAST.isObject())
|
{
|
String error = jsonAST.safeGetStr("error", "未知错误:" + jsonAST.toString());
|
return this.queryUnknowQuestion(error, llm, question, tranReq);
|
|
}
|
else if(!jsonAST.isArray())
|
{
|
String error = "未知错误:" + jsonAST.asString();
|
return this.queryUnknowQuestion(error, llm, question, tranReq);
|
}
|
|
return this.callAgentsByAST(jsonPath, jsonArgs, jsonAST, tranReq);
|
}
|
|
public SMTJavaAIError callAgentsByAST(String jsonPath, Json jsonArgs, Json jsonAST, SMTAIServerRequest tranReq) throws Exception
|
{
|
SMTJsonWriter jsonWrResult = tranReq.getResultJsonWr();
|
jsonWrResult.addKeyValue("answer_type", "summary");
|
jsonWrResult.beginArray("summary");
|
SMTJavaAIError aiError = queryRecordByAST(jsonPath, jsonAST.asJsonList(), tranReq);
|
jsonWrResult.endArray();
|
|
return aiError;
|
}
|
|
private SMTJavaAIError queryRecordByAST(String jsonPath, List<Json> jsonASTList, SMTAIServerRequest tranReq) throws Exception
|
{
|
SMTJsonWriter jsonWrResult = tranReq.getResultJsonWr();
|
|
ASTDBMap dbMap = new ASTDBMap();
|
try
|
{
|
ASTResult astResult = new ASTResult();
|
|
// 解析所有语法树
|
boolean existAST = false;
|
int count = jsonASTList.size();
|
for(int jsonIdx = 0; jsonIdx < count; jsonIdx ++)
|
{
|
Json jsonAST = jsonASTList.get(jsonIdx);
|
|
// 如果当前is_output = false
|
if(!jsonAST.getJson("args").safeGetBoolean("is_output", true))
|
{
|
// 如果已经存在执行器，则忽略
|
if(existAST)
|
continue;
|
|
// 如果当前执行器不是最后一个，则跳过
|
if(jsonIdx < (count -1))
|
continue;
|
}
|
|
|
existAST = true;
|
|
// 如果发现语法树报错，则直接返回错误
|
{
|
String error;
|
error = jsonAST.safeGetStr("error", null);
|
if(!SMTStatic.isNullOrEmpty(error))
|
return new SMTJavaAIError(error);
|
}
|
|
// 解析语法树
|
ASTResult curAstResult = new ASTResult();
|
SMTJavaAIError error = queryRecordAST2SQLTree("#" + SMTStatic.toString(jsonIdx) + "/", dbMap, jsonAST, null, tranReq, curAstResult);
|
if(error != null)
|
return error;
|
|
for(ASTCubeRecs cubeRecs : curAstResult._listRecordset)
|
{
|
astResult._listRecordset.add(cubeRecs);
|
}
|
}
|
|
ASTMergeResult mergeResult = new ASTMergeResult();
|
mergeResult.outputResultToJson(jsonPath, astResult, jsonWrResult);
|
//
|
// // 将生成的cube进行组合
|
// List<ASTMergeGroup> listMergeGroup = mergeASTResult(astResult);
|
//
|
// // 输出组合后的cube
|
// for(ASTMergeGroup mergeGroup : listMergeGroup)
|
// {
|
// mergeGroup.outputGroupToJson(jsonPath, jsonWr);
|
// }
|
}
|
finally
|
{
|
dbMap.close();
|
}
|
|
return null;
|
}
|
|
private SMTJavaAIError queryRecordAST2SQLTree(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
SMTJavaAIError aiError = null;
|
String call = jsonAST.getJson("call").asString();
|
Json jsonArgs = jsonAST.getJson("args");
|
|
|
if("query_metrics".equals(call))
|
{
|
aiError = call_query_metrics(jsonPath + "args/", dbMap, jsonArgs, extArg, tranReq, r_result);
|
}
|
else if("query_only_metrics".equals(call))
|
{
|
aiError = call_query_only_metrics(jsonPath + "args/", dbMap, jsonArgs, extArg, tranReq, r_result);
|
}
|
else if("agg_metrics".equals(call))
|
{
|
aiError = call_agg_metrics(jsonPath + "args/", dbMap, jsonArgs, extArg, tranReq, r_result);
|
}
|
else if("top_metrics".equals(call))
|
{
|
aiError = call_top_metrics(jsonPath + "args/", dbMap, jsonArgs, extArg, tranReq, r_result);
|
}
|
else if("diff_metrics".equals(call))
|
{
|
aiError = call_diff_metrics(jsonPath + "args/", dbMap, jsonArgs, extArg, tranReq, r_result);
|
}
|
else if("query_base_info".equals(call))
|
{
|
aiError = call_query_base_info(jsonPath + "args/", dbMap, jsonArgs, extArg, tranReq, r_result);
|
}
|
else
|
{
|
return new SMTJavaAIError("未知调用：" + call);
|
}
|
|
return aiError;
|
|
}
|
|
private SMTJavaAIError call_query_base_info(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
SMTJavaAIError error = null;
|
|
String metricsId = jsonAST.safeGetStr("metrics", null);
|
|
|
SMTMetricsDef metricsDef = null;
|
|
// 如果未配置指标，则取出第一个指标，且本配置只需要一个指标
|
if(SMTStatic.isNullOrEmpty(metricsId))
|
{
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
|
if(mapId2Metrics.size() != 1)
|
throw new Exception("call_query_base_info only one metrics : " + this.getAgentId());
|
|
for(SMTMetricsDef curMetricsDef : mapId2Metrics.values())
|
{
|
metricsDef = curMetricsDef;
|
break;
|
}
|
}
|
else
|
{
|
metricsDef = queryMetricsType(metricsId);
|
if(metricsDef == null)
|
return new SMTJavaAIError("未发现指标:" + metricsId);
|
}
|
|
if((error = metricsDef.queryMetrics(jsonPath, dbMap, jsonAST, extArg, tranReq, r_result)) != null)
|
return error;
|
|
return null;
|
}
|
|
private SMTJavaAIError call_diff_metrics(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
SMTJavaAIError error = null;
|
|
// 查询子结果集1
|
ASTResult childResult1 = new ASTResult();
|
error = queryRecordAST2SQLTree(jsonPath + "recordset1/", dbMap, jsonAST.getJson("recordset1"), extArg, tranReq, childResult1);
|
if(error != null)
|
return error;
|
|
// 查询子结果集2
|
ASTResult childResult2 = new ASTResult();
|
error = queryRecordAST2SQLTree(jsonPath + "recordset2/", dbMap, jsonAST.getJson("recordset2"), extArg, tranReq, childResult2);
|
if(error != null)
|
return error;
|
|
// 判断是否可以对比
|
if(childResult1._listRecordset.size() != 1 || childResult2._listRecordset.size() != 1)
|
return new SMTJavaAIError("查询出多个结果集无法对比");
|
|
ASTCubeRecs astCubeRecs1 = childResult1._listRecordset.get(0);
|
ASTCubeRecs astCubeRecs2 = childResult2._listRecordset.get(0);
|
if(astCubeRecs1._dimNames.size() > 0 || astCubeRecs2._dimNames.size() > 0)
|
return new SMTJavaAIError("查询多维度结果集无法对比");
|
|
// 获取对比方式
|
String userOperate = jsonAST.safeGetStr("operate", "");
|
if(SMTStatic.isNullOrEmpty(userOperate))
|
return new SMTJavaAIError("未指定对比方式");
|
String[] operate = matchGroupType(userOperate, _mapDiffType2Match);
|
if(operate == null)
|
return new SMTJavaAIError("对比方式" + userOperate + "不支持");
|
|
// 复制第一个结果集
|
List<ASTCubeRecs> listCubeRecs = new ArrayList<>();
|
for(ASTCubeRecs astResult : childResult1._listRecordset)
|
{
|
listCubeRecs.add(astResult.cloneCubeRecs());
|
}
|
|
// 附加第二个结果集
|
for(ASTCubeRecs astResult : childResult2._listRecordset)
|
{
|
listCubeRecs.add(astResult);
|
}
|
|
// 设置标题
|
astCubeRecs1._title += operate[1];
|
|
// 对比数据
|
if((error = astCubeRecs1._mapDimId2Recs.get(-1).diffValueRecords(operate[0], astCubeRecs2._mapDimId2Recs.get(-1))) != null)
|
return error;
|
|
astCubeRecs1._mapDimId2Recs.get(-1)._title += "和" + astCubeRecs2._mapDimId2Recs.get(-1)._title;
|
r_result._listRecordset.add(astCubeRecs1);
|
|
// 将原始曲线加入
|
for(ASTCubeRecs cubeRecs : listCubeRecs)
|
{
|
cubeRecs._isRawRS = true;
|
r_result._listRecordset.add(cubeRecs);
|
}
|
|
return null;
|
}
|
|
private SMTJavaAIError call_top_metrics(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
int limit = jsonAST.safeGetInt("limit", 5);
|
|
// 查询子结果集
|
SMTJavaAIError error = queryRecordAST2SQLTree(jsonPath + "recordset/", dbMap, jsonAST.getJson("recordset"), extArg, tranReq, r_result);
|
if(error != null)
|
return error;
|
|
for(ASTCubeRecs astRecs : r_result._listRecordset)
|
{
|
for(ASTCubeRecsValue astRecsValue : astRecs._mapDimId2Recs.values())
|
{
|
astRecsValue.limitRecords(limit);
|
}
|
}
|
|
return null;
|
}
|
|
private String[] matchGroupType(String operate, Map<String, String[]> mapGroupType2Match)
|
{
|
JaccardSimilarity jaccardSimilarity = new JaccardSimilarity();
|
|
String maxTitle = null;
|
String maxKey = null;
|
double maxMatch = 0;
|
for(Entry<String, String[]> entry : mapGroupType2Match.entrySet())
|
{
|
String curKey = entry.getKey();
|
for(String line : entry.getValue())
|
{
|
double curMatch = jaccardSimilarity.apply(line, operate);
|
if(curMatch == 1)
|
{
|
return new String[] {curKey, entry.getValue()[0]};
|
}
|
if(curMatch >= 0.8 && curMatch > maxMatch)
|
{
|
maxKey = curKey;
|
maxTitle = entry.getValue()[0];
|
maxMatch = curMatch;
|
}
|
}
|
}
|
|
if(maxKey == null)
|
return null;
|
|
return new String[] {maxKey, maxTitle};
|
}
|
|
private SMTJavaAIError call_agg_metrics(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
// 获取聚合操作
|
String[] operate = null;
|
String userOperate = jsonAST.safeGetStr("operate", "");
|
if(SMTStatic.isNullOrEmpty(userOperate))
|
{
|
operate = new String[]{"AVG", "平均"};
|
}
|
else
|
{
|
operate = matchGroupType(userOperate, _mapGroupType2Match);
|
if(operate == null)
|
{
|
operate = new String[]{"AVG", "平均"};
|
}
|
}
|
|
// 获取时间步长
|
String userStep = jsonAST.safeGetStr("step_time", "");
|
|
// 如果存在时间步长，且子操作是：query_metrics，则将其传递到子对象参数
|
boolean groupInQuery = false;
|
Json jsonRS = jsonAST.getJson("recordset");
|
String childCall = jsonRS.safeGetStr("call", "");
|
//if(!SMTStatic.isNullOrEmpty(userStep))
|
{
|
if("query_metrics".equals(childCall))
|
{
|
Json jsonRSArgs = jsonRS.getJson("args");
|
|
jsonRSArgs.set("step_op_key", operate[0]);
|
jsonRSArgs.set("step_op_title", operate[1]);
|
if(!SMTStatic.isNullOrEmpty(userStep))
|
{
|
jsonRSArgs.set("step_time_path", jsonPath + "step_time");
|
jsonRSArgs.set("step_time", userStep);
|
}
|
String stepDim = jsonAST.safeGetStr("dim_name", null);
|
if(!SMTStatic.isNullOrEmpty(stepDim))
|
jsonRSArgs.set("step_dim_name", stepDim);
|
groupInQuery = true;
|
}
|
|
}
|
|
// 如果存在分组，且子操作是query_base_info,则将其传递到子对象参数
|
if(operate != null && ("query_base_info".equals(childCall) || "query_only_metrics".equals(childCall)))
|
{
|
Json jsonRSArgs = jsonRS.getJson("args");
|
jsonRSArgs.set("step_op_key", operate[0]);
|
jsonRSArgs.set("step_op_title", operate[1]);
|
jsonRSArgs.set("step_time_path", jsonPath + "step_time");
|
String stepDim = jsonAST.safeGetStr("dim_name", null);
|
if(!SMTStatic.isNullOrEmpty(stepDim))
|
jsonRSArgs.set("step_dim_name", stepDim);
|
groupInQuery = true;
|
}
|
|
|
// 查询子结果集
|
SMTJavaAIError error = queryRecordAST2SQLTree(jsonPath + "recordset/", dbMap, jsonRS, null, tranReq, r_result);
|
if(error != null)
|
return error;
|
|
|
// 聚合操作
|
if(!groupInQuery)
|
{
|
for(ASTCubeRecs astRecs : r_result._listRecordset)
|
{
|
ASTCubeRecsType[] cubeRecsType = new ASTCubeRecsType[1];
|
for(ASTCubeRecsValue astRecsValue : astRecs._mapDimId2Recs.values())
|
{
|
String aggDimName = jsonAST.safeGetStr("dim_name", null);
|
if(!SMTStatic.isNullOrEmpty(aggDimName))
|
{
|
SMTDimensionDef dimDef = SMTAIServerApp.getApp().getDimensionDef(aggDimName);
|
astRecsValue._groupField = dimDef.getId();
|
astRecsValue._groupType = dimDef.getType();
|
}
|
|
cubeRecsType[0] = astRecs._recsType;
|
if((error = astRecsValue.groupValueRecords(operate[0], userStep, cubeRecsType, new String[][] {astRecs._colTitles})) != null)
|
return error;
|
astRecs._colTitles = new String[] {operate[1]};
|
if(cubeRecsType[0] == ASTCubeRecsType.SUMMARY)
|
astRecsValue._title += operate[1];
|
}
|
astRecs._recsType = cubeRecsType[0];
|
|
if(cubeRecsType[0] != ASTCubeRecsType.SUMMARY)
|
{
|
if(!SMTStatic.isNullOrEmpty(userStep))
|
{
|
int[] timeStep = SMTAIServerApp.convStrToTimeStep(userOperate);
|
astRecs._title += "每" + SMTAIServerApp.convTimeStepToStr(timeStep[0], timeStep[1]) + "的" + operate[1];
|
}
|
else
|
{
|
astRecs._title += operate[1];
|
}
|
}
|
}
|
}
|
|
return null;
|
}
|
|
private SMTJavaAIError call_query_metrics(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
// 获取指标对象
|
Object oMetrics = queryMetricsType(dbMap, jsonAST, tranReq);
|
if(oMetrics instanceof SMTJavaAIError)
|
return (SMTJavaAIError)oMetrics;
|
SMTMetricsDef matchMetrics = (SMTMetricsDef)oMetrics;
|
SMTJavaAIError error = matchMetrics.queryMetrics(jsonPath, dbMap, jsonAST, extArg, tranReq, r_result);
|
return error;
|
}
|
|
private SMTJavaAIError call_query_only_metrics(String jsonPath, ASTDBMap dbMap, Json jsonAST, Map<String, String> extArg, SMTAIServerRequest tranReq, ASTResult r_result) throws Exception
|
{
|
// 获取指标对象
|
SMTMetricsDef matchMetrics = null;
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
for(SMTMetricsDef curMatchMetrics : mapId2Metrics.values())
|
{
|
matchMetrics = curMatchMetrics;
|
break;
|
}
|
|
SMTJavaAIError error = matchMetrics.queryMetrics(jsonPath, dbMap, jsonAST, extArg, tranReq, r_result);
|
return error;
|
}
|
|
private Object queryMetricsType(ASTDBMap dbMap, Json jsonAST, SMTAIServerRequest tranReq) throws Exception
|
{
|
|
// 从参数中获取用户输入的指标类型
|
String metricsName = jsonAST.safeGetStr("metrics", "");
|
if(SMTStatic.isNullOrEmpty(metricsName))
|
{
|
for(String metricsAilas : _metricsAlisList)
|
{
|
metricsName = jsonAST.safeGetStr(metricsAilas, "");
|
if(!SMTStatic.isNullOrEmpty(metricsName))
|
{
|
SMTDimensionDef dimDef = SMTAIServerApp.getApp().getDimensionDef(metricsAilas);
|
if(dimDef == null)
|
continue;
|
JaccardSimilarity jaccardSimilarity = new JaccardSimilarity();
|
metricsName = dimDef.matchDimension(metricsName, jaccardSimilarity);
|
if(metricsName == null)
|
continue;
|
break;
|
}
|
}
|
|
if(SMTStatic.isNullOrEmpty(metricsName))
|
return new SMTJavaAIError("未解析出指标信息");
|
}
|
|
SMTMetricsDef metricsDef = queryMetricsType(metricsName);
|
if(metricsDef != null)
|
return metricsDef;
|
|
if(metricsName.startsWith("监测") && jsonAST.has("device"))
|
{
|
metricsName = jsonAST.getJson("device").asString() + jsonAST.safeGetStr("metrics", "");
|
metricsDef = queryMetricsType(metricsName);
|
}
|
|
if(metricsDef != null)
|
return metricsDef;
|
|
return new SMTJavaAIError("未找到匹配的指标:" + metricsName);
|
}
|
|
|
private SMTMetricsDef queryMetricsType(String metricsName) throws Exception
|
{
|
double minSimValue = SMTStatic.toDouble(SMTAIServerApp.getApp().getGlobalConfig("history.math.ratio"));
|
|
// 匹配指标定义
|
double maxSim = 0;
|
SMTMetricsDef matchMetrics = null;
|
TreeMap<Double, SMTMetricsDef> mapSim2Metrics = new TreeMap<>();
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
JaccardSimilarity jaccardSimilarity = new JaccardSimilarity();
|
for(SMTMetricsDef metricsDef : mapId2Metrics.values())
|
{
|
double curSim = metricsDef.matchMetrics(metricsName, jaccardSimilarity);
|
if(curSim == 1)
|
{
|
maxSim = 1;
|
matchMetrics = metricsDef;
|
break;
|
}
|
else if(curSim >= minSimValue)
|
{
|
if(maxSim <= curSim)
|
{
|
maxSim = curSim;
|
matchMetrics = metricsDef;
|
}
|
}
|
|
mapSim2Metrics.put(curSim, metricsDef);
|
}
|
|
if(maxSim < minSimValue)
|
return null;
|
|
return matchMetrics;
|
}
|
|
@Override
|
public void queryUnknowQuestionList(String keyword, SMTAIServerRequest tranReq) throws Exception
|
{
|
Map<String, SMTMetricsDef> mapId2Metrics = SMTAIServerApp.getApp().getMetricsMap(this.getAgentId());
|
JaccardSimilarity jaccardSimilarity = new JaccardSimilarity();
|
for(SMTMetricsDef metricsDef : mapId2Metrics.values())
|
{
|
metricsDef.queryUnknowQuestionList(jaccardSimilarity, keyword, tranReq);
|
}
|
}
|
}
|
