From ab9c953ee4827e9f6b61415b66bda034de744ad9 Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 11:30:52 +0800 Subject: [PATCH 1/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91=EF=BC=8C=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../TextClassificationController.java | 62 ++++++ .../TextClassificationInsController.java | 59 ++++++ .../platform/domain/TextClassification.java | 50 +++++ .../domain/TextClassificationIns.java | 41 ++++ .../mapper/TextClassificationDao.java | 23 +++ .../mapper/TextClassificationInsDao.java | 23 +++ .../service/TextClassificationInsService.java | 26 +++ .../service/TextClassificationService.java | 21 ++ .../impl/ActiveLearnInsServiceImpl.java | 8 +- .../service/impl/ActiveLearnServiceImpl.java | 6 +- .../service/impl/AutoMlInsServiceImpl.java | 12 +- .../service/impl/AutoMlServiceImpl.java | 12 +- .../service/impl/CodeConfigServiceImpl.java | 8 +- .../service/impl/ComponentServiceImpl.java | 4 +- .../service/impl/DatasetServiceImpl.java | 2 +- .../impl/DatasetVersionServiceImpl.java | 2 +- .../impl/ExperimentInsServiceImpl.java | 10 +- .../service/impl/ExperimentServiceImpl.java | 4 +- .../platform/service/impl/GitServiceImpl.java | 2 +- .../service/impl/ImageServiceImpl.java | 12 +- .../service/impl/ImageVersionServiceImpl.java | 12 +- .../service/impl/ModelsServiceImpl.java | 22 +-- .../impl/ModelsVersionServiceImpl.java | 2 +- .../service/impl/NewDatasetServiceImpl.java | 20 +- .../service/impl/RayInsServiceImpl.java | 8 +- .../platform/service/impl/RayServiceImpl.java | 7 +- .../service/impl/ServiceServiceImpl.java | 2 +- .../impl/TextClassificationServiceImpl.java | 179 ++++++++++++++++++ .../service/impl/WorkflowServiceImpl.java | 2 +- .../vo/TextClassificationParamVo.java | 31 +++ .../platform/vo/TextClassificationVo.java | 51 +++++ .../mapper/managementPlatform/AutoMlDao.xml | 5 +- .../TextClassificationDaoMapper.xml | 87 +++++++++ .../TextClassificationInsDaoMapper.xml | 85 +++++++++ 34 files changed, 816 insertions(+), 84 deletions(-) create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationInsController.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassificationIns.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationDao.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationInsDao.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java create mode 100644 ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml create mode 100644 ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java new file mode 100644 index 00000000..4d643e80 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java @@ -0,0 +1,62 @@ +package com.ruoyi.platform.controller.textClassfication; + +import com.ruoyi.common.core.web.controller.BaseController; +import com.ruoyi.common.core.web.domain.GenericsAjaxResult; +import com.ruoyi.platform.domain.TextClassification; +import com.ruoyi.platform.service.TextClassificationService; +import com.ruoyi.platform.vo.TextClassificationVo; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.web.bind.annotation.*; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +import javax.annotation.Resource; +import java.io.IOException; + +@RestController +@RequestMapping("textClassification") +@Api("文本分类") +public class TextClassificationController extends BaseController { + @Resource + private TextClassificationService textClassificationService; + + @GetMapping + @ApiOperation("分页查询") + public GenericsAjaxResult> queryByPage(@RequestParam("page") int page, + @RequestParam("size") int size, + @RequestParam(value = "name", required = false) String name){ + PageRequest pageRequest = PageRequest.of(page, size); + return genericsSuccess(this.textClassificationService.queryByPage(name, pageRequest)); + } + + @PostMapping + @ApiOperation("新增文本分类") + public GenericsAjaxResult add(@RequestBody TextClassificationVo textClassificationVo) throws Exception { + return genericsSuccess(this.textClassificationService.save(textClassificationVo)); + } + + @PutMapping + @ApiOperation("编辑文本分类") + public GenericsAjaxResult edit(@RequestBody TextClassificationVo textClassificationVo) throws Exception { + return genericsSuccess(this.textClassificationService.edit(textClassificationVo)); + } + + @GetMapping("/getTextClassificationDetail") + @ApiOperation("获取文本分类详细信息") + public GenericsAjaxResult getTextClassificationDetail(@RequestParam("id") Long id)throws IOException { + return genericsSuccess(this.textClassificationService.getTextClassificationDetail(id)); + } + + @DeleteMapping("{id}") + @ApiOperation("删除文本分类") + public GenericsAjaxResult deleteTextClassification(@PathVariable("id") Long id){ + return genericsSuccess(this.textClassificationService.delete(id)); + } + + @PostMapping("/run/{id}") + @ApiOperation("运行文本分类") + public GenericsAjaxResult runTextClassification(@PathVariable("id") Long id) throws Exception { + return genericsSuccess(this.textClassificationService.runTextClassificationIns(id)); + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationInsController.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationInsController.java new file mode 100644 index 00000000..9c6c7692 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationInsController.java @@ -0,0 +1,59 @@ +package com.ruoyi.platform.controller.textClassfication; + +import com.ruoyi.common.core.web.controller.BaseController; +import com.ruoyi.common.core.web.domain.GenericsAjaxResult; +import com.ruoyi.platform.domain.TextClassificationIns; +import com.ruoyi.platform.service.TextClassificationInsService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.web.bind.annotation.*; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +import javax.annotation.Resource; +import java.util.List; + +@RestController +@RequestMapping("textClassificationIns") +@Api("文本分类实验实例") +public class TextClassificationInsController extends BaseController { + @Resource + private TextClassificationInsService textClassificationInsService; + + @GetMapping + @ApiOperation("分页查询") + public GenericsAjaxResult> queryByPage(TextClassificationIns textClassificationIns, int page, int size){ + PageRequest pageRequest = PageRequest.of(page, size); + return genericsSuccess(this.textClassificationInsService.queryByPage(textClassificationIns, pageRequest)); + } + + @PostMapping + @ApiOperation("新增实验实例") + public GenericsAjaxResult add(@RequestBody TextClassificationIns textClassificationIns) { + return genericsSuccess(this.textClassificationInsService.insert(textClassificationIns)); + } + + @DeleteMapping("{id}") + @ApiOperation("删除实验实例") + public GenericsAjaxResult deleteById(@PathVariable("id") Long id) { + return genericsSuccess(this.textClassificationInsService.removeById(id)); + } + + @DeleteMapping("batchDelete") + @ApiOperation("批量删除实验实例") + public GenericsAjaxResult batchDelete(@RequestBody List ids) { + return genericsSuccess(this.textClassificationInsService.batchDelete(ids)); + } + + @PutMapping("{id}") + @ApiOperation("终止实验实例") + public GenericsAjaxResult terminateTextClassificationIns(@PathVariable("id") Long id) throws Exception { + return genericsSuccess(this.textClassificationInsService.terminateTextClassificationIns(id)); + } + + @GetMapping("{id}") + @ApiOperation("查看实验实例详情") + public GenericsAjaxResult getDetailById(@PathVariable("id") Long id) { + return genericsSuccess(this.textClassificationInsService.getDetailById(id)); + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java new file mode 100644 index 00000000..f6a239c5 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java @@ -0,0 +1,50 @@ +package com.ruoyi.platform.domain; + +import com.fasterxml.jackson.databind.PropertyNamingStrategy; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.Date; + +@Data +@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class) +@ApiModel(description = "文本分类") +public class TextClassification { + private Long id; + + @ApiModelProperty(value = "实验名称") + private String name; + + @ApiModelProperty(value = "实验描述") + private String description; + + @ApiModelProperty(value = "模型") + private String model; + + @ApiModelProperty(value = "数据集") + private String dataset; + + @ApiModelProperty(value = "epochs") + private Integer epochs; + + @ApiModelProperty(value = "batch_size") + private Integer batchSize; + + @ApiModelProperty(value = "学习率") + private Float lr; + + private String createBy; + + private String updateBy; + + private Date createTime; + + private Date updateTime; + + private Integer state; + + @ApiModelProperty(value = "状态列表") + private String statusList; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassificationIns.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassificationIns.java new file mode 100644 index 00000000..09c43f25 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassificationIns.java @@ -0,0 +1,41 @@ +package com.ruoyi.platform.domain; + +import com.fasterxml.jackson.databind.PropertyNamingStrategy; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import io.swagger.annotations.ApiModel; +import lombok.Data; + +import java.util.Date; + +@Data +@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class) +@ApiModel(description = "文本分类实验实例") +public class TextClassificationIns { + private Long id; + + private Long textClassificationId; + + private Integer state; + + private String status; + + private String param; + + private Date createTime; + + private Date updateTime; + + private Date finishTime; + + private String argoInsName; + + private String argoInsNs; + + private String resultPath; + + private String ModelPath; + + private String nodeStatus; + + private String nodeResult; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationDao.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationDao.java new file mode 100644 index 00000000..f69f248b --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationDao.java @@ -0,0 +1,23 @@ +package com.ruoyi.platform.mapper; + +import com.ruoyi.platform.domain.TextClassification; +import org.apache.ibatis.annotations.Param; +import org.springframework.data.domain.Pageable; + +import java.util.List; + +public interface TextClassificationDao { + long count(@Param("name") String name); + + List queryByPage(@Param("name") String name, @Param("pageable") Pageable pageable); + + TextClassification getByName(@Param("name") String name); + + TextClassification getById(@Param("id") Long id); + + int save(@Param("textClassification") TextClassification textClassification); + + int edit(@Param("textClassification") TextClassification textClassification); + + List queryByDatasetId(@Param("datasetId") String datasetId); +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationInsDao.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationInsDao.java new file mode 100644 index 00000000..3bc16cd2 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/TextClassificationInsDao.java @@ -0,0 +1,23 @@ +package com.ruoyi.platform.mapper; + +import com.ruoyi.platform.domain.TextClassificationIns; +import org.apache.ibatis.annotations.Param; +import org.springframework.data.domain.Pageable; + +import java.util.List; + +public interface TextClassificationInsDao { + long count(@Param("textClassificationIns") TextClassificationIns textClassificationIns); + + List queryAllByLimit(@Param("textClassificationIns") TextClassificationIns textClassificationIns, @Param("pageable") Pageable pageable); + + List getByTextClassificationId(@Param("textClassificationId") Long textClassificationId); + + TextClassificationIns queryById(@Param("id") Long id); + + int insert(@Param("textClassificationIns") TextClassificationIns textClassificationIns); + + int update(@Param("textClassificationIns") TextClassificationIns textClassificationIns); + + List queryByNotTerminated(); +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java new file mode 100644 index 00000000..d14c3a51 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java @@ -0,0 +1,26 @@ +package com.ruoyi.platform.service; +import com.ruoyi.platform.domain.TextClassificationIns; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +import java.util.List; + +public interface TextClassificationInsService { + Page queryByPage(TextClassificationIns textClassificationIns, PageRequest pageRequest); + + TextClassificationIns insert(TextClassificationIns textClassificationIns); + + String removeById(Long id); + + String batchDelete(List ids); + + boolean terminateTextClassificationIns(Long id) throws Exception; + + TextClassificationIns getDetailById(Long id); + + List queryByNotTerminated(); + + TextClassificationIns queryStatusFromArgo(TextClassificationIns textClassificationIns); + + void updateTextClassificationStatus(Long textClassificationId); +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java new file mode 100644 index 00000000..fffa57de --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java @@ -0,0 +1,21 @@ +package com.ruoyi.platform.service; +import com.ruoyi.platform.domain.TextClassification; +import com.ruoyi.platform.vo.TextClassificationVo; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +import java.io.IOException; + +public interface TextClassificationService { + Page queryByPage(String name, PageRequest pageRequest); + + TextClassification save(TextClassificationVo textClassificationVo) throws Exception; + + String edit(TextClassificationVo textClassificationVo) throws Exception; + + String delete(Long id); + + TextClassificationVo getTextClassificationDetail(Long id) throws IOException; + + String runTextClassificationIns(Long id) throws Exception; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnInsServiceImpl.java index ca35a866..60cb3868 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnInsServiceImpl.java @@ -126,7 +126,7 @@ public class ActiveLearnInsServiceImpl implements ActiveLearnInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowTermination, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (StringUtils.isEmpty(req)) { - throw new RuntimeException("终止响应内容为空。"); + throw new RuntimeException("终止响应内容为空"); } // 将响应的JSON字符串转换为Map对象 @@ -214,19 +214,19 @@ public class ActiveLearnInsServiceImpl implements ActiveLearnInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowStatus, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (req == null || StringUtils.isEmpty(req)) { - throw new RuntimeException("工作流状态响应为空。"); + throw new RuntimeException("工作流状态响应为空"); } // 将响应的JSON字符串转换为Map对象 Map runResMap = JsonUtils.jsonToMap(req); // 从响应Map中获取"data"部分 Map data = (Map) runResMap.get("data"); if (data == null || data.isEmpty()) { - throw new RuntimeException("工作流数据为空."); + throw new RuntimeException("工作流数据为空"); } // 从"data"中获取"status"部分，并返回"phase"的值 Map status = (Map) data.get("status"); if (status == null || status.isEmpty()) { - throw new RuntimeException("工作流状态为空。"); + throw new RuntimeException("工作流状态为空"); } //解析流水线结束时间 diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnServiceImpl.java index a1f2f93b..04b3809a 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ActiveLearnServiceImpl.java @@ -60,13 +60,13 @@ public class ActiveLearnServiceImpl implements ActiveLearnService { @Override public ActiveLearn save(ActiveLearnVo activeLearnVo) throws Exception { + if (activeLearnVo.getName().length() >= 64) { + throw new RuntimeException("实验名称大于最大长度"); + } ActiveLearn activeLearnByName = activeLearnDao.getActiveLearnByName(activeLearnVo.getName()); if (activeLearnByName != null) { throw new RuntimeException("实验名称已存在"); } - if (activeLearnVo.getName().length() >= 64) { - throw new RuntimeException("实验名称大于最大长度"); - } ActiveLearn activeLearn = new ActiveLearn(); BeanUtils.copyProperties(activeLearnVo, activeLearn); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlInsServiceImpl.java index 2fbceeea..1294d426 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlInsServiceImpl.java @@ -108,19 +108,19 @@ public class AutoMlInsServiceImpl implements AutoMlInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowStatus, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (req == null || StringUtils.isEmpty(req)) { - throw new RuntimeException("工作流状态响应为空。"); + throw new RuntimeException("工作流状态响应为空"); } // 将响应的JSON字符串转换为Map对象 Map runResMap = JsonUtils.jsonToMap(req); // 从响应Map中获取"data"部分 Map data = (Map) runResMap.get("data"); if (data == null || data.isEmpty()) { - throw new RuntimeException("工作流数据为空."); + throw new RuntimeException("工作流数据为空"); } // 从"data"中获取"status"部分，并返回"phase"的值 Map status = (Map) data.get("status"); if (status == null || status.isEmpty()) { - throw new RuntimeException("工作流状态为空。"); + throw new RuntimeException("工作流状态为空"); } //解析流水线结束时间 @@ -190,7 +190,7 @@ public class AutoMlInsServiceImpl implements AutoMlInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowTermination, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (StringUtils.isEmpty(req)) { - throw new RuntimeException("终止响应内容为空。"); + throw new RuntimeException("终止响应内容为空"); } // 将响应的JSON字符串转换为Map对象 @@ -211,8 +211,8 @@ public class AutoMlInsServiceImpl implements AutoMlInsService { if (innerMap.containsKey("phase")) { String phaseValue = (String) innerMap.get("phase"); // 如果值不等于 Succeeded，则赋值为 Failed - if (!StringUtils.equals("Succeeded", phaseValue)) { - innerMap.put("phase", "Failed"); + if (!StringUtils.equals(Constant.Succeeded, phaseValue)) { + innerMap.put("phase", Constant.Failed); } } } diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlServiceImpl.java index bff62c3c..99354424 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/AutoMlServiceImpl.java @@ -66,15 +66,13 @@ public class AutoMlServiceImpl implements AutoMlService { @Override public AutoMl save(AutoMlVo autoMlVo) throws Exception { + if (autoMlVo.getMlName().length() >= 64) { + throw new RuntimeException("实验名称大于最大长度"); + } AutoMl autoMlByName = autoMlDao.getAutoMlByName(autoMlVo.getMlName()); if (autoMlByName != null) { throw new RuntimeException("实验名称已存在"); } - - if (autoMlVo.getMlName().length() >= 64) { - throw new RuntimeException("实验名称大于最大长度"); - } - AutoMl autoMl = new AutoMl(); BeanUtils.copyProperties(autoMlVo, autoMl); String username = SecurityUtils.getLoginUser().getUsername(); @@ -178,13 +176,13 @@ public class AutoMlServiceImpl implements AutoMlService { String runRes = HttpUtils.sendPost(argoUrl + argoWorkflowRun, JsonUtils.mapToJson(runReqMap)); if (runRes == null || StringUtils.isEmpty(runRes)) { - throw new RuntimeException("Failed to run workflow."); + throw new RuntimeException("运行流水线失败"); } Map runResMap = JsonUtils.jsonToMap(runRes); Map data = (Map) runResMap.get("data"); //判断data为空 if (data == null || MapUtils.isEmpty(data)) { - throw new RuntimeException("Failed to run workflow."); + throw new RuntimeException("运行流水线失败"); } Map metadata = (Map) data.get("metadata"); // 插入记录到实验实例表 diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/CodeConfigServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/CodeConfigServiceImpl.java index 8c4f02f3..872b34b9 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/CodeConfigServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/CodeConfigServiceImpl.java @@ -94,7 +94,7 @@ public class CodeConfigServiceImpl implements CodeConfigService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(id, Constant.Asset_Type_Code, null); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该代码配置被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该代码配置被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap map = new HashMap<>(); @@ -102,19 +102,19 @@ public class CodeConfigServiceImpl implements CodeConfigService { List rayList = rayDao.queryByCodeConfig(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - throw new Exception("该代码配置被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + throw new Exception("该代码配置被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByCodeConfig(JSON.toJSONString(map)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - throw new Exception("该代码配置被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + throw new Exception("该代码配置被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List serviceVersionList = serviceDao.queryByCodeConfig(JSON.toJSONString(map)); if (serviceVersionList != null && !serviceVersionList.isEmpty()) { String serviceVersions = String.join(",", serviceVersionList.stream().collect(Collectors.toSet())); - throw new Exception("该代码配置被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本。"); + throw new Exception("该代码配置被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本"); } LoginUser loginUser = SecurityUtils.getLoginUser(); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ComponentServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ComponentServiceImpl.java index 47b05f0d..a93628e3 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ComponentServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ComponentServiceImpl.java @@ -121,7 +121,7 @@ public class ComponentServiceImpl implements ComponentService { Integer existingCount = this.componentDao.countByNameAndCategoryId(component.getComponentName(),component.getCategoryId()); if(existingCount != null && existingCount > 0) { - throw new RuntimeException("该类别下已有同名组件。"); + throw new RuntimeException("该类别下已有同名组件"); } this.componentDao.insert(component); @@ -140,7 +140,7 @@ public class ComponentServiceImpl implements ComponentService { //只能更新当前存在的组件 if (component == null){ - throw new RuntimeException("组件不存在，无法更新。"); + throw new RuntimeException("组件不存在，无法更新"); } //将object转成string类型 diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetServiceImpl.java index a08d3db4..ba3f35e8 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetServiceImpl.java @@ -147,7 +147,7 @@ public class DatasetServiceImpl implements DatasetService { public Dataset update(Dataset dataset) { int currentState = dataset.getState(); if (currentState == 0) { - throw new RuntimeException("数据集已被删除，无法更新。"); + throw new RuntimeException("数据集已被删除，无法更新"); } LoginUser loginUser = SecurityUtils.getLoginUser(); dataset.setUpdateBy(loginUser.getUsername()); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetVersionServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetVersionServiceImpl.java index 61d61031..d4e99abc 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetVersionServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/DatasetVersionServiceImpl.java @@ -101,7 +101,7 @@ public class DatasetVersionServiceImpl implements DatasetVersionService { public DatasetVersion update(DatasetVersion datasetVersion) { int currentState = datasetVersion.getState(); if (currentState == 0){ - throw new RuntimeException("数据集版本已被删除，无法更新。"); + throw new RuntimeException("数据集版本已被删除，无法更新"); } LoginUser loginUser = SecurityUtils.getLoginUser(); datasetVersion.setUpdateBy(loginUser.getUsername()); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentInsServiceImpl.java index 33f2d338..b58e449b 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentInsServiceImpl.java @@ -285,7 +285,7 @@ public class ExperimentInsServiceImpl implements ExperimentInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowStatus, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (req == null || StringUtils.isEmpty(req)) { - throw new RuntimeException("工作流状态响应为空。"); + throw new RuntimeException("工作流状态响应为空"); } // 将响应的JSON字符串转换为Map对象 @@ -293,12 +293,12 @@ public class ExperimentInsServiceImpl implements ExperimentInsService { // 从响应Map中获取"data"部分 Map data = (Map) runResMap.get("data"); if (data == null || data.isEmpty()) { - throw new RuntimeException("工作流数据为空."); + throw new RuntimeException("工作流数据为空"); } // 从"data"中获取"status"部分，并返回"phase"的值 Map status = (Map) data.get("status"); if (status == null || status.isEmpty()) { - throw new RuntimeException("工作流状态为空。"); + throw new RuntimeException("工作流状态为空"); } //解析流水线结束时间 @@ -379,7 +379,7 @@ public class ExperimentInsServiceImpl implements ExperimentInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowTermination, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (StringUtils.isEmpty(req)) { - throw new RuntimeException("终止响应内容为空。"); + throw new RuntimeException("终止响应内容为空"); } // 将响应的JSON字符串转换为Map对象 @@ -509,7 +509,7 @@ public class ExperimentInsServiceImpl implements ExperimentInsService { // 从响应Map中获取"data"的值,也就是日志的值 String experimentInsLog = (String) runResMap.get("data"); if (experimentInsLog == null) { - throw new RuntimeException("日志为空。"); + throw new RuntimeException("日志为空"); } //返回日志内容 return experimentInsLog; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentServiceImpl.java index 0a6b2bc7..96193527 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ExperimentServiceImpl.java @@ -264,13 +264,13 @@ public class ExperimentServiceImpl implements ExperimentService { String runRes = HttpUtils.sendPost(argoUrl + argoWorkflowRun, JsonUtils.mapToJson(runReqMap)); if (runRes == null || StringUtils.isEmpty(runRes)) { - throw new RuntimeException("Failed to run workflow."); + throw new RuntimeException("运行流水线失败"); } Map runResMap = JsonUtils.jsonToMap(runRes); Map data = (Map) runResMap.get("data"); //判断data为空 if (data == null || MapUtils.isEmpty(data)) { - throw new RuntimeException("Failed to run workflow."); + throw new RuntimeException("运行流水线失败"); } diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/GitServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/GitServiceImpl.java index 60f62afe..684d8069 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/GitServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/GitServiceImpl.java @@ -140,7 +140,7 @@ public class GitServiceImpl implements GitService { String req = httpUtils.sendGetWithToken(gitendpoint + "/api/v1/" + owner + "/" + projectName + "/branches/all.json", null, token); // 解析响应JSON if (StringUtils.isEmpty(req)) { - throw new RuntimeException("终止响应内容为空。"); + throw new RuntimeException("终止响应内容为空"); } // 将响应的JSON字符串转换为List对象 List> mapList = JacksonUtil.parseJSONStr2MapList(req); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageServiceImpl.java index fb7f66f5..0c52a9bb 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageServiceImpl.java @@ -144,7 +144,7 @@ public class ImageServiceImpl implements ImageService { public Image update(Image image) { int currentState = image.getState(); if (currentState == 0) { - throw new RuntimeException("镜像已被删除，无法更新。"); + throw new RuntimeException("镜像已被删除，无法更新"); } LoginUser loginUser = SecurityUtils.getLoginUser(); image.setUpdateBy(loginUser.getUsername()); @@ -175,7 +175,7 @@ public class ImageServiceImpl implements ImageService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(id), Constant.Asset_Type_Image, null); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该镜像被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该镜像被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap map = new HashMap<>(); @@ -183,25 +183,25 @@ public class ImageServiceImpl implements ImageService { List rayList = rayDao.queryByImageId(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - throw new Exception("该镜像被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + throw new Exception("该镜像被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByImageId(JSON.toJSONString(map)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - throw new Exception("该镜像被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + throw new Exception("该镜像被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List devEnvironmentList = devEnvironmentDao.queryByImageId(JSON.toJSONString(map)); if (devEnvironmentList != null && !devEnvironmentList.isEmpty()) { String devEnvironments = String.join(",", devEnvironmentList.stream().map(DevEnvironment::getName).collect(Collectors.toSet())); - throw new Exception("该镜像被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境。"); + throw new Exception("该镜像被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境"); } List serviceVersionList = serviceDao.queryByImageId(JSON.toJSONString(map)); if (serviceVersionList != null && !serviceVersionList.isEmpty()) { String serviceVersions = String.join(",", serviceVersionList.stream().collect(Collectors.toSet())); - throw new Exception("该镜像被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本。"); + throw new Exception("该镜像被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本"); } //判断权限，只有admin和创建者本身可以删除该数据集 diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageVersionServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageVersionServiceImpl.java index 2f35c63d..7205a225 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageVersionServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ImageVersionServiceImpl.java @@ -86,7 +86,7 @@ public class ImageVersionServiceImpl implements ImageVersionService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(imageVersion.getImageId()), Constant.Asset_Type_Image, imageVersion.getTagName()); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - return GenericsAjaxResult.error("该镜像版本被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + return GenericsAjaxResult.error("该镜像版本被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap map = new HashMap<>(); @@ -94,25 +94,25 @@ public class ImageVersionServiceImpl implements ImageVersionService { List rayList = rayDao.queryByImageId(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - return GenericsAjaxResult.error("该镜像版本被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + return GenericsAjaxResult.error("该镜像版本被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByImageId(JSON.toJSONString(map)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - return GenericsAjaxResult.error("该镜像版本被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + return GenericsAjaxResult.error("该镜像版本被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List devEnvironmentList = devEnvironmentDao.queryByImageId(JSON.toJSONString(map)); if (devEnvironmentList != null && !devEnvironmentList.isEmpty()) { String devEnvironments = String.join(",", devEnvironmentList.stream().map(DevEnvironment::getName).collect(Collectors.toSet())); - throw new Exception("该镜像版本被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境。"); + throw new Exception("该镜像版本被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境"); } List serviceVersionList = serviceDao.queryByImageId(JSON.toJSONString(map)); if (serviceVersionList != null && !serviceVersionList.isEmpty()) { String serviceVersions = String.join(",", serviceVersionList.stream().collect(Collectors.toSet())); - throw new Exception("该镜像版本被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本。"); + throw new Exception("该镜像版本被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本"); } //判断权限，只有admin和创建者本身可以删除该数据集 @@ -156,7 +156,7 @@ public class ImageVersionServiceImpl implements ImageVersionService { public ImageVersion update(ImageVersion imageVersion) { int currentState = imageVersion.getState(); if (currentState == 0) { - throw new RuntimeException("镜像版本已被删除，无法更新。"); + throw new RuntimeException("镜像版本已被删除，无法更新"); } LoginUser loginUser = SecurityUtils.getLoginUser(); imageVersion.setUpdateBy(loginUser.getUsername()); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsServiceImpl.java index c6c9ae0e..71f02654 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsServiceImpl.java @@ -190,7 +190,7 @@ public class ModelsServiceImpl implements ModelsService { public Models update(Models models) { int currentState = models.getState(); if (currentState == 0) { - throw new RuntimeException("模型已被删除，无法更新。"); + throw new RuntimeException("模型已被删除，无法更新"); } LoginUser loginUser = SecurityUtils.getLoginUser(); models.setUpdateBy(loginUser.getUsername()); @@ -1161,7 +1161,7 @@ public class ModelsServiceImpl implements ModelsService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(repoId), Constant.Asset_Type_Model, null); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该模型被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该模型被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap queryMap = new HashMap<>(); @@ -1169,25 +1169,25 @@ public class ModelsServiceImpl implements ModelsService { List rayList = rayDao.queryByModelId(JSON.toJSONString(queryMap)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - throw new Exception("该模型被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + throw new Exception("该模型被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByModelId(JSON.toJSONString(queryMap)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - throw new Exception("该模型被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + throw new Exception("该模型被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List devEnvironmentList = devEnvironmentDao.queryByModelId(JSON.toJSONString(queryMap)); if (devEnvironmentList != null && !devEnvironmentList.isEmpty()) { String devEnvironments = String.join(",", devEnvironmentList.stream().map(DevEnvironment::getName).collect(Collectors.toSet())); - throw new Exception("该模型被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境。"); + throw new Exception("该模型被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境"); } List serviceVersionList = serviceDao.queryByModelId(JSON.toJSONString(queryMap)); if (serviceVersionList != null && !serviceVersionList.isEmpty()) { String serviceVersions = String.join(",", serviceVersionList.stream().collect(Collectors.toSet())); - throw new Exception("该模型被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本。"); + throw new Exception("该模型被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本"); } String token = gitService.checkoutToken(); @@ -1210,7 +1210,7 @@ public class ModelsServiceImpl implements ModelsService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(repoId), Constant.Asset_Type_Model, version); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该模型版本被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该模型版本被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap queryMap = new HashMap<>(); @@ -1219,25 +1219,25 @@ public class ModelsServiceImpl implements ModelsService { List rayList = rayDao.queryByModelId(JSON.toJSONString(queryMap)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - throw new Exception("该模型版本被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + throw new Exception("该模型版本被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByModelId(JSON.toJSONString(queryMap)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - throw new Exception("该模型版本被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + throw new Exception("该模型版本被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List devEnvironmentList = devEnvironmentDao.queryByModelId(JSON.toJSONString(queryMap)); if (devEnvironmentList != null && !devEnvironmentList.isEmpty()) { String devEnvironments = String.join(",", devEnvironmentList.stream().map(DevEnvironment::getName).collect(Collectors.toSet())); - throw new Exception("该模型版本被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境。"); + throw new Exception("该模型版本被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境"); } List serviceVersionList = serviceDao.queryByModelId(JSON.toJSONString(queryMap)); if (serviceVersionList != null && !serviceVersionList.isEmpty()) { String serviceVersions = String.join(",", serviceVersionList.stream().collect(Collectors.toSet())); - throw new Exception("该模型版本被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本。"); + throw new Exception("该模型版本被服务版本：" + serviceVersions + "使用，不能删除，请先删除服务版本"); } String token = gitService.checkoutToken(); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsVersionServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsVersionServiceImpl.java index 274b3c1d..24a6b636 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsVersionServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ModelsVersionServiceImpl.java @@ -99,7 +99,7 @@ public class ModelsVersionServiceImpl implements ModelsVersionService { public ModelsVersion update(ModelsVersion modelsVersion) { int currentState = modelsVersion.getState(); if(currentState == 0){ - throw new RuntimeException("模型版本已被删除，无法更新。"); + throw new RuntimeException("模型版本已被删除，无法更新"); } LoginUser loginUser = SecurityUtils.getLoginUser(); modelsVersion.setUpdateBy(loginUser.getUsername()); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java index 80b4a986..caeffbbb 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java @@ -415,7 +415,7 @@ public class NewDatasetServiceImpl implements NewDatasetService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(repoId), Constant.Asset_Type_Dataset, null); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该数据集被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该数据集被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap map = new HashMap<>(); @@ -423,25 +423,25 @@ public class NewDatasetServiceImpl implements NewDatasetService { List autoMlList = autoMlDao.queryByDatasetId(JSON.toJSONString(map)); if (autoMlList != null && !autoMlList.isEmpty()) { String autoMls = String.join(",", autoMlList.stream().map(AutoMl::getMlName).collect(Collectors.toSet())); - throw new Exception("该数据集被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习。"); + throw new Exception("该数据集被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); } List rayList = rayDao.queryByDatasetId(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - throw new Exception("该数据集被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + throw new Exception("该数据集被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByDatasetId(JSON.toJSONString(map)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - throw new Exception("该数据集被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + throw new Exception("该数据集被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List devEnvironmentList = devEnvironmentDao.queryByDatasetId(JSON.toJSONString(map)); if (devEnvironmentList != null && !devEnvironmentList.isEmpty()) { String devEnvironments = String.join(",", devEnvironmentList.stream().map(DevEnvironment::getName).collect(Collectors.toSet())); - throw new Exception("该数据集被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境。"); + throw new Exception("该数据集被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境"); } String token = gitService.checkoutToken(); @@ -457,7 +457,7 @@ public class NewDatasetServiceImpl implements NewDatasetService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(repoId), Constant.Asset_Type_Dataset, version); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该数据集版本被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } HashMap map = new HashMap<>(); @@ -466,25 +466,25 @@ public class NewDatasetServiceImpl implements NewDatasetService { List autoMlList = autoMlDao.queryByDatasetId(JSON.toJSONString(map)); if (autoMlList != null && !autoMlList.isEmpty()) { String autoMls = String.join(",", autoMlList.stream().map(AutoMl::getMlName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习。"); + throw new Exception("该数据集版本被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); } List rayList = rayDao.queryByDatasetId(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优。"); + throw new Exception("该数据集版本被超参数自动寻优：" + rays + "使用，不能删除，请先删除超参数自动寻优"); } List activeLearnList = activeLearnDao.queryByDatasetId(JSON.toJSONString(map)); if (activeLearnList != null && !activeLearnList.isEmpty()) { String activeLearns = String.join(",", activeLearnList.stream().map(ActiveLearn::getName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习。"); + throw new Exception("该数据集版本被主动学习：" + activeLearns + "使用，不能删除，请先删除主动学习"); } List devEnvironmentList = devEnvironmentDao.queryByDatasetId(JSON.toJSONString(map)); if (devEnvironmentList != null && !devEnvironmentList.isEmpty()) { String devEnvironments = String.join(",", devEnvironmentList.stream().map(DevEnvironment::getName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境。"); + throw new Exception("该数据集版本被开发环境：" + devEnvironments + "使用，不能删除，请先删除开发环境"); } String token = gitService.checkoutToken(); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayInsServiceImpl.java index c29c0951..9e757c0c 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayInsServiceImpl.java @@ -139,7 +139,7 @@ public class RayInsServiceImpl implements RayInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowTermination, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (StringUtils.isEmpty(req)) { - throw new RuntimeException("终止响应内容为空。"); + throw new RuntimeException("终止响应内容为空"); } // 将响应的JSON字符串转换为Map对象 @@ -227,19 +227,19 @@ public class RayInsServiceImpl implements RayInsService { String req = HttpUtils.sendPost(argoUrl + argoWorkflowStatus, null, JsonUtils.mapToJson(res)); // 检查响应是否为空或无内容 if (req == null || StringUtils.isEmpty(req)) { - throw new RuntimeException("工作流状态响应为空。"); + throw new RuntimeException("工作流状态响应为空"); } // 将响应的JSON字符串转换为Map对象 Map runResMap = JsonUtils.jsonToMap(req); // 从响应Map中获取"data"部分 Map data = (Map) runResMap.get("data"); if (data == null || data.isEmpty()) { - throw new RuntimeException("工作流数据为空."); + throw new RuntimeException("工作流数据为空"); } // 从"data"中获取"status"部分，并返回"phase"的值 Map status = (Map) data.get("status"); if (status == null || status.isEmpty()) { - throw new RuntimeException("工作流状态为空。"); + throw new RuntimeException("工作流状态为空"); } //解析流水线结束时间 diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayServiceImpl.java index f2021a88..1a9c9770 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/RayServiceImpl.java @@ -63,15 +63,14 @@ public class RayServiceImpl implements RayService { @Override public Ray save(RayVo rayVo) throws Exception { + if (rayVo.getName().length() >= 64) { + throw new RuntimeException("实验名称大于最大长度"); + } Ray rayByName = rayDao.getRayByName(rayVo.getName()); if (rayByName != null) { throw new RuntimeException("实验名称已存在"); } - if (rayVo.getName().length() >= 64) { - throw new RuntimeException("实验名称大于最大长度"); - } - Ray ray = new Ray(); BeanUtils.copyProperties(rayVo, ray); String username = SecurityUtils.getLoginUser().getUsername(); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ServiceServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ServiceServiceImpl.java index c48ed069..14b58f2b 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ServiceServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/ServiceServiceImpl.java @@ -229,7 +229,7 @@ public class ServiceServiceImpl implements ServiceService { List assetWorkflow = assetWorkflowDao.getAssetWorkflow(Long.valueOf(id), Constant.Asset_Type_Service, null); if (assetWorkflow != null && !assetWorkflow.isEmpty()) { String workflows = String.join(",", assetWorkflow.stream().map(AssetWorkflow::getWorkflowName).collect(Collectors.toSet())); - throw new Exception("该服务被流水线：" + workflows + "使用，不能删除，请先删除流水线。"); + throw new Exception("该服务被流水线：" + workflows + "使用，不能删除，请先删除流水线"); } LoginUser loginUser = SecurityUtils.getLoginUser(); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java new file mode 100644 index 00000000..e085bbea --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java @@ -0,0 +1,179 @@ +package com.ruoyi.platform.service.impl; + +import com.ruoyi.common.security.utils.SecurityUtils; +import com.ruoyi.platform.domain.TextClassification; +import com.ruoyi.platform.domain.TextClassificationIns; +import com.ruoyi.platform.mapper.TextClassificationDao; +import com.ruoyi.platform.mapper.TextClassificationInsDao; +import com.ruoyi.platform.service.TextClassificationInsService; +import com.ruoyi.platform.service.TextClassificationService; +import com.ruoyi.platform.utils.HttpUtils; +import com.ruoyi.platform.utils.JacksonUtil; +import com.ruoyi.platform.utils.JsonUtils; +import com.ruoyi.platform.vo.TextClassificationParamVo; +import com.ruoyi.platform.vo.TextClassificationVo; +import com.ruoyi.system.api.constant.Constant; +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.BeanUtils; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.PageRequest; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Service +public class TextClassificationServiceImpl implements TextClassificationService { + @Value("${git.localPath}") + String localPath; + @Value("${argo.url}") + private String argoUrl; + @Value("${argo.convertTextClassification}") + String convertTextClassification; + @Value("${argo.workflowRun}") + private String argoWorkflowRun; + @Value("${minio.endpointIp}") + private String minioEndpoint; + + @Resource + private TextClassificationDao textClassificationDao; + @Resource + private TextClassificationInsDao textClassificationInsDao; + @Resource + private TextClassificationInsService textClassificationInsService; + + @Override + public Page queryByPage(String name, PageRequest pageRequest) { + long total = textClassificationDao.count(name); + List textClassifications= textClassificationDao.queryByPage(name, pageRequest); + return new PageImpl<>(textClassifications, pageRequest, total); + } + + @Override + public TextClassification save(TextClassificationVo textClassificationVo) throws Exception { + if (textClassificationVo.getName().length() >= 64) { + throw new RuntimeException("实验名称大于最大长度"); + } + TextClassification textClassificationByName = textClassificationDao.getByName(textClassificationVo.getName()); + if (textClassificationByName != null) { + throw new RuntimeException("实验名称已存在"); + } + TextClassification textClassification = new TextClassification(); + BeanUtils.copyProperties(textClassificationVo, textClassification); + String username = SecurityUtils.getLoginUser().getUsername(); + textClassification.setCreateBy(username); + textClassification.setUpdateBy(username); + String datasetJson = JacksonUtil.toJSONString(textClassificationVo.getDataset()); + textClassification.setDataset(datasetJson); + textClassificationDao.save(textClassification); + return textClassification; + } + + @Override + public String edit(TextClassificationVo textClassificationVo) throws Exception { + TextClassification oldTextClassification = textClassificationDao.getByName(textClassificationVo.getName()); + if (oldTextClassification != null && !oldTextClassification.getId().equals(textClassificationVo.getId())) { + throw new RuntimeException("实验名称已存在"); + } + TextClassification textClassification = new TextClassification(); + BeanUtils.copyProperties(textClassificationVo, textClassification); + String username = SecurityUtils.getLoginUser().getUsername(); + textClassification.setUpdateBy(username); + String datasetJson = JacksonUtil.toJSONString(textClassificationVo.getDataset()); + textClassification.setDataset(datasetJson); + + textClassificationDao.edit(textClassification); + return "修改成功"; + } + + @Override + public String delete(Long id) { + TextClassification textClassification = textClassificationDao.getById(id); + if (textClassification == null) { + throw new RuntimeException("实验不存在"); + } + String username = SecurityUtils.getLoginUser().getUsername(); + String createBy = textClassification.getCreateBy(); + if (!(StringUtils.equals(username, "admin") || StringUtils.equals(username, createBy))) { + throw new RuntimeException("无权限删除该实验"); + } + textClassification.setState(Constant.State_invalid); + return textClassificationDao.edit(textClassification) > 0 ? "删除成功" : "删除失败"; + } + + @Override + public TextClassificationVo getTextClassificationDetail(Long id) throws IOException { + TextClassification textClassification = textClassificationDao.getById(id); + TextClassificationVo textClassificationVo = new TextClassificationVo(); + BeanUtils.copyProperties(textClassification, textClassificationVo); + if (StringUtils.isNotEmpty(textClassification.getDataset())) { + textClassificationVo.setDataset(JsonUtils.jsonToMap(textClassification.getDataset())); + } + return textClassificationVo; + } + + @Override + public String runTextClassificationIns(Long id) throws Exception { + TextClassification textClassification = textClassificationDao.getById(id); + if (textClassification == null) { + throw new Exception("文本分类配置不存在"); + } + TextClassificationParamVo paramVo = new TextClassificationParamVo(); + BeanUtils.copyProperties(textClassification, paramVo); + paramVo.setDataset(JsonUtils.jsonToMap(textClassification.getDataset())); + String param = JsonUtils.objectToJson(paramVo); + // 调argo转换接口 + try { + String convertRes = HttpUtils.sendPost(argoUrl + convertTextClassification, param); + if (convertRes == null || StringUtils.isEmpty(convertRes)) { + throw new RuntimeException("转换流水线失败"); + } + Map converMap = JsonUtils.jsonToMap(convertRes); + // 组装运行接口json + Map output = (Map) converMap.get("output"); + Map runReqMap = new HashMap<>(); + runReqMap.put("data", converMap.get("data")); + // 调argo运行接口 + String runRes = HttpUtils.sendPost(argoUrl + argoWorkflowRun, JsonUtils.mapToJson(runReqMap)); + + if (runRes == null || StringUtils.isEmpty(runRes)) { + throw new RuntimeException("运行流水线失败"); + } + Map runResMap = JsonUtils.jsonToMap(runRes); + Map data = (Map) runResMap.get("data"); + //判断data为空 + if (data == null || MapUtils.isEmpty(data)) { + throw new RuntimeException("运行流水线失败"); + } + Map metadata = (Map) data.get("metadata"); + // 插入记录到实验实例表 + TextClassificationIns textClassificationIns = new TextClassificationIns(); + textClassificationIns.setTextClassificationId(id); + textClassificationIns.setArgoInsNs((String) metadata.get("namespace")); + textClassificationIns.setArgoInsName((String) metadata.get("name")); + textClassificationIns.setParam(param); + textClassificationIns.setStatus(Constant.Pending); + //替换argoInsName + String outputString = JsonUtils.mapToJson(output); + textClassificationIns.setNodeResult(outputString.replace("{{workflow.name}}", (String) metadata.get("name"))); + + Map param_output = (Map) output.get("param_output"); + List output1 = (ArrayList) param_output.values().toArray()[0]; + Map output2 = (Map) output1.get(0); + String outputPath = minioEndpoint + "/" + output2.get("path").replace("{{workflow.name}}", (String) metadata.get("name")) + "/"; + textClassificationIns.setModelPath(outputPath + "/saved_dict/" + textClassification.getModel() + ".ckpt"); + textClassificationInsDao.insert(textClassificationIns); + textClassificationInsService.updateTextClassificationStatus(id); + } catch (Exception e) { + throw new RuntimeException(e); + } + return "执行成功"; + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/WorkflowServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/WorkflowServiceImpl.java index 2535c1e0..fbeb54a5 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/WorkflowServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/WorkflowServiceImpl.java @@ -201,7 +201,7 @@ public class WorkflowServiceImpl implements WorkflowService { // 从响应Map中获取"data"的值,也就是日志的值 String newDag = (String) runResMap.get("data"); if (newDag == null) { - throw new RuntimeException("响应内容为空。"); + throw new RuntimeException("响应内容为空"); } duplicateWorkflow.setDag(newDag); duplicateWorkflow.setDescription(workflow.getDescription()); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java new file mode 100644 index 00000000..90252141 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java @@ -0,0 +1,31 @@ +package com.ruoyi.platform.vo; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.databind.PropertyNamingStrategy; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.Map; + +@Data +@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class) +@JsonInclude(JsonInclude.Include.NON_NULL) +@ApiModel(description = "文本分类参数") +public class TextClassificationParamVo { + @ApiModelProperty(value = "模型") + private String model; + + @ApiModelProperty(value = "数据集") + private Map dataset; + + @ApiModelProperty(value = "epochs") + private Integer epochs; + + @ApiModelProperty(value = "batch_size") + private Integer batchSize; + + @ApiModelProperty(value = "学习率") + private Float lr; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java new file mode 100644 index 00000000..5b780955 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java @@ -0,0 +1,51 @@ +package com.ruoyi.platform.vo; + +import com.fasterxml.jackson.databind.PropertyNamingStrategy; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.Date; +import java.util.Map; + +@Data +@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class) +@ApiModel(description = "文本分类") +public class TextClassificationVo { + private Long id; + + @ApiModelProperty(value = "实验名称") + private String name; + + @ApiModelProperty(value = "实验描述") + private String description; + + @ApiModelProperty(value = "模型") + private String model; + + @ApiModelProperty(value = "数据集") + private Map dataset; + + @ApiModelProperty(value = "epochs") + private Integer epochs; + + @ApiModelProperty(value = "batch_size") + private Integer batchSize; + + @ApiModelProperty(value = "学习率") + private Float lr; + + private String createBy; + + private String updateBy; + + private Date createTime; + + private Date updateTime; + + private Integer state; + + @ApiModelProperty(value = "状态列表") + private String statusList; +} diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/AutoMlDao.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/AutoMlDao.xml index 8bf8250f..79cf3e35 100644 --- a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/AutoMlDao.xml +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/AutoMlDao.xml @@ -1,7 +1,7 @@ - + insert into auto_ml(ml_name, ml_description, task_type, dataset, time_left_for_this_task, per_run_time_limit, ensemble_size, ensemble_class, ensemble_nbest, max_models_on_disc, seed, memory_limit, @@ -37,9 +37,6 @@ status_list = #{autoMl.statusList}, - - - task_type = #{autoMl.taskType}, diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml new file mode 100644 index 00000000..b600dec9 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml @@ -0,0 +1,87 @@ + + + + + + + + + + + + + insert into text_classification(name, description, model, dataset, epochs, batch_size, lr, create_by, update_by) + values (#{textClassification.name}, #{textClassification.description}, #{textClassification.model}, + #{textClassification.dataset}, #{textClassification.epochs}, #{textClassification.batchSize}, + #{textClassification.lr}, #{textClassification.createBy}, #{textClassification.updateBy},) + + + + update text_classification + + + name = #{textClassification.name}, + + + description = #{textClassification.description}, + + + model = #{textClassification.model}, + + + dataset = #{textClassification.dataset}, + + + epochs = #{textClassification.epochs}, + + + batch_size = #{textClassification.batchSize}, + + + lr = #{textClassification.lr}, + + + update_by = #{textClassification.updateBy}, + + + status_list = #{textClassification.statusList}, + + + state = #{textClassification.state}, + + + where id = #{textClassification.id} + + + + + + + state = 1 + + and name like concat('%', #{name}, '%') + + + + \ No newline at end of file diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml new file mode 100644 index 00000000..fd481dae --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml @@ -0,0 +1,85 @@ + + + + + + + + + + + + + insert into text_classification_ins(text_classification_id, status, param, argo_ins_name, argo_ins_ns, + node_status, node_result) + values (#{textClassificationIns.textClassificationId}, #{textClassificationIns.status}, + #{textClassificationIns.param}, #{textClassificationIns.argoInsName}, + #{textClassificationIns.argoInsNs}, #{textClassificationIns.nodeStatus}, + #{textClassificationIns.nodeResult}) + + + + update text_classification_ins + + + model_path = #{autoMlIns.modelPath}, + + + result_path = #{autoMlIns.resultPath}, + + + status = #{autoMlIns.status}, + + + node_status = #{autoMlIns.nodeStatus}, + + + node_result = #{autoMlIns.nodeResult}, + + + state = #{autoMlIns.state}, + + + update_time = #{autoMlIns.updateTime}, + + + finish_time = #{autoMlIns.finishTime}, + + + where id = #{textClassificationIns.id} + + + + \ No newline at end of file From 7156c805367a10bb3e26fbd0620569a7d0ec9cef Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 11:31:48 +0800 Subject: [PATCH 2/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../TextClassificationInsServiceImpl.java | 251 ++++++++++++++++++ 1 file changed, 251 insertions(+) create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java new file mode 100644 index 00000000..500515f6 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java @@ -0,0 +1,251 @@ +package com.ruoyi.platform.service.impl; + +import com.ruoyi.platform.domain.TextClassification; +import com.ruoyi.platform.domain.TextClassificationIns; +import com.ruoyi.platform.mapper.TextClassificationDao; +import com.ruoyi.platform.mapper.TextClassificationInsDao; +import com.ruoyi.platform.service.TextClassificationInsService; +import com.ruoyi.platform.utils.DateUtils; +import com.ruoyi.platform.utils.HttpUtils; +import com.ruoyi.platform.utils.JsonUtils; +import com.ruoyi.system.api.constant.Constant; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.PageRequest; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.util.*; + +@Service +public class TextClassificationInsServiceImpl implements TextClassificationInsService { + @Value("${argo.url}") + private String argoUrl; + @Value("${argo.workflowStatus}") + private String argoWorkflowStatus; + @Value("${argo.workflowTermination}") + private String argoWorkflowTermination; + + @Resource + private TextClassificationDao textClassificationDao; + @Resource + private TextClassificationInsDao textClassificationInsDao; + + @Override + public Page queryByPage(TextClassificationIns textClassificationIns, PageRequest pageRequest) { + long total = this.textClassificationInsDao.count(textClassificationIns); + List textClassificationInsList = this.textClassificationInsDao.queryAllByLimit(textClassificationIns, pageRequest); + return new PageImpl<>(textClassificationInsList, pageRequest, total); + } + + @Override + public TextClassificationIns insert(TextClassificationIns textClassificationIns) { + this.textClassificationInsDao.insert(textClassificationIns); + return textClassificationIns; + } + + @Override + public String removeById(Long id) { + TextClassificationIns textClassificationIns = textClassificationInsDao.queryById(id); + if (textClassificationIns == null) { + return "实验实例不存在"; + } + if (StringUtils.isEmpty(textClassificationIns.getStatus())) { + textClassificationIns = queryStatusFromArgo(textClassificationIns); + } + if (StringUtils.equals(textClassificationIns.getStatus(), Constant.Running)) { + return "实验实例正在运行，不可删除"; + } + textClassificationIns.setState(Constant.State_invalid); + int update = textClassificationInsDao.update(textClassificationIns); + if (update > 0) { + updateTextClassificationStatus(textClassificationIns.getTextClassificationId()); + return "删除成功"; + } else { + return "删除失败"; + } + } + + @Override + public String batchDelete(List ids) { + for (Long id : ids) { + String result = removeById(id); + if (!"删除成功".equals(result)) { + return result; + } + } + return "删除成功"; + } + + @Override + public boolean terminateTextClassificationIns(Long id) throws Exception { + TextClassificationIns textClassificationIns = textClassificationInsDao.queryById(id); + if (textClassificationIns == null) { + throw new IllegalStateException("实验实例未查询到，id: " + id); + } + String currentStatus = textClassificationIns.getStatus(); + String name = textClassificationIns.getArgoInsName(); + String namespace = textClassificationIns.getArgoInsNs(); + + // 获取当前状态，如果为空，则从Argo查询 + if (StringUtils.isEmpty(currentStatus)) { + currentStatus = queryStatusFromArgo(textClassificationIns).getStatus(); + } + // 只有状态是"Running"时才能终止实例 + if (!currentStatus.equalsIgnoreCase(Constant.Running)) { + throw new Exception("终止错误，只有运行状态的实例才能终止"); // 如果不是"Running"状态，则不执行终止操作 + } + + // 创建请求数据map + Map requestData = new HashMap<>(); + requestData.put("namespace", namespace); + requestData.put("name", name); + // 创建发送数据map，将请求数据作为"data"键的值 + Map res = new HashMap<>(); + res.put("data", requestData); + + try { + // 发送POST请求到Argo工作流状态查询接口，并将请求数据转换为JSON + String req = HttpUtils.sendPost(argoUrl + argoWorkflowTermination, null, JsonUtils.mapToJson(res)); + // 检查响应是否为空或无内容 + if (StringUtils.isEmpty(req)) { + throw new RuntimeException("终止响应内容为空"); + + } + // 将响应的JSON字符串转换为Map对象 + Map runResMap = JsonUtils.jsonToMap(req); + // 从响应Map中直接获取"errCode"的值 + Integer errCode = (Integer) runResMap.get("errCode"); + if (errCode != null && errCode == 0) { + //更新autoMlIns,确保状态更新被保存到数据库 + TextClassificationIns ins = queryStatusFromArgo(textClassificationIns); + String nodeStatus = ins.getNodeStatus(); + Map nodeMap = JsonUtils.jsonToMap(nodeStatus); + + // 遍历 map + for (Map.Entry entry : nodeMap.entrySet()) { + // 获取每个 Map 中的值并强制转换为 Map + Map innerMap = (Map) entry.getValue(); + // 检查 phase 的值 + if (innerMap.containsKey("phase")) { + String phaseValue = (String) innerMap.get("phase"); + // 如果值不等于 Succeeded，则赋值为 Failed + if (!StringUtils.equals(Constant.Succeeded, phaseValue)) { + innerMap.put("phase", Constant.Failed); + } + } + } + ins.setNodeStatus(JsonUtils.mapToJson(nodeMap)); + ins.setStatus(Constant.Terminated); + ins.setUpdateTime(new Date()); + ins.setFinishTime(new Date()); + this.textClassificationInsDao.update(ins); + updateTextClassificationStatus(textClassificationIns.getTextClassificationId()); + return true; + }else { + return false; + } + } catch (Exception e) { + throw new RuntimeException("终止实例错误: " + e.getMessage(), e); + } + } + + @Override + public TextClassificationIns getDetailById(Long id) { + TextClassificationIns textClassificationIns = textClassificationInsDao.queryById(id); + if (Constant.Running.equals(textClassificationIns.getStatus()) || Constant.Pending.equals(textClassificationIns.getStatus())) { + textClassificationIns = queryStatusFromArgo(textClassificationIns); + } + return textClassificationIns; + } + + @Override + public List queryByNotTerminated() { + return textClassificationInsDao.queryByNotTerminated(); + } + + @Override + public TextClassificationIns queryStatusFromArgo(TextClassificationIns ins) { + String namespace = ins.getArgoInsNs(); + String name = ins.getArgoInsName(); + + // 创建请求数据map + Map requestData = new HashMap<>(); + requestData.put("namespace", namespace); + requestData.put("name", name); + + // 创建发送数据map，将请求数据作为"data"键的值 + Map res = new HashMap<>(); + res.put("data", requestData); + + try { + // 发送POST请求到Argo工作流状态查询接口，并将请求数据转换为JSON + String req = HttpUtils.sendPost(argoUrl + argoWorkflowStatus, null, JsonUtils.mapToJson(res)); + // 检查响应是否为空或无内容 + if (req == null || StringUtils.isEmpty(req)) { + throw new RuntimeException("工作流状态响应为空"); + } + // 将响应的JSON字符串转换为Map对象 + Map runResMap = JsonUtils.jsonToMap(req); + // 从响应Map中获取"data"部分 + Map data = (Map) runResMap.get("data"); + if (data == null || data.isEmpty()) { + throw new RuntimeException("工作流数据为空"); + } + // 从"data"中获取"status"部分，并返回"phase"的值 + Map status = (Map) data.get("status"); + if (status == null || status.isEmpty()) { + throw new RuntimeException("工作流状态为空"); + } + //解析流水线结束时间 + String finishedAtString = (String) status.get("finishedAt"); + if (finishedAtString != null && !finishedAtString.isEmpty()) { + Date finishTime = DateUtils.convertUTCtoShanghaiDate(finishedAtString); + ins.setFinishTime(finishTime); + } + // 解析nodes字段,提取节点状态并转换为JSON字符串 + Map nodes = (Map) status.get("nodes"); + Map modifiedNodes = new LinkedHashMap<>(); + if (nodes != null) { + for (Map.Entry nodeEntry : nodes.entrySet()) { + Map nodeDetails = (Map) nodeEntry.getValue(); + String templateName = (String) nodeDetails.get("displayName"); + modifiedNodes.put(templateName, nodeDetails); + } + } + + String nodeStatusJson = JsonUtils.mapToJson(modifiedNodes); + ins.setNodeStatus(nodeStatusJson); + + //终止态为终止不改 + if (!StringUtils.equals(ins.getStatus(), Constant.Terminated)) { + ins.setStatus(StringUtils.isNotEmpty((String) status.get("phase")) ? (String) status.get("phase") : Constant.Pending); + } + if (StringUtils.equals(ins.getStatus(), Constant.Error)) { + ins.setStatus(Constant.Failed); + } + return ins; + } catch (Exception e) { + throw new RuntimeException("查询状态失败: " + e.getMessage(), e); + } + } + + @Override + public void updateTextClassificationStatus(Long textClassificationId) { + List insList = textClassificationInsDao.getByTextClassificationId(textClassificationId); + List statusList = new ArrayList<>(); + // 更新实验状态列表 + for (int i = 0; i < insList.size(); i++) { + statusList.add(insList.get(i).getStatus()); + } + String subStatus = statusList.toString().substring(1, statusList.toString().length() - 1); + TextClassification textClassification = textClassificationDao.getById(new Long(textClassificationId)); + + if (!StringUtils.equals(textClassification.getStatusList(), subStatus)) { + textClassification.setStatusList(subStatus); + textClassificationDao.edit(textClassification); + } + } +} From faedf1b103418e119838972e94308c9c6cc7d208 Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 11:34:04 +0800 Subject: [PATCH 3/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../textClassfication/TextClassificationController.java | 8 ++++---- .../platform/service/TextClassificationInsService.java | 1 + .../ruoyi/platform/service/TextClassificationService.java | 1 + .../service/impl/TextClassificationInsServiceImpl.java | 2 +- .../service/impl/TextClassificationServiceImpl.java | 2 +- 5 files changed, 8 insertions(+), 6 deletions(-) diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java index 4d643e80..628e7855 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/textClassfication/TextClassificationController.java @@ -24,8 +24,8 @@ public class TextClassificationController extends BaseController { @GetMapping @ApiOperation("分页查询") public GenericsAjaxResult> queryByPage(@RequestParam("page") int page, - @RequestParam("size") int size, - @RequestParam(value = "name", required = false) String name){ + @RequestParam("size") int size, + @RequestParam(value = "name", required = false) String name) { PageRequest pageRequest = PageRequest.of(page, size); return genericsSuccess(this.textClassificationService.queryByPage(name, pageRequest)); } @@ -44,13 +44,13 @@ public class TextClassificationController extends BaseController { @GetMapping("/getTextClassificationDetail") @ApiOperation("获取文本分类详细信息") - public GenericsAjaxResult getTextClassificationDetail(@RequestParam("id") Long id)throws IOException { + public GenericsAjaxResult getTextClassificationDetail(@RequestParam("id") Long id) throws IOException { return genericsSuccess(this.textClassificationService.getTextClassificationDetail(id)); } @DeleteMapping("{id}") @ApiOperation("删除文本分类") - public GenericsAjaxResult deleteTextClassification(@PathVariable("id") Long id){ + public GenericsAjaxResult deleteTextClassification(@PathVariable("id") Long id) { return genericsSuccess(this.textClassificationService.delete(id)); } diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java index d14c3a51..d8ffdae8 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationInsService.java @@ -1,4 +1,5 @@ package com.ruoyi.platform.service; + import com.ruoyi.platform.domain.TextClassificationIns; import org.springframework.data.domain.Page; import org.springframework.data.domain.PageRequest; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java index fffa57de..1bf95f34 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/TextClassificationService.java @@ -1,4 +1,5 @@ package com.ruoyi.platform.service; + import com.ruoyi.platform.domain.TextClassification; import com.ruoyi.platform.vo.TextClassificationVo; import org.springframework.data.domain.Page; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java index 500515f6..6dd52394 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java @@ -144,7 +144,7 @@ public class TextClassificationInsServiceImpl implements TextClassificationInsSe this.textClassificationInsDao.update(ins); updateTextClassificationStatus(textClassificationIns.getTextClassificationId()); return true; - }else { + } else { return false; } } catch (Exception e) { diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java index e085bbea..3de94587 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java @@ -52,7 +52,7 @@ public class TextClassificationServiceImpl implements TextClassificationService @Override public Page queryByPage(String name, PageRequest pageRequest) { long total = textClassificationDao.count(name); - List textClassifications= textClassificationDao.queryByPage(name, pageRequest); + List textClassifications = textClassificationDao.queryByPage(name, pageRequest); return new PageImpl<>(textClassifications, pageRequest, total); } From 2f9a18bf1c833dedef3942dde7326c5b10ba9115 Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 14:26:04 +0800 Subject: [PATCH 4/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../platform/domain/TextClassification.java | 2 + .../scheduling/AutoMlInsStatusTask.java | 4 +- .../scheduling/TextClassificationInsTask.java | 116 ++++++++++++++++++ .../service/impl/NewDatasetServiceImpl.java | 14 +++ .../TextClassificationInsServiceImpl.java | 8 ++ .../impl/TextClassificationServiceImpl.java | 104 +++++++++------- .../TextClassificationDaoMapper.xml | 7 +- .../TextClassificationInsDaoMapper.xml | 2 +- 8 files changed, 206 insertions(+), 51 deletions(-) create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/TextClassificationInsTask.java diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java index f6a239c5..fd11eedc 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java @@ -26,6 +26,8 @@ public class TextClassification { @ApiModelProperty(value = "数据集") private String dataset; + private Integer computingResourceId; + @ApiModelProperty(value = "epochs") private Integer epochs; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/AutoMlInsStatusTask.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/AutoMlInsStatusTask.java index 0c71cb7d..c59d67fc 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/AutoMlInsStatusTask.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/AutoMlInsStatusTask.java @@ -30,7 +30,7 @@ public class AutoMlInsStatusTask { private List autoMlIds = new ArrayList<>(); @Scheduled(cron = "0/30 * * * * ?") // 每30S执行一次 - public void executeAutoMlInsStatus() throws Exception { + public void executeAutoMlInsStatus() { // 首先查到所有非终止态的实验实例 List autoMlInsList = autoMlInsService.queryByAutoMlInsIsNotTerminated(); @@ -59,7 +59,7 @@ public class AutoMlInsStatusTask { } @Scheduled(cron = "0/30 * * * * ?") // / 每30S执行一次 - public void executeAutoMlStatus() throws Exception { + public void executeAutoMlStatus() { if (autoMlIds.size() == 0) { return; } diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/TextClassificationInsTask.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/TextClassificationInsTask.java new file mode 100644 index 00000000..5499c868 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/TextClassificationInsTask.java @@ -0,0 +1,116 @@ +package com.ruoyi.platform.scheduling; + +import com.ruoyi.platform.domain.TextClassification; +import com.ruoyi.platform.domain.TextClassificationIns; +import com.ruoyi.platform.mapper.ResourceOccupyDao; +import com.ruoyi.platform.mapper.TextClassificationDao; +import com.ruoyi.platform.mapper.TextClassificationInsDao; +import com.ruoyi.platform.service.ResourceOccupyService; +import com.ruoyi.platform.service.TextClassificationInsService; +import com.ruoyi.system.api.constant.Constant; +import org.apache.commons.lang3.StringUtils; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +@Component() +public class TextClassificationInsTask { + @Resource + private TextClassificationInsService textClassificationInsService; + @Resource + private TextClassificationInsDao textClassificationInsDao; + @Resource + private TextClassificationDao textClassificationDao; + @Resource + private ResourceOccupyDao resourceOccupyDao; + @Resource + private ResourceOccupyService resourceOccupyService; + + private List textClassificationIds = new ArrayList<>(); + + @Scheduled(cron = "0/30 * * * * ?") // 每30S执行一次 + public void executeTextClassificationInsStatus() { + // 首先查到所有非终止态的实验实例 + List insList = textClassificationInsService.queryByNotTerminated(); + + // 去argo查询状态 + List updateList = new ArrayList<>(); + if (insList != null && insList.size() > 0) { + for (TextClassificationIns ins : insList) { + //当原本状态为null或非终止态时才调用argo接口 + try { + Long userId = resourceOccupyDao.getResourceOccupyByTask(Constant.TaskType_TextClassification, ins.getTextClassificationId(), ins.getId(), null).get(0).getUserId(); + if (resourceOccupyDao.getUserCredit(userId) <= 0) { + ins.setStatus(Constant.Failed); + textClassificationInsService.terminateTextClassificationIns(ins.getId()); + } else { + ins = textClassificationInsService.queryStatusFromArgo(ins); + // 扣除积分 + if (Constant.Running.equals(ins.getStatus())) { + resourceOccupyService.deducing(Constant.TaskType_TextClassification, null, ins.getId(), null, null); + } else if (Constant.Failed.equals(ins.getStatus()) || Constant.Terminated.equals(ins.getStatus()) + || Constant.Succeeded.equals(ins.getStatus())) { + resourceOccupyService.endDeduce(Constant.TaskType_TextClassification, null, ins.getId(), null, null); + } + } + } catch (Exception e) { + ins.setStatus(Constant.Failed); + // 结束扣除积分 + resourceOccupyService.endDeduce(Constant.TaskType_TextClassification, null, ins.getId(), null, null); + } + // 线程安全的添加操作 + synchronized (textClassificationIds) { + textClassificationIds.add(ins.getTextClassificationId()); + } + updateList.add(ins); + } + if (updateList.size() > 0) { + for (TextClassificationIns ins : updateList) { + textClassificationInsDao.update(ins); + } + } + } + } + + @Scheduled(cron = "0/30 * * * * ?") // / 每30S执行一次 + public void executeTextClassificationStatus() { + if (textClassificationIds.size() == 0) { + return; + } + // 存储需要更新的实验对象列表 + List updateTextClassifications = new ArrayList<>(); + for (Long textClassificationId : textClassificationIds) { + // 获取当前实验的所有实例列表 + List insList = textClassificationInsDao.getByTextClassificationId(textClassificationId); + List statusList = new ArrayList<>(); + // 更新实验状态列表 + for (int i = 0; i < insList.size(); i++) { + statusList.add(insList.get(i).getStatus()); + } + String subStatus = statusList.toString().substring(1, statusList.toString().length() - 1); + TextClassification textClassification = textClassificationDao.getById(textClassificationId); + if (!StringUtils.equals(textClassification.getStatusList(), subStatus)) { + textClassification.setStatusList(subStatus); + updateTextClassifications.add(textClassification); + textClassificationDao.edit(textClassification); + } + } + + if (!updateTextClassifications.isEmpty()) { + // 使用Iterator进行安全的删除操作 + Iterator iterator = textClassificationIds.iterator(); + while (iterator.hasNext()) { + Long textClassificationId = iterator.next(); + for (TextClassification textClassification : updateTextClassifications) { + if (textClassification.getId().equals(textClassificationId)) { + iterator.remove(); + } + } + } + } + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java index caeffbbb..5432f17b 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java @@ -53,6 +53,8 @@ public class NewDatasetServiceImpl implements NewDatasetService { @Resource private AutoMlDao autoMlDao; @Resource + private TextClassificationDao textClassificationDao; + @Resource private RayDao rayDao; @Resource private ActiveLearnDao activeLearnDao; @@ -426,6 +428,12 @@ public class NewDatasetServiceImpl implements NewDatasetService { throw new Exception("该数据集被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); } + List textClassificationList = textClassificationDao.queryByDatasetId(JSON.toJSONString(map)); + if (textClassificationList != null && !textClassificationList.isEmpty()) { + String textClassifications = String.join(",", textClassificationList.stream().map(TextClassification::getName).collect(Collectors.toSet())); + throw new Exception("该数据集被自动机器学习文本分类：" + textClassifications + "使用，不能删除，请先删除自动机器学习文本分类"); + } + List rayList = rayDao.queryByDatasetId(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); @@ -469,6 +477,12 @@ public class NewDatasetServiceImpl implements NewDatasetService { throw new Exception("该数据集版本被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); } + List textClassificationList = textClassificationDao.queryByDatasetId(JSON.toJSONString(map)); + if (textClassificationList != null && !textClassificationList.isEmpty()) { + String textClassifications = String.join(",", textClassificationList.stream().map(TextClassification::getName).collect(Collectors.toSet())); + throw new Exception("该数据集版本被自动机器学习文本分类：" + textClassifications + "使用，不能删除，请先删除自动机器学习文本分类"); + } + List rayList = rayDao.queryByDatasetId(JSON.toJSONString(map)); if (rayList != null && !rayList.isEmpty()) { String rays = String.join(",", rayList.stream().map(Ray::getName).collect(Collectors.toSet())); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java index 6dd52394..afdd779f 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java @@ -4,6 +4,7 @@ import com.ruoyi.platform.domain.TextClassification; import com.ruoyi.platform.domain.TextClassificationIns; import com.ruoyi.platform.mapper.TextClassificationDao; import com.ruoyi.platform.mapper.TextClassificationInsDao; +import com.ruoyi.platform.service.ResourceOccupyService; import com.ruoyi.platform.service.TextClassificationInsService; import com.ruoyi.platform.utils.DateUtils; import com.ruoyi.platform.utils.HttpUtils; @@ -15,6 +16,7 @@ import org.springframework.data.domain.Page; import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import java.util.*; @@ -32,6 +34,8 @@ public class TextClassificationInsServiceImpl implements TextClassificationInsSe private TextClassificationDao textClassificationDao; @Resource private TextClassificationInsDao textClassificationInsDao; + @Resource + private ResourceOccupyService resourceOccupyService; @Override public Page queryByPage(TextClassificationIns textClassificationIns, PageRequest pageRequest) { @@ -47,6 +51,7 @@ public class TextClassificationInsServiceImpl implements TextClassificationInsSe } @Override + @Transactional public String removeById(Long id) { TextClassificationIns textClassificationIns = textClassificationInsDao.queryById(id); if (textClassificationIns == null) { @@ -61,6 +66,7 @@ public class TextClassificationInsServiceImpl implements TextClassificationInsSe textClassificationIns.setState(Constant.State_invalid); int update = textClassificationInsDao.update(textClassificationIns); if (update > 0) { + resourceOccupyService.deleteTaskState(Constant.TaskType_TextClassification, textClassificationIns.getTextClassificationId(), id); updateTextClassificationStatus(textClassificationIns.getTextClassificationId()); return "删除成功"; } else { @@ -143,6 +149,8 @@ public class TextClassificationInsServiceImpl implements TextClassificationInsSe ins.setFinishTime(new Date()); this.textClassificationInsDao.update(ins); updateTextClassificationStatus(textClassificationIns.getTextClassificationId()); + // 结束扣积分 + resourceOccupyService.endDeduce(Constant.TaskType_TextClassification, null, id, null, null); return true; } else { return false; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java index 3de94587..3c4f34e5 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java @@ -5,6 +5,7 @@ import com.ruoyi.platform.domain.TextClassification; import com.ruoyi.platform.domain.TextClassificationIns; import com.ruoyi.platform.mapper.TextClassificationDao; import com.ruoyi.platform.mapper.TextClassificationInsDao; +import com.ruoyi.platform.service.ResourceOccupyService; import com.ruoyi.platform.service.TextClassificationInsService; import com.ruoyi.platform.service.TextClassificationService; import com.ruoyi.platform.utils.HttpUtils; @@ -21,6 +22,7 @@ import org.springframework.data.domain.Page; import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import java.io.IOException; @@ -48,6 +50,8 @@ public class TextClassificationServiceImpl implements TextClassificationService private TextClassificationInsDao textClassificationInsDao; @Resource private TextClassificationInsService textClassificationInsService; + @Resource + private ResourceOccupyService resourceOccupyService; @Override public Page queryByPage(String name, PageRequest pageRequest) { @@ -94,6 +98,7 @@ public class TextClassificationServiceImpl implements TextClassificationService } @Override + @Transactional public String delete(Long id) { TextClassification textClassification = textClassificationDao.getById(id); if (textClassification == null) { @@ -105,6 +110,7 @@ public class TextClassificationServiceImpl implements TextClassificationService throw new RuntimeException("无权限删除该实验"); } textClassification.setState(Constant.State_invalid); + resourceOccupyService.deleteTaskState(Constant.TaskType_TextClassification, id, null); return textClassificationDao.edit(textClassification) > 0 ? "删除成功" : "删除失败"; } @@ -125,54 +131,60 @@ public class TextClassificationServiceImpl implements TextClassificationService if (textClassification == null) { throw new Exception("文本分类配置不存在"); } - TextClassificationParamVo paramVo = new TextClassificationParamVo(); - BeanUtils.copyProperties(textClassification, paramVo); - paramVo.setDataset(JsonUtils.jsonToMap(textClassification.getDataset())); - String param = JsonUtils.objectToJson(paramVo); - // 调argo转换接口 - try { - String convertRes = HttpUtils.sendPost(argoUrl + convertTextClassification, param); - if (convertRes == null || StringUtils.isEmpty(convertRes)) { - throw new RuntimeException("转换流水线失败"); - } - Map converMap = JsonUtils.jsonToMap(convertRes); - // 组装运行接口json - Map output = (Map) converMap.get("output"); - Map runReqMap = new HashMap<>(); - runReqMap.put("data", converMap.get("data")); - // 调argo运行接口 - String runRes = HttpUtils.sendPost(argoUrl + argoWorkflowRun, JsonUtils.mapToJson(runReqMap)); - if (runRes == null || StringUtils.isEmpty(runRes)) { - throw new RuntimeException("运行流水线失败"); - } - Map runResMap = JsonUtils.jsonToMap(runRes); - Map data = (Map) runResMap.get("data"); - //判断data为空 - if (data == null || MapUtils.isEmpty(data)) { - throw new RuntimeException("运行流水线失败"); - } - Map metadata = (Map) data.get("metadata"); - // 插入记录到实验实例表 - TextClassificationIns textClassificationIns = new TextClassificationIns(); - textClassificationIns.setTextClassificationId(id); - textClassificationIns.setArgoInsNs((String) metadata.get("namespace")); - textClassificationIns.setArgoInsName((String) metadata.get("name")); - textClassificationIns.setParam(param); - textClassificationIns.setStatus(Constant.Pending); - //替换argoInsName - String outputString = JsonUtils.mapToJson(output); - textClassificationIns.setNodeResult(outputString.replace("{{workflow.name}}", (String) metadata.get("name"))); + // 记录开始扣积分 + if (resourceOccupyService.haveResource(textClassification.getComputingResourceId(), 1)) { + TextClassificationParamVo paramVo = new TextClassificationParamVo(); + BeanUtils.copyProperties(textClassification, paramVo); + paramVo.setDataset(JsonUtils.jsonToMap(textClassification.getDataset())); + String param = JsonUtils.objectToJson(paramVo); + // 调argo转换接口 + try { + String convertRes = HttpUtils.sendPost(argoUrl + convertTextClassification, param); + if (convertRes == null || StringUtils.isEmpty(convertRes)) { + throw new RuntimeException("转换流水线失败"); + } + Map converMap = JsonUtils.jsonToMap(convertRes); + // 组装运行接口json + Map output = (Map) converMap.get("output"); + Map runReqMap = new HashMap<>(); + runReqMap.put("data", converMap.get("data")); + // 调argo运行接口 + String runRes = HttpUtils.sendPost(argoUrl + argoWorkflowRun, JsonUtils.mapToJson(runReqMap)); + + if (runRes == null || StringUtils.isEmpty(runRes)) { + throw new RuntimeException("运行流水线失败"); + } + Map runResMap = JsonUtils.jsonToMap(runRes); + Map data = (Map) runResMap.get("data"); + //判断data为空 + if (data == null || MapUtils.isEmpty(data)) { + throw new RuntimeException("运行流水线失败"); + } + Map metadata = (Map) data.get("metadata"); + // 插入记录到实验实例表 + TextClassificationIns textClassificationIns = new TextClassificationIns(); + textClassificationIns.setTextClassificationId(id); + textClassificationIns.setArgoInsNs((String) metadata.get("namespace")); + textClassificationIns.setArgoInsName((String) metadata.get("name")); + textClassificationIns.setParam(param); + textClassificationIns.setStatus(Constant.Pending); + //替换argoInsName + String outputString = JsonUtils.mapToJson(output); + textClassificationIns.setNodeResult(outputString.replace("{{workflow.name}}", (String) metadata.get("name"))); - Map param_output = (Map) output.get("param_output"); - List output1 = (ArrayList) param_output.values().toArray()[0]; - Map output2 = (Map) output1.get(0); - String outputPath = minioEndpoint + "/" + output2.get("path").replace("{{workflow.name}}", (String) metadata.get("name")) + "/"; - textClassificationIns.setModelPath(outputPath + "/saved_dict/" + textClassification.getModel() + ".ckpt"); - textClassificationInsDao.insert(textClassificationIns); - textClassificationInsService.updateTextClassificationStatus(id); - } catch (Exception e) { - throw new RuntimeException(e); + Map param_output = (Map) output.get("param_output"); + List output1 = (ArrayList) param_output.values().toArray()[0]; + Map output2 = (Map) output1.get(0); + String outputPath = minioEndpoint + "/" + output2.get("path").replace("{{workflow.name}}", (String) metadata.get("name")) + "/"; + textClassificationIns.setModelPath(outputPath + "/saved_dict/" + textClassification.getModel() + ".ckpt"); + textClassificationInsDao.insert(textClassificationIns); + textClassificationInsService.updateTextClassificationStatus(id); + // 记录开始扣除积分 + resourceOccupyService.startDeduce(textClassification.getComputingResourceId(), 1, Constant.TaskType_TextClassification, id, textClassificationIns.getId(), null, textClassification.getName(), null, null); + } catch (Exception e) { + throw new RuntimeException(e); + } } return "执行成功"; } diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml index b600dec9..5f0f3b0c 100644 --- a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml @@ -26,10 +26,10 @@ - insert into text_classification(name, description, model, dataset, epochs, batch_size, lr, create_by, update_by) + insert into text_classification(name, description, model, dataset, epochs, batch_size, lr, create_by, update_by, computing_resource_id) values (#{textClassification.name}, #{textClassification.description}, #{textClassification.model}, #{textClassification.dataset}, #{textClassification.epochs}, #{textClassification.batchSize}, - #{textClassification.lr}, #{textClassification.createBy}, #{textClassification.updateBy},) + #{textClassification.lr}, #{textClassification.createBy}, #{textClassification.updateBy}, #{textClassification.computingResourceId}) @@ -47,6 +47,9 @@ dataset = #{textClassification.dataset}, + + computing_resource_id = #{textClassification.computingResourceId}, + epochs = #{textClassification.epochs}, diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml index fd481dae..79254f76 100644 --- a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationInsDaoMapper.xml @@ -75,7 +75,7 @@ where id = #{textClassificationIns.id} - select * from text_classification_ins where (status NOT IN ('Terminated', 'Succeeded', 'Failed') From 78d1f24c4c4c0e60292777b18fd5960840bb639e Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 15:24:24 +0800 Subject: [PATCH 5/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/ruoyi/platform/domain/TextClassification.java | 2 +- .../service/impl/TextClassificationServiceImpl.java | 2 +- .../com/ruoyi/platform/vo/TextClassificationParamVo.java | 2 +- .../java/com/ruoyi/platform/vo/TextClassificationVo.java | 2 +- .../managementPlatform/TextClassificationDaoMapper.xml | 8 ++++---- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java index fd11eedc..6c4cf3bf 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java @@ -21,7 +21,7 @@ public class TextClassification { private String description; @ApiModelProperty(value = "模型") - private String model; + private String modelType; @ApiModelProperty(value = "数据集") private String dataset; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java index 3c4f34e5..30fa6e10 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationServiceImpl.java @@ -177,7 +177,7 @@ public class TextClassificationServiceImpl implements TextClassificationService List output1 = (ArrayList) param_output.values().toArray()[0]; Map output2 = (Map) output1.get(0); String outputPath = minioEndpoint + "/" + output2.get("path").replace("{{workflow.name}}", (String) metadata.get("name")) + "/"; - textClassificationIns.setModelPath(outputPath + "/saved_dict/" + textClassification.getModel() + ".ckpt"); + textClassificationIns.setModelPath(outputPath + "/saved_dict/" + textClassification.getModelType() + ".ckpt"); textClassificationInsDao.insert(textClassificationIns); textClassificationInsService.updateTextClassificationStatus(id); // 记录开始扣除积分 diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java index 90252141..84f7060a 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java @@ -15,7 +15,7 @@ import java.util.Map; @ApiModel(description = "文本分类参数") public class TextClassificationParamVo { @ApiModelProperty(value = "模型") - private String model; + private String modelType; @ApiModelProperty(value = "数据集") private Map dataset; diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java index 5b780955..517375bb 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationVo.java @@ -22,7 +22,7 @@ public class TextClassificationVo { private String description; @ApiModelProperty(value = "模型") - private String model; + private String modelType; @ApiModelProperty(value = "数据集") private Map dataset; diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml index 5f0f3b0c..faaec8aa 100644 --- a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/TextClassificationDaoMapper.xml @@ -26,8 +26,8 @@ - insert into text_classification(name, description, model, dataset, epochs, batch_size, lr, create_by, update_by, computing_resource_id) - values (#{textClassification.name}, #{textClassification.description}, #{textClassification.model}, + insert into text_classification(name, description, model_type, dataset, epochs, batch_size, lr, create_by, update_by, computing_resource_id) + values (#{textClassification.name}, #{textClassification.description}, #{textClassification.modelType}, #{textClassification.dataset}, #{textClassification.epochs}, #{textClassification.batchSize}, #{textClassification.lr}, #{textClassification.createBy}, #{textClassification.updateBy}, #{textClassification.computingResourceId}) @@ -41,8 +41,8 @@ description = #{textClassification.description}, - - model = #{textClassification.model}, + + model_type = #{textClassification.modelType}, dataset = #{textClassification.dataset}, From b104f670c2a5b9cf390ec77a41b421f436e16a46 Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 17:17:43 +0800 Subject: [PATCH 6/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ruoyi/platform/domain/TextClassification.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java index 6c4cf3bf..3dc0d4a9 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java @@ -20,7 +20,7 @@ public class TextClassification { @ApiModelProperty(value = "实验描述") private String description; - @ApiModelProperty(value = "模型") + @ApiModelProperty(value = "模型：TextCNN, TextRNN, FastText, TextRCNN, TextRNN_Att, DPCNN, Transformer") private String modelType; @ApiModelProperty(value = "数据集") From 880e63208437cd69443479e04d9ba30025810557 Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Wed, 23 Apr 2025 17:17:57 +0800 Subject: [PATCH 7/8] =?UTF-8?q?=E6=96=87=E6=9C=AC=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/com/ruoyi/platform/domain/TextClassification.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java index 3dc0d4a9..199928b5 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/TextClassification.java @@ -20,7 +20,7 @@ public class TextClassification { @ApiModelProperty(value = "实验描述") private String description; - @ApiModelProperty(value = "模型：TextCNN, TextRNN, FastText, TextRCNN, TextRNN_Att, DPCNN, Transformer") + @ApiModelProperty(value = "模型类型：TextCNN, TextRNN, FastText, TextRCNN, TextRNN_Att, DPCNN, Transformer") private String modelType; @ApiModelProperty(value = "数据集") From 0cc24f50a28c7e550b6b237a647ee60e60afba5d Mon Sep 17 00:00:00 2001 From: chenzhihang <709011834@qq.com> Date: Fri, 25 Apr 2025 10:06:20 +0800 Subject: [PATCH 8/8] =?UTF-8?q?=E8=87=AA=E5=8A=A8=E6=9C=BA=E5=99=A8?= =?UTF-8?q?=E5=AD=A6=E4=B9=A0=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/autoML/AutoMlController.java | 1 + .../machineLearn/MachineLearnController.java | 61 +++++ .../MachineLearnInsController.java | 60 ++++ .../ruoyi/platform/domain/MachineLearn.java | 42 +++ .../platform/domain/MachineLearnIns.java | 51 ++++ .../platform/mapper/MachineLearnDao.java | 23 ++ .../platform/mapper/MachineLearnInsDao.java | 23 ++ .../platform/scheduling/MLStatusTask.java | 119 ++++++++ .../service/MachineLearnInsService.java | 28 ++ .../platform/service/MachineLearnService.java | 19 ++ .../impl/MachineLearnInsServiceImpl.java | 259 ++++++++++++++++++ .../service/impl/MachineLearnServiceImpl.java | 220 +++++++++++++++ .../service/impl/NewDatasetServiceImpl.java | 36 +-- .../TextClassificationInsServiceImpl.java | 2 +- .../vo/TextClassificationParamVo.java | 2 + .../MachineLearnDaoMapper.xml | 82 ++++++ .../MachineLearnInsDaoMapper.xml | 83 ++++++ 17 files changed, 1089 insertions(+), 22 deletions(-) create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnController.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnInsController.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearn.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearnIns.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnDao.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnInsDao.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/MLStatusTask.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnInsService.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnService.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnInsServiceImpl.java create mode 100644 ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnServiceImpl.java create mode 100644 ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnDaoMapper.xml create mode 100644 ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnInsDaoMapper.xml diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/autoML/AutoMlController.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/autoML/AutoMlController.java index 9c1028bb..64c419c6 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/autoML/AutoMlController.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/autoML/AutoMlController.java @@ -44,6 +44,7 @@ public class AutoMlController extends BaseController { public GenericsAjaxResult editAutoMl(@RequestBody AutoMlVo autoMlVo) throws Exception { return genericsSuccess(this.autoMlService.edit(autoMlVo)); } + @GetMapping("/getAutoMlDetail") @ApiOperation("获取自动机器学习详细信息") public GenericsAjaxResult getAutoMlDetail(@RequestParam("id") Long id) throws IOException { diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnController.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnController.java new file mode 100644 index 00000000..5d08e5dd --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnController.java @@ -0,0 +1,61 @@ +package com.ruoyi.platform.controller.machineLearn; + +import com.ruoyi.common.core.web.controller.BaseController; +import com.ruoyi.common.core.web.domain.GenericsAjaxResult; +import com.ruoyi.platform.domain.MachineLearn; +import com.ruoyi.platform.service.MachineLearnService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; + +@RestController +@RequestMapping("machineLearn") +@Api("自动机器学习") +public class MachineLearnController extends BaseController { + @Resource + private MachineLearnService machineLearnService; + + @GetMapping + @ApiOperation("分页查询") + public GenericsAjaxResult> queryByPage(@RequestParam("page") int page, + @RequestParam("size") int size, + @RequestParam(value = "name", required = false) String name, + @RequestParam(value = "type", required = false) String type) { + PageRequest pageRequest = PageRequest.of(page, size); + return genericsSuccess(this.machineLearnService.queryByPage(name, type, pageRequest)); + } + + @PostMapping + @ApiOperation("新增自动机器学习") + public GenericsAjaxResult add(@RequestBody MachineLearn machineLearn) { + return genericsSuccess(this.machineLearnService.add(machineLearn)); + } + + @PutMapping + @ApiOperation("编辑自动机器学习") + public GenericsAjaxResult edit(@RequestBody MachineLearn machineLearn) throws Exception { + return genericsSuccess(this.machineLearnService.edit(machineLearn)); + } + + @GetMapping("/getMLDetail") + @ApiOperation("获取自动机器学习详细信息") + public GenericsAjaxResult getMLDetail(@RequestParam("id") Long id) { + return genericsSuccess(this.machineLearnService.getMLDetail(id)); + } + + @DeleteMapping("{id}") + @ApiOperation("删除自动机器学习") + public GenericsAjaxResult delete(@PathVariable("id") Long id) { + return genericsSuccess(this.machineLearnService.delete(id)); + } + + @PostMapping("/run/{id}") + @ApiOperation("运行自动机器学习") + public GenericsAjaxResult runMachineLearn(@PathVariable("id") Long id) throws Exception { + return genericsSuccess(this.machineLearnService.runMachineLearn(id)); + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnInsController.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnInsController.java new file mode 100644 index 00000000..c4e83c97 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/controller/machineLearn/MachineLearnInsController.java @@ -0,0 +1,60 @@ +package com.ruoyi.platform.controller.machineLearn; + +import com.ruoyi.common.core.web.controller.BaseController; +import com.ruoyi.common.core.web.domain.GenericsAjaxResult; +import com.ruoyi.platform.domain.MachineLearnIns; +import com.ruoyi.platform.service.MachineLearnInsService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.web.bind.annotation.*; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +import javax.annotation.Resource; +import java.util.List; + +@RestController +@RequestMapping("machineLearnIns") +@Api("自动机器学习实验实例") +public class MachineLearnInsController extends BaseController { + + @Resource + private MachineLearnInsService machineLearnInsService; + + @GetMapping + @ApiOperation("分页查询") + public GenericsAjaxResult> queryByPage(Long machineLearnId, int page, int size) { + PageRequest pageRequest = PageRequest.of(page, size); + return genericsSuccess(this.machineLearnInsService.queryByPage(machineLearnId, pageRequest)); + } + + @PostMapping + @ApiOperation("新增实验实例") + public GenericsAjaxResult add(@RequestBody MachineLearnIns machineLearnIns) { + return genericsSuccess(this.machineLearnInsService.insert(machineLearnIns)); + } + + @DeleteMapping("{id}") + @ApiOperation("删除实验实例") + public GenericsAjaxResult deleteById(@PathVariable("id") Long id) { + return genericsSuccess(this.machineLearnInsService.removeById(id)); + } + + @DeleteMapping("batchDelete") + @ApiOperation("批量删除实验实例") + public GenericsAjaxResult batchDelete(@RequestBody List ids) { + return genericsSuccess(this.machineLearnInsService.batchDelete(ids)); + } + + @PutMapping("{id}") + @ApiOperation("终止实验实例") + public GenericsAjaxResult terminateMLIns(@PathVariable("id") Long id) throws Exception { + return genericsSuccess(this.machineLearnInsService.terminateMLIns(id)); + } + + @GetMapping("{id}") + @ApiOperation("查看实验实例详情") + public GenericsAjaxResult getDetailById(@PathVariable("id") Long id) { + return genericsSuccess(this.machineLearnInsService.getDetailById(id)); + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearn.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearn.java new file mode 100644 index 00000000..110c6476 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearn.java @@ -0,0 +1,42 @@ +package com.ruoyi.platform.domain; + +import com.fasterxml.jackson.databind.PropertyNamingStrategy; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.Date; + +@Data +@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class) +@ApiModel(description = "机器学习") +public class MachineLearn { + private Long id; + + private Long experimentId; + + @ApiModelProperty(value = "类型") + private String type; + + @ApiModelProperty(value = "实验名称") + private String name; + + @ApiModelProperty(value = "实验描述") + private String description; + + private String param; + + private String createBy; + + private Date createTime; + + private String updateBy; + + private Date updateTime; + + private Integer state; + + @ApiModelProperty(value = "状态列表") + private String statusList; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearnIns.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearnIns.java new file mode 100644 index 00000000..120cf68d --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/domain/MachineLearnIns.java @@ -0,0 +1,51 @@ +package com.ruoyi.platform.domain; + +import com.fasterxml.jackson.databind.PropertyNamingStrategy; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.Date; + +@Data +@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class) +@ApiModel(description = "自动机器学习实验实例") +public class MachineLearnIns { + + private Long id; + + private Long machineLearnId; + + private String type; + + private String resultPath; + + private String modelPath; + + private String imgPath; + + private String runHistoryPath; + + private Integer state; + + private String status; + + private String nodeStatus; + + private String nodeResult; + + private String param; + + @ApiModelProperty(value = "Argo实例名称") + private String argoInsName; + + @ApiModelProperty(value = "Argo命名空间") + private String argoInsNs; + + private Date createTime; + + private Date updateTime; + + private Date finishTime; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnDao.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnDao.java new file mode 100644 index 00000000..7b954e2f --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnDao.java @@ -0,0 +1,23 @@ +package com.ruoyi.platform.mapper; + +import com.ruoyi.platform.domain.MachineLearn; +import org.apache.ibatis.annotations.Param; +import org.springframework.data.domain.Pageable; + +import java.util.List; + +public interface MachineLearnDao { + long count(@Param("name") String name, @Param("type") String type); + + List queryByPage(@Param("name") String name, @Param("type") String type, @Param("pageable") Pageable pageable); + + int save(@Param("machineLearn") MachineLearn machineLearn); + + int edit(@Param("machineLearn") MachineLearn machineLearn); + + MachineLearn getMachineLearnById(@Param("id") Long id); + + MachineLearn getMachineLearnByName(@Param("name") String name); + + List queryByDatasetId(@Param("datasetId") String datasetId); +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnInsDao.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnInsDao.java new file mode 100644 index 00000000..2267a830 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/mapper/MachineLearnInsDao.java @@ -0,0 +1,23 @@ +package com.ruoyi.platform.mapper; + +import com.ruoyi.platform.domain.MachineLearnIns; +import org.apache.ibatis.annotations.Param; +import org.springframework.data.domain.Pageable; + +import java.util.List; + +public interface MachineLearnInsDao { + long count(@Param("machineLearnId") Long machineLearnId); + + List queryAllByLimit(@Param("machineLearnId") Long machineLearnId, @Param("pageable") Pageable pageable); + + List getByMachineLearnId(@Param("machineLearnId") Long machineLearnId); + + int insert(@Param("machineLearnIns") MachineLearnIns machineLearnIns); + + int update(@Param("machineLearnIns") MachineLearnIns machineLearnIns); + + MachineLearnIns queryById(@Param("id") Long id); + + List queryNotTerminated(); +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/MLStatusTask.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/MLStatusTask.java new file mode 100644 index 00000000..473c0079 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/scheduling/MLStatusTask.java @@ -0,0 +1,119 @@ +package com.ruoyi.platform.scheduling; + +import com.ruoyi.platform.domain.*; +import com.ruoyi.platform.mapper.MachineLearnDao; +import com.ruoyi.platform.mapper.MachineLearnInsDao; +import com.ruoyi.platform.mapper.ResourceOccupyDao; +import com.ruoyi.platform.service.MachineLearnInsService; +import com.ruoyi.platform.service.ResourceOccupyService; +import com.ruoyi.system.api.constant.Constant; +import org.apache.commons.lang3.StringUtils; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Component; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +@Component() +public class MLStatusTask { + @Resource + private MachineLearnInsService machineLearnInsService; + @Resource + private MachineLearnInsDao machineLearnInsDao; + @Resource + private MachineLearnDao machineLearnDao; + @Resource + private ResourceOccupyDao resourceOccupyDao; + @Resource + private ResourceOccupyService resourceOccupyService; + + private List machineLearnIds = new ArrayList<>(); + + @Scheduled(cron = "0/30 * * * * ?") // 每30S执行一次 + public void executeMachineLearnInsStatus() { + // 首先查到所有非终止态的实验实例 + List insList = machineLearnInsService.queryNotTerminated(); + + // 去argo查询状态 + List updateList = new ArrayList<>(); + if (insList != null && insList.size() > 0) { + for (MachineLearnIns ins : insList) { + //当原本状态为null或非终止态时才调用argo接口 + try { + Long userId = resourceOccupyDao.getResourceOccupyByTask(Constant.TaskType_ML, ins.getMachineLearnId(), ins.getId(), null).get(0).getUserId(); + if (userId != null) { + if (resourceOccupyDao.getUserCredit(userId) <= 0) { + ins.setStatus(Constant.Failed); + machineLearnInsService.terminateMLIns(ins.getId()); + } else { + ins = machineLearnInsService.queryStatusFromArgo(ins); + // 扣除积分 + if (Constant.Running.equals(ins.getStatus())) { + resourceOccupyService.deducing(Constant.TaskType_ML, null, ins.getId(), null, null); + } else if (Constant.Failed.equals(ins.getStatus()) || Constant.Terminated.equals(ins.getStatus()) + || Constant.Succeeded.equals(ins.getStatus())) { + resourceOccupyService.endDeduce(Constant.TaskType_ML, null, ins.getId(), null, null); + } + } + } else { + ins = machineLearnInsService.queryStatusFromArgo(ins); + } + } catch (Exception e) { + ins.setStatus(Constant.Failed); + // 结束扣除积分 + resourceOccupyService.endDeduce(Constant.TaskType_ML, null, ins.getId(), null, null); + } + // 线程安全的添加操作 + synchronized (machineLearnIds) { + machineLearnIds.add(ins.getMachineLearnId()); + } + updateList.add(ins); + if (updateList.size() > 0) { + for (MachineLearnIns machineLearnIns : updateList) { + machineLearnInsDao.update(machineLearnIns); + } + } + } + } + } + + @Scheduled(cron = "0/30 * * * * ?") // / 每30S执行一次 + public void executeMachineLearn() { + if (machineLearnIds.size() == 0) { + return; + } + // 存储需要更新的实验对象列表 + List updateMLs = new ArrayList<>(); + for (Long machineLearnId : machineLearnIds) { + // 获取当前实验的所有实例列表 + List insList = machineLearnInsDao.getByMachineLearnId(machineLearnId); + List statusList = new ArrayList<>(); + // 更新实验状态列表 + for (int i = 0; i < insList.size(); i++) { + statusList.add(insList.get(i).getStatus()); + } + String subStatus = statusList.toString().substring(1, statusList.toString().length() - 1); + MachineLearn machineLearn = machineLearnDao.getMachineLearnById(machineLearnId); + if (!StringUtils.equals(machineLearn.getStatusList(), subStatus)) { + machineLearn.setStatusList(subStatus); + updateMLs.add(machineLearn); + machineLearnDao.edit(machineLearn); + } + } + + if (!updateMLs.isEmpty()) { + // 使用Iterator进行安全的删除操作 + Iterator iterator = machineLearnIds.iterator(); + while (iterator.hasNext()) { + Long machineLearnId = iterator.next(); + for (MachineLearn machineLearn : updateMLs) { + if (machineLearn.getId().equals(machineLearnId)) { + iterator.remove(); + } + } + } + } + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnInsService.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnInsService.java new file mode 100644 index 00000000..66becd1f --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnInsService.java @@ -0,0 +1,28 @@ +package com.ruoyi.platform.service; + +import com.ruoyi.platform.domain.MachineLearnIns; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +import java.util.List; + +public interface MachineLearnInsService { + + Page queryByPage(Long machineLearnId, PageRequest pageRequest); + + MachineLearnIns insert(MachineLearnIns machineLearnIns); + + String removeById(Long id); + + String batchDelete(List ids); + + List queryNotTerminated(); + + MachineLearnIns queryStatusFromArgo(MachineLearnIns machineLearnIns); + + boolean terminateMLIns(Long id) throws Exception; + + MachineLearnIns getDetailById(Long id); + + void updateMLStatus(Long machineLearnId); +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnService.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnService.java new file mode 100644 index 00000000..35c5985a --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/MachineLearnService.java @@ -0,0 +1,19 @@ +package com.ruoyi.platform.service; + +import com.ruoyi.platform.domain.MachineLearn; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageRequest; + +public interface MachineLearnService { + Page queryByPage(String name, String type, PageRequest pageRequest); + + MachineLearn add(MachineLearn machineLearn); + + String edit(MachineLearn machineLearn); + + MachineLearn getMLDetail(Long id); + + String delete(Long id); + + String runMachineLearn(Long id) throws Exception; +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnInsServiceImpl.java new file mode 100644 index 00000000..2e353807 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnInsServiceImpl.java @@ -0,0 +1,259 @@ +package com.ruoyi.platform.service.impl; + +import com.ruoyi.platform.domain.MachineLearn; +import com.ruoyi.platform.domain.MachineLearnIns; +import com.ruoyi.platform.mapper.MachineLearnDao; +import com.ruoyi.platform.mapper.MachineLearnInsDao; +import com.ruoyi.platform.service.MachineLearnInsService; +import com.ruoyi.platform.service.ResourceOccupyService; +import com.ruoyi.platform.utils.DateUtils; +import com.ruoyi.platform.utils.HttpUtils; +import com.ruoyi.platform.utils.JsonUtils; +import com.ruoyi.system.api.constant.Constant; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.PageRequest; +import org.springframework.transaction.annotation.Transactional; + +import javax.annotation.Resource; +import java.util.*; + +@Service +public class MachineLearnInsServiceImpl implements MachineLearnInsService { + @Value("${argo.url}") + private String argoUrl; + @Value("${argo.workflowStatus}") + private String argoWorkflowStatus; + @Value("${argo.workflowTermination}") + private String argoWorkflowTermination; + + @Resource + private MachineLearnInsDao machineLearnInsDao; + @Resource + private MachineLearnDao machineLearnDao; + @Resource + private ResourceOccupyService resourceOccupyService; + + @Override + public Page queryByPage(Long machineLearnId, PageRequest pageRequest) { + long count = machineLearnInsDao.count(machineLearnId); + List machineLearnInsList = machineLearnInsDao.queryAllByLimit(machineLearnId, pageRequest); + return new PageImpl<>(machineLearnInsList, pageRequest, count); + } + + @Override + public MachineLearnIns insert(MachineLearnIns machineLearnIns) { + machineLearnInsDao.insert(machineLearnIns); + return machineLearnIns; + } + + @Override + @Transactional + public String removeById(Long id) { + MachineLearnIns machineLearnIns = machineLearnInsDao.queryById(id); + if (machineLearnIns == null) { + return "实验实例不存在"; + } + if (StringUtils.isEmpty(machineLearnIns.getStatus())) { + machineLearnIns = queryStatusFromArgo(machineLearnIns); + } + if (StringUtils.equals(machineLearnIns.getStatus(), Constant.Running)) { + return "实验实例正在运行，不可删除"; + } + machineLearnIns.setState(Constant.State_invalid); + int update = machineLearnInsDao.update(machineLearnIns); + if (update > 0) { + resourceOccupyService.deleteTaskState(Constant.TaskType_ML, machineLearnIns.getMachineLearnId(), id); + updateMLStatus(machineLearnIns.getMachineLearnId()); + return "删除成功"; + } else { + return "删除失败"; + } + } + + @Override + public String batchDelete(List ids) { + for (Long id : ids) { + String result = removeById(id); + if (!"删除成功".equals(result)) { + return result; + } + } + return "删除成功"; + } + + @Override + public List queryNotTerminated() { + return machineLearnInsDao.queryNotTerminated(); + } + + @Override + public MachineLearnIns queryStatusFromArgo(MachineLearnIns ins) { + String namespace = ins.getArgoInsNs(); + String name = ins.getArgoInsName(); + + // 创建请求数据map + Map requestData = new HashMap<>(); + requestData.put("namespace", namespace); + requestData.put("name", name); + + // 创建发送数据map，将请求数据作为"data"键的值 + Map res = new HashMap<>(); + res.put("data", requestData); + + try { + // 发送POST请求到Argo工作流状态查询接口，并将请求数据转换为JSON + String req = HttpUtils.sendPost(argoUrl + argoWorkflowStatus, null, JsonUtils.mapToJson(res)); + // 检查响应是否为空或无内容 + if (req == null || StringUtils.isEmpty(req)) { + throw new RuntimeException("工作流状态响应为空"); + } + // 将响应的JSON字符串转换为Map对象 + Map runResMap = JsonUtils.jsonToMap(req); + // 从响应Map中获取"data"部分 + Map data = (Map) runResMap.get("data"); + if (data == null || data.isEmpty()) { + throw new RuntimeException("工作流数据为空"); + } + // 从"data"中获取"status"部分，并返回"phase"的值 + Map status = (Map) data.get("status"); + if (status == null || status.isEmpty()) { + throw new RuntimeException("工作流状态为空"); + } + //解析流水线结束时间 + String finishedAtString = (String) status.get("finishedAt"); + if (finishedAtString != null && !finishedAtString.isEmpty()) { + Date finishTime = DateUtils.convertUTCtoShanghaiDate(finishedAtString); + ins.setFinishTime(finishTime); + } + // 解析nodes字段,提取节点状态并转换为JSON字符串 + Map nodes = (Map) status.get("nodes"); + Map modifiedNodes = new LinkedHashMap<>(); + if (nodes != null) { + for (Map.Entry nodeEntry : nodes.entrySet()) { + Map nodeDetails = (Map) nodeEntry.getValue(); + String templateName = (String) nodeDetails.get("displayName"); + modifiedNodes.put(templateName, nodeDetails); + } + } + + String nodeStatusJson = JsonUtils.mapToJson(modifiedNodes); + ins.setNodeStatus(nodeStatusJson); + + //终止态为终止不改 + if (!StringUtils.equals(ins.getStatus(), Constant.Terminated)) { + ins.setStatus(StringUtils.isNotEmpty((String) status.get("phase")) ? (String) status.get("phase") : Constant.Pending); + } + if (StringUtils.equals(ins.getStatus(), Constant.Error)) { + ins.setStatus(Constant.Failed); + } + return ins; + } catch (Exception e) { + throw new RuntimeException("查询状态失败: " + e.getMessage(), e); + } + } + + + @Override + public boolean terminateMLIns(Long id) throws Exception { + MachineLearnIns machineLearnIns = machineLearnInsDao.queryById(id); + if (machineLearnIns == null) { + throw new IllegalStateException("实验实例未查询到"); + } + String currentStatus = machineLearnIns.getStatus(); + String name = machineLearnIns.getArgoInsName(); + String namespace = machineLearnIns.getArgoInsNs(); + + // 获取当前状态，如果为空，则从Argo查询 + if (StringUtils.isEmpty(currentStatus)) { + currentStatus = queryStatusFromArgo(machineLearnIns).getStatus(); + } + // 只有状态是"Running"时才能终止实例 + if (!currentStatus.equalsIgnoreCase(Constant.Running)) { + throw new Exception("终止错误，只有运行状态的实例才能终止"); // 如果不是"Running"状态，则不执行终止操作 + } + + // 创建请求数据map + Map requestData = new HashMap<>(); + requestData.put("namespace", namespace); + requestData.put("name", name); + // 创建发送数据map，将请求数据作为"data"键的值 + Map res = new HashMap<>(); + res.put("data", requestData); + + try { + // 发送POST请求到Argo工作流状态查询接口，并将请求数据转换为JSON + String req = HttpUtils.sendPost(argoUrl + argoWorkflowTermination, null, JsonUtils.mapToJson(res)); + // 检查响应是否为空或无内容 + if (StringUtils.isEmpty(req)) { + throw new RuntimeException("终止响应内容为空"); + + } + // 将响应的JSON字符串转换为Map对象 + Map runResMap = JsonUtils.jsonToMap(req); + // 从响应Map中直接获取"errCode"的值 + Integer errCode = (Integer) runResMap.get("errCode"); + if (errCode != null && errCode == 0) { + MachineLearnIns ins = queryStatusFromArgo(machineLearnIns); + String nodeStatus = ins.getNodeStatus(); + Map nodeMap = JsonUtils.jsonToMap(nodeStatus); + + // 遍历 map + for (Map.Entry entry : nodeMap.entrySet()) { + // 获取每个 Map 中的值并强制转换为 Map + Map innerMap = (Map) entry.getValue(); + // 检查 phase 的值 + if (innerMap.containsKey("phase")) { + String phaseValue = (String) innerMap.get("phase"); + // 如果值不等于 Succeeded，则赋值为 Failed + if (!StringUtils.equals(Constant.Succeeded, phaseValue)) { + innerMap.put("phase", Constant.Failed); + } + } + } + ins.setNodeStatus(JsonUtils.mapToJson(nodeMap)); + ins.setStatus(Constant.Terminated); + ins.setUpdateTime(new Date()); + ins.setFinishTime(new Date()); + machineLearnInsDao.update(ins); + updateMLStatus(ins.getMachineLearnId()); + // 结束扣积分 + resourceOccupyService.endDeduce(Constant.TaskType_ML, null, id, null, null); + return true; + } else { + return false; + } + } catch (Exception e) { + throw new RuntimeException("终止实例错误: " + e.getMessage(), e); + } + } + + @Override + public MachineLearnIns getDetailById(Long id) { + MachineLearnIns machineLearnIns = machineLearnInsDao.queryById(id); + if (Constant.Running.equals(machineLearnIns.getStatus()) || Constant.Pending.equals(machineLearnIns.getStatus())) { + machineLearnIns = queryStatusFromArgo(machineLearnIns); + } + return machineLearnIns; + } + + @Override + public void updateMLStatus(Long machineLearnId) { + List insList = machineLearnInsDao.getByMachineLearnId(machineLearnId); + List statusList = new ArrayList<>(); + // 更新实验状态列表 + for (int i = 0; i < insList.size(); i++) { + statusList.add(insList.get(i).getStatus()); + } + String subStatus = statusList.toString().substring(1, statusList.toString().length() - 1); + MachineLearn machineLearn = machineLearnDao.getMachineLearnById(machineLearnId); + + if (!StringUtils.equals(machineLearn.getStatusList(), subStatus)) { + machineLearn.setStatusList(subStatus); + machineLearnDao.edit(machineLearn); + } + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnServiceImpl.java new file mode 100644 index 00000000..bdd9f422 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/MachineLearnServiceImpl.java @@ -0,0 +1,220 @@ +package com.ruoyi.platform.service.impl; + +import com.ruoyi.common.security.utils.SecurityUtils; +import com.ruoyi.platform.domain.MachineLearn; +import com.ruoyi.platform.domain.MachineLearnIns; +import com.ruoyi.platform.mapper.MachineLearnDao; +import com.ruoyi.platform.mapper.MachineLearnInsDao; +import com.ruoyi.platform.service.MachineLearnInsService; +import com.ruoyi.platform.service.MachineLearnService; +import com.ruoyi.platform.service.ResourceOccupyService; +import com.ruoyi.platform.utils.HttpUtils; +import com.ruoyi.platform.utils.JsonUtils; +import com.ruoyi.platform.vo.AutoMlParamVo; +import com.ruoyi.platform.vo.TextClassificationParamVo; +import com.ruoyi.system.api.constant.Constant; +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.PageRequest; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Service +public class MachineLearnServiceImpl implements MachineLearnService { + @Value("${argo.url}") + private String argoUrl; + @Value("${argo.convertAutoML}") + String convertAutoML; + @Value("${argo.convertTextClassification}") + String convertTextClassification; + @Value("${argo.workflowRun}") + private String argoWorkflowRun; + @Value("${minio.endpointIp}") + private String minioEndpoint; + + @Resource + private MachineLearnDao machineLearnDao; + @Resource + private MachineLearnInsDao machineLearnInsDao; + @Resource + private ResourceOccupyService resourceOccupyService; + @Autowired + private MachineLearnInsService machineLearnInsService; + + @Override + public Page queryByPage(String name, String type, PageRequest pageRequest) { + long total = machineLearnDao.count(name, type); + List autoMls = machineLearnDao.queryByPage(name, type, pageRequest); + return new PageImpl<>(autoMls, pageRequest, total); + } + + @Override + public MachineLearn add(MachineLearn machineLearn) { + if (machineLearn.getName().length() >= 64) { + throw new RuntimeException("实验名称大于最大长度"); + } + MachineLearn machineLearnByName = machineLearnDao.getMachineLearnByName(machineLearn.getName()); + if (machineLearnByName != null) { + throw new RuntimeException("实验名称已存在"); + } + String username = SecurityUtils.getLoginUser().getUsername(); + machineLearn.setCreateBy(username); + machineLearn.setUpdateBy(username); + machineLearnDao.save(machineLearn); + return machineLearn; + } + + @Override + public String edit(MachineLearn machineLearn) { + MachineLearn machineLearnByName = machineLearnDao.getMachineLearnByName(machineLearn.getName()); + if (machineLearnByName != null && !machineLearnByName.getId().equals(machineLearn.getId())) { + throw new RuntimeException("实验名称已存在"); + } + machineLearn.setUpdateBy(SecurityUtils.getLoginUser().getUsername()); + machineLearnDao.edit(machineLearn); + return "修改成功"; + } + + @Override + public MachineLearn getMLDetail(Long id) { + return machineLearnDao.getMachineLearnById(id); + } + + @Override + @Transactional + public String delete(Long id) { + MachineLearn machineLearn = machineLearnDao.getMachineLearnById(id); + if (machineLearn == null) { + throw new RuntimeException("实验不存在"); + } + String username = SecurityUtils.getLoginUser().getUsername(); + String createBy = machineLearn.getCreateBy(); + if (!(StringUtils.equals(username, "admin") || StringUtils.equals(username, createBy))) { + throw new RuntimeException("无权限删除该实验"); + } + machineLearn.setUpdateBy(SecurityUtils.getLoginUser().getUsername()); + machineLearn.setState(Constant.State_invalid); + resourceOccupyService.deleteTaskState(Constant.TaskType_ML, id, null); + return machineLearnDao.edit(machineLearn) > 0 ? "删除成功" : "删除失败"; + } + + @Override + @Transactional + public String runMachineLearn(Long id) throws Exception { + MachineLearn machineLearn = machineLearnDao.getMachineLearnById(id); + if (machineLearn == null) { + throw new Exception("自动机器学习配置不存在"); + } + // 调argo转换接口 + try { + String convertRes = null; + String param = null; + String modelType = null; + String taskType = null; + Integer seed = null; + Integer computingResourceId = null; + switch (machineLearn.getType()) { + case Constant.ML_CSV: { + AutoMlParamVo paramVo = JsonUtils.jsonToObject(machineLearn.getParam(), AutoMlParamVo.class); + taskType = paramVo.getTaskType(); + seed = paramVo.getSeed(); + param = JsonUtils.objectToJson(paramVo); + convertRes = HttpUtils.sendPost(argoUrl + convertAutoML, param); + break; + } + case Constant.ML_TextClassification: { + TextClassificationParamVo paramVo = JsonUtils.jsonToObject(machineLearn.getParam(), TextClassificationParamVo.class); + modelType = paramVo.getModelType(); + computingResourceId = paramVo.getComputingResourceId(); + if (resourceOccupyService.haveResource(computingResourceId, 1)) { + param = JsonUtils.getConvertParam(paramVo); + convertRes = HttpUtils.sendPost(argoUrl + convertTextClassification, param); + } + break; + } + case Constant.ML_VideoClassification: { + // todo + break; + } + } + + if (convertRes == null || StringUtils.isEmpty(convertRes)) { + throw new RuntimeException("转换流水线失败"); + } + Map converMap = JsonUtils.jsonToMap(convertRes); + // 组装运行接口json + Map output = (Map) converMap.get("output"); + Map runReqMap = new HashMap<>(); + runReqMap.put("data", converMap.get("data")); + // 调argo运行接口 + String runRes = HttpUtils.sendPost(argoUrl + argoWorkflowRun, JsonUtils.mapToJson(runReqMap)); + + if (runRes == null || StringUtils.isEmpty(runRes)) { + throw new RuntimeException("运行流水线失败"); + } + Map runResMap = JsonUtils.jsonToMap(runRes); + Map data = (Map) runResMap.get("data"); + //判断data为空 + if (data == null || MapUtils.isEmpty(data)) { + throw new RuntimeException("运行流水线失败"); + } + Map metadata = (Map) data.get("metadata"); + // 插入记录到实验实例表 + MachineLearnIns machineLearnIns = new MachineLearnIns(); + machineLearnIns.setMachineLearnId(id); + machineLearnIns.setType(machineLearn.getType()); + machineLearnIns.setArgoInsNs((String) metadata.get("namespace")); + machineLearnIns.setArgoInsName((String) metadata.get("name")); + machineLearnIns.setParam(param); + machineLearnIns.setStatus(Constant.Pending); + //替换argoInsName + String outputString = JsonUtils.mapToJson(output); + machineLearnIns.setNodeResult(outputString.replace("{{workflow.name}}", (String) metadata.get("name"))); + Map param_output = (Map) output.get("param_output"); + List output1 = (ArrayList) param_output.values().toArray()[0]; + Map output2 = (Map) output1.get(0); + String outputPath = minioEndpoint + "/" + output2.get("path").replace("{{workflow.name}}", (String) metadata.get("name")) + "/"; + + switch (machineLearn.getType()) { + case Constant.ML_CSV: { + machineLearnIns.setModelPath(outputPath + "save_model.joblib"); + if (Constant.AutoMl_Classification.equals(taskType)) { + machineLearnIns.setImgPath(outputPath + "Auto-sklearn_metric_over_time.png" + "," + outputPath + "Train_Confusion_Matrix.png" + "," + outputPath + "Test_Confusion_Matrix.png"); + } else { + machineLearnIns.setImgPath(outputPath + "Auto-sklearn_metric_over_time.png" + "," + outputPath + "regression.png"); + } + machineLearnIns.setResultPath(outputPath + "result.txt"); + String seedStr = seed != null ? String.valueOf(seed) : "1"; + machineLearnIns.setRunHistoryPath(outputPath + "smac3-output/run_" + seedStr + "/runhistory.json"); + break; + } + case Constant.ML_TextClassification: { + machineLearnIns.setModelPath(outputPath + "/saved_dict/" + modelType + ".ckpt"); + break; + } + case Constant.ML_VideoClassification: { + break; + } + } + machineLearnInsDao.insert(machineLearnIns); + machineLearnInsService.updateMLStatus(id); + if (computingResourceId != null) { + // 记录开始扣除积分 + resourceOccupyService.startDeduce(computingResourceId, 1, Constant.TaskType_ML, id, machineLearnIns.getId(), null, machineLearn.getName(), null, null); + } + } catch (Exception e) { + throw new RuntimeException(e); + } + return "执行成功"; + } +} diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java index 5432f17b..122fd26b 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/NewDatasetServiceImpl.java @@ -51,9 +51,7 @@ public class NewDatasetServiceImpl implements NewDatasetService { @Resource private AssetWorkflowDao assetWorkflowDao; @Resource - private AutoMlDao autoMlDao; - @Resource - private TextClassificationDao textClassificationDao; + private MachineLearnDao machineLearnDao; @Resource private RayDao rayDao; @Resource @@ -422,16 +420,14 @@ public class NewDatasetServiceImpl implements NewDatasetService { HashMap map = new HashMap<>(); map.put("id", String.valueOf(repoId)); - List autoMlList = autoMlDao.queryByDatasetId(JSON.toJSONString(map)); - if (autoMlList != null && !autoMlList.isEmpty()) { - String autoMls = String.join(",", autoMlList.stream().map(AutoMl::getMlName).collect(Collectors.toSet())); - throw new Exception("该数据集被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); - } - List textClassificationList = textClassificationDao.queryByDatasetId(JSON.toJSONString(map)); - if (textClassificationList != null && !textClassificationList.isEmpty()) { - String textClassifications = String.join(",", textClassificationList.stream().map(TextClassification::getName).collect(Collectors.toSet())); - throw new Exception("该数据集被自动机器学习文本分类：" + textClassifications + "使用，不能删除，请先删除自动机器学习文本分类"); + HashMap mLQueryMap = new HashMap<>(); + mLQueryMap.put("dataset", map); + List machineLearnList = machineLearnDao.queryByDatasetId(JSON.toJSONString(mLQueryMap)); + + if (machineLearnList != null && !machineLearnList.isEmpty()) { + String autoMls = String.join(",", machineLearnList.stream().map(MachineLearn::getName).collect(Collectors.toSet())); + throw new Exception("该数据集被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); } List rayList = rayDao.queryByDatasetId(JSON.toJSONString(map)); @@ -471,16 +467,14 @@ public class NewDatasetServiceImpl implements NewDatasetService { HashMap map = new HashMap<>(); map.put("id", String.valueOf(repoId)); map.put("version", version); - List autoMlList = autoMlDao.queryByDatasetId(JSON.toJSONString(map)); - if (autoMlList != null && !autoMlList.isEmpty()) { - String autoMls = String.join(",", autoMlList.stream().map(AutoMl::getMlName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); - } - List textClassificationList = textClassificationDao.queryByDatasetId(JSON.toJSONString(map)); - if (textClassificationList != null && !textClassificationList.isEmpty()) { - String textClassifications = String.join(",", textClassificationList.stream().map(TextClassification::getName).collect(Collectors.toSet())); - throw new Exception("该数据集版本被自动机器学习文本分类：" + textClassifications + "使用，不能删除，请先删除自动机器学习文本分类"); + HashMap mLQueryMap = new HashMap<>(); + mLQueryMap.put("dataset", map); + List machineLearnList = machineLearnDao.queryByDatasetId(JSON.toJSONString(mLQueryMap)); + + if (machineLearnList != null && !machineLearnList.isEmpty()) { + String autoMls = String.join(",", machineLearnList.stream().map(MachineLearn::getName).collect(Collectors.toSet())); + throw new Exception("该数据集版本被自动机器学习：" + autoMls + "使用，不能删除，请先删除自动机器学习"); } List rayList = rayDao.queryByDatasetId(JSON.toJSONString(map)); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java index afdd779f..72f0fea1 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/service/impl/TextClassificationInsServiceImpl.java @@ -249,7 +249,7 @@ public class TextClassificationInsServiceImpl implements TextClassificationInsSe statusList.add(insList.get(i).getStatus()); } String subStatus = statusList.toString().substring(1, statusList.toString().length() - 1); - TextClassification textClassification = textClassificationDao.getById(new Long(textClassificationId)); + TextClassification textClassification = textClassificationDao.getById(textClassificationId); if (!StringUtils.equals(textClassification.getStatusList(), subStatus)) { textClassification.setStatusList(subStatus); diff --git a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java index 84f7060a..26d60204 100644 --- a/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java +++ b/ruoyi-modules/management-platform/src/main/java/com/ruoyi/platform/vo/TextClassificationParamVo.java @@ -28,4 +28,6 @@ public class TextClassificationParamVo { @ApiModelProperty(value = "学习率") private Float lr; + + private Integer computingResourceId; } diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnDaoMapper.xml new file mode 100644 index 00000000..8f5cfe49 --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnDaoMapper.xml @@ -0,0 +1,82 @@ + + + + + + + + + + insert into machine_learn(name, description, type, param, create_by, update_by) + values (#{machineLearn.name}, #{machineLearn.description}, #{machineLearn.type}, + #{machineLearn.param}, #{machineLearn.createBy}, #{machineLearn.updateBy}) + + + + update machine_learn + + + name = #{machineLearn.name}, + + + description = #{machineLearn.description}, + + + type = #{machineLearn.type}, + + + param = #{machineLearn.param}, + + + status_list = #{machineLearn.statusList}, + + + state = #{machineLearn.state}, + + + update_by = #{machineLearn.updateBy}, + + + where id = #{machineLearn.id} + + + + + + + + + + + + + and name like concat('%', #{name}, '%') + + + and type = #{type} + + and state = 1 + + + \ No newline at end of file diff --git a/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnInsDaoMapper.xml b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnInsDaoMapper.xml new file mode 100644 index 00000000..be1b642b --- /dev/null +++ b/ruoyi-modules/management-platform/src/main/resources/mapper/managementPlatform/MachineLearnInsDaoMapper.xml @@ -0,0 +1,83 @@ + + + + + insert into machine_learn_ins(machine_learn_id, type, result_path, model_path, img_path, run_history_path, node_status, + node_result, param, argo_ins_name, argo_ins_ns, status) + values (#{machineLearnIns.machineLearnId}, #{machineLearnIns.type}, #{machineLearnIns.resultPath}, #{machineLearnIns.modelPath}, #{machineLearnIns.imgPath}, + #{machineLearnIns.runHistoryPath}, #{machineLearnIns.nodeStatus}, + #{machineLearnIns.nodeResult}, #{machineLearnIns.param},#{machineLearnIns.argoInsName}, + #{machineLearnIns.argoInsNs}, #{machineLearnIns.status} + ) + + + + update machine_learn_ins + + + type = #{machineLearnIns.type}, + + + status = #{machineLearnIns.status}, + + + state = #{machineLearnIns.state}, + + + update_time = #{machineLearnIns.updateTime}, + + + finish_time = #{machineLearnIns.finishTime}, + + + node_status = #{machineLearnIns.nodeStatus}, + + + node_result = #{machineLearnIns.nodeResult}, + + + where id = #{machineLearnIns.id} + + + + + + + + + + + + \ No newline at end of file