国产大模型对比，谁家AI更聪明
近年来，国内的人工智能领域取得了显著的进展，其中大规模预训练模型在各个领域发挥着重要作用。本文将测试国内几款大模型，看看他们在同一需求下的表现如何？
需求：写一个java函数BigDecimal的表达式运算
文心一言：
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalCalculator {
public static BigDecimal calculate(String expression) {
String[] operators = {"+", "-", "\*", "/"};
BigDecimal[] numbers = expression.split("\\s+");
BigDecimal result = new BigDecimal(numbers[0]);
for (int i = 1; i < numbers.length; i++) {
for (String operator : operators) {
if (numbers[i].contains(operator)) {
BigDecimal operand1 = new BigDecimal(numbers[i].split(operator)[0]);
BigDecimal operand2 = new BigDecimal(numbers[i].split(operator)[1]);
switch (operator) {
case "+":
result = result.add(operand1).add(operand2);
break;
case "-":
result = result.subtract(operand1).subtract(operand2);
break;
case "\*":
result = result.multiply(operand1).multiply(operand2);
break;
case "/":
result = result.divide(operand1, 2, RoundingMode.HALF_UP).multiply(operand2);
break;
}
} else {
result = result.add(new BigDecimal(numbers[i]));
}
}
}
return result;
}
}
讯飞星火大模型：
import java.math.BigDecimal;
public class BigDecimalExample {
public static void main(String[] args) {
BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("2.3");
BigDecimal result = add(num1, num2);
System.out.println("相加结果： " + result);
}
public static BigDecimal add(BigDecimal num1, BigDecimal num2) {
return num1.add(num2);
}
}
FuncGPT（慧函数）：
// 类名：BigDecimalCalculator
// 函数名：calculateExpression
// 函数功能：使用BigDecimal计算表达式的结果
// POM依赖包：
// <dependency>
// <groupId>org.apache.commons</groupId>
// <artifactId>commons-lang3</artifactId>
// <version>3.12.0</version>
// </dependency>
import org.apache.commons.lang3.StringUtils;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Stack;
public class BigDecimalCalculator {
/**
* 使用BigDecimal计算表达式的结果
* @param expression 要计算的表达式
* @return 计算结果
*/
public static BigDecimal calculateExpression(String expression) {
if (StringUtils.isBlank(expression)) {
throw new IllegalArgumentException("Expression cannot be blank");
}
Stack<BigDecimal> numberStack = new Stack<>();
Stack<Character> operatorStack = new Stack<>();
for (int i = 0; i < expression.length(); i++) {
char ch = expression.charAt(i);
if (Character.isDigit(ch)) {
StringBuilder sb = new StringBuilder();
while (i < expression.length() && (Character.isDigit(expression.charAt(i)) || expression.charAt(i) == '.')) {
sb.append(expression.charAt(i));
i++;
}
i--;
BigDecimal number = new BigDecimal(sb.toString());
numberStack.push(number);
} else if (ch == '(') {
operatorStack.push(ch);
} else if (ch == ')') {
while (!operatorStack.isEmpty() && operatorStack.peek() != '(') {
BigDecimal result = performOperation(numberStack, operatorStack);
numberStack.push(result);
}
if (!operatorStack.isEmpty() && operatorStack.peek() == '(') {
operatorStack.pop();
}
} else if (isOperator(ch)) {
while (!operatorStack.isEmpty() && hasHigherPrecedence(ch, operatorStack.peek())) {
BigDecimal result = performOperation(numberStack, operatorStack);
numberStack.push(result);
}
operatorStack.push(ch);
}
}
while (!operatorStack.isEmpty()) {
BigDecimal result = performOperation(numberStack, operatorStack);
numberStack.push(result);
}
return numberStack.pop();
}
private static boolean isOperator(char ch) {
return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}
private static boolean hasHigherPrecedence(char op1, char op2) {
if ((op1 == '*' || op1 == '/') && (op2 == '+' || op2 == '-')) {
return true;
}
return false;
}
private static BigDecimal performOperation(Stack<BigDecimal> numberStack, Stack<Character> operatorStack) {
BigDecimal num2 = numberStack.pop();
BigDecimal num1 = numberStack.pop();
char operator = operatorStack.pop();
BigDecimal result;
switch (operator) {
case '+':
result = num1.add(num2);
break;
case '-':
result = num1.subtract(num2);
break;
case '*':
result = num1.multiply(num2);
break;
case '/':
result = num1.divide(num2, 2, RoundingMode.HALF_UP);
break;
default:
throw new IllegalArgumentException("Invalid operator");
}
return result;
}
}
// 函数示例
// 使用BigDecimal计算表达式的结果示例
// 入参：expression，要计算的表达式
// 出参：result，计算结果
// 调用示例：
// String expression = "2.5 + 3 * (4 - 1)";
// BigDecimal result = BigDecimalCalculator.calculateExpression(expression);
// System.out.println(result);
// 输出结果：例如，计算表达式"2.5 + 3 * (4 - 1)"的结果为：11.5
// 则输出结果为：11.5
来看看多维度的对比结果
- 文心一言 vs 慧函数
文心一言 |
慧函数 |
生成时间：1分钟 |
生成时间：25秒 |
不够灵活，可扩展性差
使用字符串分割和循环的方式逐步计算表达式 |
更加灵活和可扩展
慧函数使用栈的数据结构来处理表达式中的操作符和数字，通过读取每一个字符，并根据情况进行相应的处理。 |
运算误差更大
在处理除法时使用了 RoundingMode.HALF_UP进行四舍五入 |
运算误差更小
默认进行了两位小数精度的保留，可以在计算结果中直接得到保留两位小数的精确结果 |
代码健壮性不足 |
代码健壮性更好
利用了Apache Commons Lang库中的StringUtils工具类判断表达式是否为空或空格。 |
总结：慧函数生成的代码更加模块化、可读性和可扩展性更好，同时也减少了一些运算过程中的误差 |
|
- ChatGPT vs 慧函数
ChatGPT |
慧函数 |
生成时间：21秒 |
生成时间：25秒 |
方法繁琐，存在漏洞
虽然使用了递归方法来计算表达式，但递归实现的过程较为繁琐，容易出错。对于较复杂的表达式，代码2的递归方法可能会导致栈溢出或性能问题。
|
代码结构清晰，易于理解和维护
使用了栈的数据结构来处理表达式的计算，这样可以准确地处理运算符的优先级和括号的嵌套。代码实现清晰明了，将不同的逻辑功能封装成了独立的函数，使得代码的结构更加清晰，易于理解和维护。 |
代码健壮性不足 |
代码健壮性更好
提供了异常处理机制，通过抛出IllegalArgumentException来处理非法输入，增加了代码的健壮性。 |
总结：慧函数生成的代码在可读性、可维护性和健壮性方面更好。 |
|
那么这三组代码哪个好呢，看看第三方的大模型怎么说
讯飞星火大模型：
Ps：第一组文心一言、第二组讯飞星火、第三组FuncGPT（慧函数）
据了解：FuncGPT（慧函数）能够极大地提高开发者的编程效率，让开发者从日常简单重复的“写代码”中抽离出来，原来需要花费 80% 的编码时间，交给 AI 工具来完成，同时配以代码实时可见，人机交互-智脑等特色功能，在助力开发人员效率和质量双提升的基础上，解放自己能够更加专注于 20% 的工作，站在更高的角度深入思考问题，从“程序员”变成“架构师”，从“写代码”变成“设计程序”，彻底释放每个开发者的创新潜能。
感兴趣的小伙伴也可以免费使用一波：https://c.suo.nz/aQ9xU
- 点赞
- 收藏
- 关注作者
评论（0）