贪心算法应用：柔性制造系统(FMS)刀具分配问题详解

在这里插入图片描述

Java中的贪心算法应用：柔性制造系统(FMS)刀具分配问题详解

1. 问题背景与定义

柔性制造系统(Flexible Manufacturing System, FMS)是现代智能制造中的关键组成部分，它能够灵活地适应不同产品的生产需求。在FMS中，刀具分配是一个核心优化问题，直接影响生产效率和成本。

1.1 FMS刀具分配问题定义

给定：

  • 一组待加工的工件(Jobs)：J = {J₁, J₂, …, Jₙ}
  • 一组可用刀具(Tools)：T = {T₁, T₂, …, Tₘ}
  • 每个工件需要特定的刀具组合
  • 每个刀具在机床上的存储位置有限(刀具容量限制)

目标：
在满足机床刀具容量限制的前提下，为每个工件分配所需的刀具，使得总体加工效率最高（通常表现为最小化刀具更换次数或最大化机床利用率）。

2. 贪心算法原理与适用性

2.1 贪心算法基本思想

贪心算法(Greedy Algorithm)是一种在每一步选择中都采取当前状态下最优的选择，从而希望导致全局最优解的算法策略。

2.2 为什么贪心算法适用于FMS刀具分配

  1. 局部最优可导致全局最优：刀具分配问题中，当前最优的刀具选择往往能减少未来的刀具更换
  2. 问题具有贪心选择性质：一个刀具的选择不会影响其他刀具的选择顺序
  3. 高效性：贪心算法通常比其他方法(如动态规划)更高效，适合实时决策

3. 问题建模与算法设计

3.1 数学模型

定义：

  • C：机床的刀具容量
  • Tᵢ：第i个刀具
  • Jⱼ：第j个工件
  • Rⱼ ⊆ T：工件Jⱼ所需的刀具集合
  • xᵢⱼ ∈ {0,1}：刀具Tᵢ是否分配给工件Jⱼ

目标函数：
最小化刀具更换次数或最大化刀具利用率

约束条件：

  1. ∑ xᵢⱼ ≤ C (机床刀具容量限制)
  2. 对于每个Jⱼ，必须满足Rⱼ中的所有刀具都被分配

3.2 贪心策略选择

常见的贪心策略：

  1. 最频繁使用优先：优先分配被最多工件需要的刀具
  2. 最长加工时间优先：优先分配用于最长加工时间的刀具
  3. 最大覆盖优先：优先分配能覆盖最多未分配工件的刀具

4. Java实现详解

4.1 数据结构设计

// 刀具类
class Tool {
int id;
int usageCount; // 被多少工件需要
List<Job> requiredBy; // 需要该刀具的工件列表public Tool(int id) {
this.id = id;
this.usageCount = 0;
this.requiredBy = new ArrayList<>();
}public void addJob(Job job) {
this.requiredBy.add(job);
this.usageCount++;
}
}// 工件类
class Job {
int id;
List<Tool> requiredTools; // 需要的刀具列表
boolean isAssigned; // 是否已分配刀具public Job(int id) {
this.id = id;
this.requiredTools = new ArrayList<>();
this.isAssigned = false;
}public void addTool(Tool tool) {
this.requiredTools.add(tool);
}
}// FMS系统类
class FMS {
int machineCapacity; // 机床刀具容量
List<Tool> tools; // 所有刀具
List<Job> jobs; // 所有工件
Set<Tool> loadedTools; // 当前装载的刀具public FMS(int capacity) {
this.machineCapacity = capacity;
this.tools = new ArrayList<>();
this.jobs = new ArrayList<>();
this.loadedTools = new HashSet<>();
}// 添加刀具
public void addTool(Tool tool) {
tools.add(tool);
}// 添加工件
public void addJob(Job job) {
jobs.add(job);
}
}

4.2 贪心算法实现（最频繁使用优先策略）

public class GreedyToolAllocation {public static void allocateTools(FMS fms) {
// 1. 按使用频率降序排序刀具
List<Tool> sortedTools = new ArrayList<>(fms.tools);
Collections.sort(sortedTools, (t1, t2) -> t2.usageCount - t1.usageCount);// 2. 初始化未分配工件列表
List<Job> unassignedJobs = new ArrayList<>(fms.jobs);// 3. 贪心分配循环
while (!unassignedJobs.isEmpty() && fms.loadedTools.size() < fms.machineCapacity) {
// 选择下一个最优刀具
Tool selectedTool = selectNextTool(sortedTools, fms.loadedTools, unassignedJobs);if (selectedTool == null) {
break; // 没有可选刀具了
}// 装载刀具
fms.loadedTools.add(selectedTool);
System.out.println("Loaded tool: " + selectedTool.id);// 处理可以加工的工件
processAssignedJobs(fms, selectedTool, unassignedJobs);
}// 4. 检查是否有未分配的工件
if (!unassignedJobs.isEmpty()) {
System.out.println("Warning: Not all jobs could be assigned due to capacity constraints");
}
}private static Tool selectNextTool(List<Tool> sortedTools, Set<Tool> loadedTools, List<Job> unassignedJobs) {
for (Tool tool : sortedTools) {
if (!loadedTools.contains(tool)) {
// 检查该刀具是否能帮助分配至少一个未分配工件
for (Job job : tool.requiredBy) {
if (unassignedJobs.contains(job)) {
return tool;
}
}
}
}
return null;
}private static void processAssignedJobs(FMS fms, Tool selectedTool, List<Job> unassignedJobs) {
Iterator<Job> iterator = unassignedJobs.iterator();
while (iterator.hasNext()) {
Job job = iterator.next();
if (job.requiredTools.contains(selectedTool)) {
// 检查该工件所需的所有刀具是否都已装载
boolean allToolsLoaded = true;
for (Tool t : job.requiredTools) {
if (!fms.loadedTools.contains(t)) {
allToolsLoaded = false;
break;
}
}if (allToolsLoaded) {
System.out.println("Assigned job " + job.id + " with tools: " +
job.requiredTools.stream().map(t -> t.id).collect(Collectors.toList()));
iterator.remove();
}
}
}
}
}

4.3 算法复杂度分析

  1. 排序阶段：O(m log m)，m为刀具数量
  2. 主循环：最坏情况下O(m × n)，n为工件数量
  3. 总体复杂度：O(m log m + m × n)

5. 算法优化与变种

5.1 带权重的贪心策略

考虑刀具更换成本或刀具装载时间，可以引入权重因子：

class Tool {
// ... 原有属性
double weight; // 权重因子，可能基于更换成本或装载时间public Tool(int id, double weight) {
this.id = id;
this.weight = weight;
// ... 其他初始化
}
}// 修改排序比较器
Collections.sort(sortedTools, (t1, t2) -> {
double priority1 = t1.usageCount / t1.weight;
double priority2 = t2.usageCount / t2.weight;
return Double.compare(priority2, priority1);
});

5.2 动态贪心策略

根据当前机床状态动态调整贪心策略：

private static Tool selectNextTool(FMS fms, List<Tool> sortedTools, List<Job> unassignedJobs) {
Tool bestTool = null;
double bestScore = -1;for (Tool tool : sortedTools) {
if (!fms.loadedTools.contains(tool)) {
// 计算当前刀具的得分
double score = calculateToolScore(fms, tool, unassignedJobs);if (score > bestScore) {
bestScore = score;
bestTool = tool;
}
}
}return bestTool;
}private static double calculateToolScore(FMS fms, Tool tool, List<Job> unassignedJobs) {
// 计算能覆盖多少未分配工件
long coverCount = tool.requiredBy.stream()
.filter(unassignedJobs::contains)
.count();// 计算这些工件所需的剩余刀具是否能在剩余容量内满足
double feasibilityFactor = 1.0;
for (Job job : tool.requiredBy) {
if (unassignedJobs.contains(job)) {
int remainingToolsNeeded = (int) job.requiredTools.stream()
.filter(t -> !fms.loadedTools.contains(t) && t != tool)
.count();
if (remainingToolsNeeded > (fms.machineCapacity - fms.loadedTools.size() - 1)) {
feasibilityFactor *= 0.5; // 降低不可行分配的权重
}
}
}return coverCount * feasibilityFactor / tool.weight;
}

6. 实际应用案例

6.1 案例数据

假设：

  • 机床刀具容量：5
  • 刀具：T1-T10
  • 工件：J1-J8
  • 工件-刀具需求：
  • J1: T1, T3, T5
  • J2: T2, T4, T6
  • J3: T1, T7, T8
  • J4: T2, T5, T9
  • J5: T3, T6, T10
  • J6: T1, T4, T7
  • J7: T2, T3, T8
  • J8: T5, T6, T9

6.2 Java实现与执行

public class FMSTest {
public static void main(String[] args) {
// 创建FMS系统，机床容量为5
FMS fms = new FMS(5);// 创建刀具
for (int i = 1; i <= 10; i++) {
fms.addTool(new Tool(i));
}// 创建工件并建立与刀具的关系
Job j1 = new Job(1);
j1.addTool(fms.tools.get(0)); // T1
j1.addTool(fms.tools.get(2)); // T3
j1.addTool(fms.tools.get(4)); // T5
fms.addJob(j1);
fms.tools.get(0).addJob(j1);
fms.tools.get(2).addJob(j1);
fms.tools.get(4).addJob(j1);// 类似地添加其他工件和刀具关系...
// (为简洁起见，这里省略了J2-J8的添加代码，实际应用中应完整添加)// 执行贪心算法分配
GreedyToolAllocation.allocateTools(fms);// 输出最终装载的刀具
System.out.println("Final loaded tools: " +
fms.loadedTools.stream().map(t -> t.id).collect(Collectors.toList()));
}
}

6.3 预期输出

根据贪心策略，算法可能会输出类似以下的结果：

Loaded tool: 2
Loaded tool: 1
Assigned job 1 with tools: [1, 3, 5]
Assigned job 3 with tools: [1, 7, 8]
Assigned job 6 with tools: [1, 4, 7]
Loaded tool: 5
Assigned job 4 with tools: [2, 5, 9]
Assigned job 8 with tools: [5, 6, 9]
Loaded tool: 3
Assigned job 5 with tools: [3, 6, 10]
Assigned job 7 with tools: [2, 3, 8]
Final loaded tools: [1, 2, 3, 5]

7. 算法评估与比较

7.1 性能指标

  1. 刀具更换次数：算法执行过程中需要更换刀具的次数
  2. 机床利用率：刀具装载时间占总生产时间的比例
  3. 工件完成率：在给定容量下能完成的工件比例
  4. 响应时间：算法决策所需的时间

7.2 与其他算法的比较

  1. 与动态规划比较：
  • 贪心算法更高效，但可能不是全局最优
  • 动态规划能保证最优解，但复杂度高(通常O(n²)或更高)
  1. 与遗传算法比较：
  • 贪心算法是确定性算法，结果可重复
  • 遗传算法可能找到更好解，但计算成本高
  1. 与规则引擎比较：
  • 贪心算法更系统化
  • 规则引擎更灵活但需要大量领域知识

8. 实际工程考虑

8.1 多目标优化

实际FMS中可能需要考虑多个目标：

  • 最小化刀具更换
  • 最大化机床利用率
  • 均衡刀具磨损
  • 最小化能耗

可以修改贪心算法的评分函数来综合考虑这些因素。

8.2 实时性要求

FMS通常需要实时响应，贪心算法的快速决策优势明显。可以进一步优化：

// 使用并发处理提高性能
public class ParallelGreedyAllocator {
private static final int THREAD_POOL_SIZE = Runtime.getRuntime().availableProcessors();public static void allocateTools(FMS fms) {
ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);// 并行计算刀具得分
List<Future<ToolScore>> futures = new ArrayList<>();
for (Tool tool : fms.tools) {
if (!fms.loadedTools.contains(tool)) {
futures.add(executor.submit(() ->
new ToolScore(tool, calculateToolScore(fms, tool, fms.jobs))));
}
}// 获取最佳刀具
Tool bestTool = null;
double bestScore = -1;for (Future<ToolScore> future : futures) {
try {
ToolScore ts = future.get();
if (ts.score > bestScore) {
bestScore = ts.score;
bestTool = ts.tool;
}
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}executor.shutdown();if (bestTool != null) {
// 装载最佳刀具并处理工件
// ...
}
}private static class ToolScore {
Tool tool;
double score;public ToolScore(Tool tool, double score) {
this.tool = tool;
this.score = score;
}
}
}

8.3 异常处理与鲁棒性

增强算法的鲁棒性：

public class RobustGreedyAllocator {
public static void allocateTools(FMS fms) {
try {
// 主分配逻辑
basicAllocation(fms);// 检查并处理未分配工件
handleUnassignedJobs(fms);} catch (Exception e) {
System.err.println("Allocation error: " + e.getMessage());
// 回滚或恢复策略
recoverFromFailure(fms);
}
}private static void handleUnassignedJobs(FMS fms) {
List<Job> unassigned = fms.jobs.stream()
.filter(j -> !j.isAssigned)
.collect(Collectors.toList());if (!unassigned.isEmpty()) {
// 尝试更激进的策略
aggressiveAllocation(fms, unassigned);// 如果仍有未分配工件，考虑部分分配或重新调度
if (unassigned.stream().anyMatch(j -> !j.isAssigned)) {
rescheduleOrPartialAllocation(fms, unassigned);
}
}
}
}

9. 扩展与未来方向

9.1 结合机器学习

可以使用强化学习来优化贪心算法的决策策略：

public class RLEnhancedGreedyAllocator {
private QLearningModel model; // 预训练的Q学习模型public void allocateTools(FMS fms) {
while (/* 条件 */) {
// 获取当前状态
State currentState = extractState(fms);// 使用模型预测最佳动作
Action action = model.predict(currentState);// 执行动作
executeAction(fms, action);// 更新状态
updateState(fms);
}
}private State extractState(FMS fms) {
// 提取当前状态特征：装载的刀具、未分配工件等
// ...
}
}

9.2 分布式FMS中的刀具分配

对于多机分布式FMS系统，可以扩展算法：

public class DistributedAllocator {
public void allocateAcrossMachines(List<FMS> machines, List<Job> allJobs) {
// 全局刀具使用统计
Map<Tool, Integer> globalUsage = calculateGlobalToolUsage(allJobs);// 为每个机床分配初始刀具集
for (FMS machine : machines) {
allocateInitialTools(machine, globalUsage);
}// 分布式分配工件
distributeJobs(machines, allJobs);
}
}

10. 总结

贪心算法在FMS刀具分配问题中提供了一种高效实用的解决方案。通过合理设计贪心策略、优化数据结构实现，并结合实际工程考虑，可以开发出适用于工业环境的强大刀具分配系统。虽然贪心算法不能保证总是得到全局最优解，但其高效性和良好的近似解质量使其成为FMS实时决策的理想选择。

开发方向包括：

  1. 与机器学习方法结合，实现自适应贪心策略
  2. 扩展到分布式FMS环境
  3. 考虑更多实际约束和多目标优化
  4. 进一步提高实时性能，满足工业4.0的需求

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/diannao/98586.shtml
繁体地址，请注明出处：http://hk.pswp.cn/diannao/98586.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

不止是DELETE：MySQL多表关联删除的JOIN语法实战详解

不止是DELETE：MySQL多表关联删除的JOIN语法实战详解

MySQL 的 ​​DELETE​​ 语句用于从数据库表中删除记录。这是一项非常强大且危险的操作&#xff0c;因为一旦执行&#xff0c;数据通常无法恢复。理解其语法和安全实践至关重要。以下是 MySQL 删除语句的详细指南。一、 核心语法&#xff1a;DELETE​​DELETE​​ 语句用于删除…
阅读更多...
ubuntu 系統使用過程中黑屏問題分析

ubuntu 系統使用過程中黑屏問題分析

背景&#xff1a; 工欲善其事&#xff0c;必先利其器。作为程序员&#xff0c;想要得到更好的发展&#xff0c;遇到问题直接baidu, google 虽然可以得到一些参考或者答案&#xff0c;但是也会降低自己的思考能力&#xff0c;本文以ubuntu 使用过程中黑屏这一问题为背景&#x…
阅读更多...
Redis（45）哨兵模式与集群模式有何区别？

Redis（45）哨兵模式与集群模式有何区别？

Redis 提供了两种高可用性解决方案&#xff1a;哨兵模式和集群模式。它们各自有不同的特点和适用场景。以下是详细的对比和结合代码的示例&#xff1a; 哨兵模式&#xff08;Sentinel&#xff09; 特点高可用性&#xff1a; Sentinel 通过监控、通知、故障转移等功能&#xff0…
阅读更多...
微信小程序如何进行分包处理？

微信小程序如何进行分包处理？

目录 分包是什么&#xff1f; 为什么要分包&#xff1f; 分包前后结构对比 具体操作步骤 第 1 步&#xff1a;规划分包结构 第 2 步&#xff1a;修改 app.json 进行配置 第 3 步&#xff1a;创建分包目录并移动文件 第 4 步&#xff1a;处理组件和工具函数的引用 第 5…
阅读更多...
Go语言极速入门与精要指南从零到精通的系统化学习路径

Go语言极速入门与精要指南从零到精通的系统化学习路径

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 持续学习&#xff0c;不断…
阅读更多...
git 切换仓库后清理分支缓存

git 切换仓库后清理分支缓存

我明白了&#xff0c;从您的截图可以看到远程仓库中有 feature/v1.4_20250903 分支&#xff0c;但本地 git branch -r 看不到&#xff0c;这是因为之前更换过仓库地址后需要重新获取远程仓库的所有信息。让我们执行以下步骤来解决这个问题&#xff1a; 首先执行 git fetch --al…
阅读更多...
考研倒计时101天---路由选择协议

考研倒计时101天---路由选择协议

路由选择协议&#xff1a;RIP 与 OSPFRIP 协议&#xff08;基于距离向量算法&#xff09;RIP&#xff08;Routing Information Protocol&#xff09;是一种内部网关协议&#xff08;IGP&#xff09;&#xff0c;采用距离向量算法进行路由选择。其主要特点如下&#xff1a;工作机…
阅读更多...
「类 vs 实例」对比 ，「类 - 原型 - 实例」的关系

「类 vs 实例」对比 ，「类 - 原型 - 实例」的关系

坚持的本身就是意义 目录直观类比类 (Class) vs 实例 (Instance)对比表示例代码类 - 原型 - 实例关系图解释&#xff1a;类 (class Person)原型 (Person.prototype)实例 (new Person(...))总结&#xff1a;直观类比 类&#xff08;Class&#xff09; 图纸 / 模板实例&#xf…
阅读更多...
第一课、Cocos Creator 3.8 安装与配置

第一课、Cocos Creator 3.8 安装与配置

介绍说明 本文主要介绍在windows系统中&#xff0c;安装开发Cocos使用的软件工具&#xff0c;主要包含&#xff1a;安装CocosDashboard控制面板、CocosCreator3.8编辑器和脚本编辑器 VS Code 。 一、Cocos Dashboard 的安装 说明&#xff1a;Cocos Dashboard 主要作用是能够同…
阅读更多...
从航空FACE的一个落地方案漫谈汽车HPC软件架构的思维转变（2/3）FACE的“段”同Autosar的“层”概念区别探索

从航空FACE的一个落地方案漫谈汽车HPC软件架构的思维转变（2/3）FACE的“段”同Autosar的“层”概念区别探索

文章目录PART THREE&#xff1a;段和层的概念比较一、“段”更强调“功能闭环责任归属”&#xff0c;而非“单纯的层级堆叠”二、“段”规避“层”的“刚性依赖陷阱”&#xff0c;适配航空系统的“灵活组合需求”三、“段”贴合航空工业的“工程化语言习惯”&#xff0c;降低跨…
阅读更多...
金融量化指标--6InformationRatio信息比率

金融量化指标--6InformationRatio信息比率

InformationRatio信息比率计算公式添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09;一、信息比率&#xff08;IR&#xff09;是什么&#xff1f;核心概念&#xff1a;信息比率衡量的是投资组合经理相对于某个基准指数&#xff08;Benchmark&#xff09;&…
阅读更多...
Java全栈开发面试实录：从基础到微服务的实战经验分享

Java全栈开发面试实录：从基础到微服务的实战经验分享

Java全栈开发面试实录&#xff1a;从基础到微服务的实战经验分享 一、初识面试场景 我叫李明&#xff0c;28岁&#xff0c;毕业于复旦大学计算机科学与技术专业&#xff0c;硕士学历。在互联网行业已经有5年的工作经验&#xff0c;先后在两家中型互联网公司担任Java全栈开发工程…
阅读更多...
【51单片机】【protues仿真】基于51单片机公交报站系统

【51单片机】【protues仿真】基于51单片机公交报站系统

目录 一、主要功能 二、使用步骤 三、硬件资源 四、软件设计 五、实验现象 一、主要功能 主要功能如下&#xff1a; 1、LCD12864显示时间、日期、公交车车站、温度等 2、按键设置时间&#xff0c;显示公交车信息 3、串口播报相应站点信息 4、按键控制上行、下行、手动播…
阅读更多...
第1节-PostgreSQL入门-从表中查询数据

第1节-PostgreSQL入门-从表中查询数据

摘要&#xff1a;在本教程中,你将学习如何使用 PostgreSQL 的 SELECT 语句从表中检索数据。 SELECT 语句 要从表中查询数据,需使用 PostgreSQL 的 SELECT 语句。 以下是 SELECT 语句的基本语法: SELECT column1, column2, ... FROM table_name;在这种语法中: 首先,在 SELECT 关…
阅读更多...
【C++进阶】---- map和set的使用

【C++进阶】---- map和set的使用

1.序列式容器和关联式容器 前⾯我们已经接触过STL中的部分容器如&#xff1a;string、vector、list、deque、array、forward_list等&#xff0c;这些容器统称为序列式容器&#xff0c;因为逻辑结构为线性序列的数据结构&#xff0c;两个位置存储的值之间⼀般没有紧密的关联关系…
阅读更多...
430章:Python Web爬虫入门：使用Requests和BeautifulSoup

430章:Python Web爬虫入门：使用Requests和BeautifulSoup

在软件交付日益高频、用户需求快速迭代的今天&#xff0c;版本发布流程的规范性直接决定了团队的交付效率、产品质量和用户满意度。然而&#xff0c;许多团队仍面临以下痛点&#xff1a;发布混乱&#xff1a;分支管理随意&#xff0c;代码冲突频发&#xff1b;质量失控&#xf…
阅读更多...
代码随想录第七天|● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 18.四数之和

代码随想录第七天|● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 18.四数之和

本文所有题目链接/文章讲解/视频讲解&#xff1a;https://programmercarl.com/0454.%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0II.html 454.四数相加II 有四个数组&#xff0c;如果要遍历则时间复杂度太大 可以选择分组&#xff0c;a和b一组&#xff0c;c和d一组 这样就可以等同于…
阅读更多...
Vue3源码reactivity响应式篇之computed计算属性

Vue3源码reactivity响应式篇之computed计算属性

概述 vue3中&#xff0c;computed函数用于表示计算属性&#xff0c;有惰性求值、响应式追踪依赖的特点。本文将介绍computed的实现原理以及其机制细节。 源码解析 computed计算属性和computed方法、ComputedRefImpl类以及refreshComputed方法有关。 computed方法 computed暴露给…
阅读更多...
[嵌入式embed]Keil5烧录后STM32不自动运行,复位才能运行

[嵌入式embed]Keil5烧录后STM32不自动运行,复位才能运行

[嵌入式embed]Keil5烧录后STM32不自动运行,复位才能运行Keil5-验证“Reset and Run”功能是否生效参考文章Keil5-验证“Reset and Run”功能是否生效 参考文章 Keil5烧录后STM32不自动运行&#xff1f;必须复位才能启动的终极解决方案
阅读更多...
阿里云Qwen3系列模型部署微调评测

阿里云Qwen3系列模型部署微调评测

与阿里云一起轻松实现数智化让算力成为公共服务&#xff1a;用大规模的通用计算&#xff0c;帮助客户做从前不能做的事情&#xff0c;做从前做不到的规模。让数据成为生产资料&#xff1a;用数据的实时在线&#xff0c;帮助客户以数据为中心改变生产生活方式创造新的价值。模型…
阅读更多...
最新文章

Copyright @ 2022~2023