KIMI 与文心一言、通义千问大模型能力对比评测

对比分析

背景信息： 杭州于 3 月 14 日取消了二手房限购政策。

结果评估：

• 通义千问： 政策信息滞后（引用 2022 年 5 月 17 日政策），未给出具体可购买数量，表现较差。
• KIMI： 唯一给出正确答案的模型。得益于其实时联网搜索能力，正确检索到了取消限购的最新政策。
• 文心一言： 未更新 3 月 14 日的政策内容，仍按旧政策回答，结果错误。

小结： KIMI > 文心一言 > 通义千问

问题三：河北邯郸 3 名不满十四周岁初中生杀害同班同学并掩埋，请问这三名初中生在法律上会受到什么惩罚？

KIMI

文心一言

通义千问

对比分析

结果评估：

• 通义千问： 未给出明确答案。
• 文心一言： 与 KIMI 回答基本一致，但在细节上更强，明确引用了《刑法》第十七条作为法律依据。
• KIMI： 回答内容与文心一言基本相同，逻辑清晰。

小结： 文心一言 > KIMI > 通义千问

问题四：使用 JAVA 代码合成部门树

输入数据：

[
    {"id": 1, "pid": 0, "name": "产品研发中心"},
    {"id": 2, "pid": 1, "name": "后端"},
    {"id": 3, "pid": 1, "name": "前端"},
    {"id": 4, "pid": 2, "name": "JAVA"},
    {"id": 5, "pid": 3, "name": "JS"},
    {"id": 6, "name": "测试数据"}
]

*注：最后一条为故意造的错误数据（缺少 pid）。

KIMI 代码

import com.google.gson.Gson;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

class Department {
    int id;
    String name;
    List<Department> children = new ArrayList<>();
    public Department(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public void addChild(Department child) {
        children.add(child);
    }
    public static Department fromJson(Map<String, Object> jsonMap) {
        return new Department((Integer) jsonMap.get("id"), (String) jsonMap.get("name"));
    }
}
public class DepartmentTreeBuilder {
    public static Department buildTree(List<Map<String, Object>> departments) {
        Map<Integer, Department> departmentMap = new HashMap<>();
        List<Department> roots = new ArrayList<>();
        for (Map<String, Object> deptJson : departments) {
            int id = (Integer) deptJson.get("id");
            String name = (String) deptJson.get("name");
            Department dept = Department.fromJson(deptJson);
            departmentMap.put(id, dept);
            if (deptJson.get("pid") != null && ((Integer) deptJson.get("pid")).equals(0)) {
                roots.add(dept);
            }
        }
        for (Map<String, Object> deptJson : departments) {
            int id = (Integer) deptJson.get("id");
            Integer pid = (Integer) deptJson.get("pid");
            if (pid != null && pid != 0 && departmentMap.containsKey(pid)) {
                Department dept = departmentMap.get(id);
                Department parent = departmentMap.get(pid);
                if (parent != null) {
                    parent.addChild(dept);
                }
            }
        }
        return roots.isEmpty() ? null : roots.get(0);
    }

    public static void main(String[] args) {
        // 测试代码略
    }
}

文心一言代码

public class DepartmentTreeBuilder {  
    public static void main(String[] args) {  
        List<Department> departments = new ArrayList<>();  
        departments.add(new Department(1, 0, "产品研发中心"));  
        departments.add(new Department(2, 1, "后端"));  
        departments.add(new Department(3, 1, "前端"));  
        departments.add(new Department(4, 2, "JAVA"));  
        departments.add(new Department(5, 3, "JS"));  
        departments.add(new Department(6, 0, "测试数据"));  

        List<Department> tree = buildDepartmentTree(departments);  
        for (Department dept : tree) {  
            printDepartmentTree(dept, 0);  
        }  
    }  

    public static List<Department> buildDepartmentTree(List<Department> departments) {  
        Map<Integer, Department> idMap = new HashMap<>();  
        List<Department> tree = new ArrayList<>();  

        for (Department dept : departments) {  
            idMap.put(dept.getId(), dept);  
        }  

        for (Department dept : departments) {  
            if (dept.getPid() == 0) {  
                tree.add(dept);  
            } else {  
                Department parent = idMap.get(dept.getPid());  
                if (parent != null) {  
                    if (parent.getChildren() == null) {  
                        parent.setChildren(new ArrayList<>());  
                    }  
                    parent.getChildren().add(dept);  
                }  
            }  
        }  

        return tree;  
    }  

    public static void printDepartmentTree(Department dept, int level) {  
        for (int i = 0; i < level; i++) {  
            System.out.print("--");  
        }  
        System.out.println(dept.getName());  
        if (dept.getChildren() != null) {  
            for (Department child : dept.getChildren()) {  
                printDepartmentTree(child, level + 1);  
            }  
        }  
    }  

    static class Department {  
        private int id;  
        private int pid;  
        private String name;  
        private List<Department> children;  

        public Department(int id, int pid, String name) {  
            this.id = id;  
            this.pid = pid;  
            this.name = name;  
        }  

        public int getId() { return id; }  
        public int getPid() { return pid; }  
        public String getName() { return name; }  
        public List<Department> getChildren() { return children; }  
        public void setChildren(List<Department> children) { this.children = children; }  
    }  
}

通义千问代码

class Department {
    int id;
    int pid;
    String name;
    List<Department> children = new ArrayList<>();

    Department(int id, int pid, String name) {
        this.id = id;
        this.pid = pid;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Department{" +
                "id=" + id +
                ", pid=" + pid +
                ", name='" + name + '\'' +
                ", children=" + children +
                '}';
    }

    static Department buildDepartmentTree(List<Department> depts) {
        Map<Integer, Department> map = new HashMap<>();
        for (Department dept : depts) {
            map.put(dept.id, dept);
        }

        for (Department dept : depts) {
            if (map.containsKey(dept.pid)) {
                map.get(dept.pid).children.add(dept);
            }
        }

        return map.values().stream()
                .filter(d -> d.pid == 0)
                .findFirst()
                .orElse(null);
    }

    public static void main(String[] args) {
        List<Department> depts = new ArrayList<>();
        depts.add(new Department(1, 0, "产品研发中心"));
        depts.add(new Department(2, 1, "后端"));
        depts.add(new Department(3, 1, "前端"));
        depts.add(new Department(4, 2, "JAVA"));
        depts.add(new Department(5, 3, "JS"));
        depts.add(new Department(6, -1, "测试数据"));

        Department root = buildDepartmentTree(depts);
        System.out.println(root);
    }
}

对比分析

• 通义千问： 代码能正确执行，写法简洁，使用了 Lambda 表达式，代码生成质量较高。
• KIMI： 生成的代码中 Department 类缺少 pid 字段定义，且逻辑处理存在瑕疵，无法直接运行。
• 文心一言： 代码能正确执行，结构完整，但相比通义千问略显冗长。

小结： 通义千问 > 文心一言 > KIMI

问题五：使用 JAVA 处理数据

需求： 去除根组织和部门 ID，将部门名用 - 分隔输出。

对比分析

• 通义千问： 多去除了部分中间层级（如'侠客集团'），结果不完整。
• 文心一言： 仅保留了根组织未去除，其余处理正确，表现最好。
• KIMI： 输出错误，未去除部门 ID，表现最差。

小结： 文心一言 > 通义千问 > KIMI

问题六：多线程图片下载

需求： JDK8 编写代码，多线程下载指定 URL 到本地，处理文件名重复问题。

对比分析

• KIMI： 代码存在错误，无法运行。未考虑下载目录不存在的情况。文件名重复处理思路（加后缀 N）正确但实现有误。
• 文心一言： 代码需修改异常抛出才能运行。文件名重复处理使用 MD5，思路独特但可能增加复杂度。
• 通义千问： 代码能正常运行，逻辑完善。考虑了目录创建，使用时间戳处理文件名冲突，实用性强。

小结： 通义千问 > 文心一言 > KIMI

总结与深度分析

通过上述六道题目的实测，我们可以得出以下结论：

1. 数据源依赖差异： KIMI 的表现高度依赖其实时联网搜索能力。在处理时效性强的问题（如楼市政策、天气）时优势明显；但在缺乏实时数据支撑的通用知识或代码生成任务中，若搜索策略不当，容易产生幻觉或错误。
2. 代码生成成熟度： 在 Java 代码生成领域，通义千问展现了较高的稳定性，特别是在处理并发、IO 流及文件操作等复杂逻辑时，代码健壮性优于 KIMI。KIMI 在基础语法和类结构定义上偶尔出现遗漏。
3. 逻辑推理与细节： 文心一言在法律条文引用和数据处理逻辑上表现稳健，细节把控较好，但在实时信息获取上稍逊一筹。
4. 行业现状思考： '百模大战'背景下，各模型各有千秋。KIMI 的火爆更多源于其在长文本处理和搜索整合上的突破，而非全能的智能体。对于开发者而言，选择模型应结合具体场景：需要实时资讯可选 KIMI，需要稳定代码生成可选通义千问，需要综合逻辑推理可选文心一言。
5. 未来展望： 随着 RAG（检索增强生成）技术的普及，大模型的准确性将进一步提升。国内大模型厂商需在垂直领域深耕，提升专业数据的训练质量，减少对外部搜索引擎的过度依赖，才能真正实现技术自主可控。

综上所述，目前尚无一款大模型在所有维度上完全碾压对手。用户应根据实际需求灵活选择，并保持对新技术的持续学习与验证。