腾讯HY4 Preview实测：能力在线但是思考过度，不如DeepSeek V4 Flash，碰瓷Pro更是毫无意义！

[terry]

腾讯的这个 Hy4 Preview 发布了。讲实话，输入输出的价格它是不便宜的。这个是对标 GLM-5.3，对标这个什么 DeepSeek V4 Pro 了。然后它官方好像也发了一个测评，说是这个跑分比 DeepSeek V4 Pro 还要牛逼。这个相关的图大家去找一找吧，我就不找了，反正网上很多。

它这个是 770B，就是 7740 亿参数了，最大输入 96K，最大输出 64K。就这一项，它就不能跟 DeepSeek V4 Pro 比。它的激活参数是 49B，跟 DeepSeek V4 Pro 一样，它的总参就只有 DeepSeek V4 Pro 的一半还不到。像这样的尺寸，说跑分超过 DeepSeek V4 Pro，我觉得还是很惊艳的，因为毕竟只使用了这个一半的参数规模。但是讲实话，最近发布的这些模型跑分都很高，最后测起来的体验，并不是能够像他们宣传的一样去吊打 DeepSeek，所以说我决定还是测试一下吧。

首先必须说明，这个我是充了钱的，但是没办法用。原因就很简单，你看看，就经常是 429，Too Many Requests，就是请求太多，它这个太繁忙了，忙不过来。你可能要隔很久，它才会回复你的请求。那我们有办法吗？它官方不是有这个网页吗？我们用这个网页来测试一下。

首先让它生成一个网页，表达传统的八卦文化。就你没看错，就是这样。说实话，作为一个 7740 亿参数的模型，就生成这么一个玩意，这玩意还不如 Hy3，完全不如，就垃圾得很。
bagua1.html

但我经过昨天测试这个 GLM-5.3-Flash，我就认识到了，现在的模型走的都是 Claude 的这个套路，就是 Anthropic 的套路。必须要把这个思考给它开高，就是模型的原生能力其实基本上就是智障，就是弱智。但是你如果把它的这个思考模式给调得高一点，无论是千问也好，千问 3.8 Flash，还是 GLM-5.3 也好，还是今天我们测的腾讯 Hy4 Preview 也好，它立刻就变了。

就这么一个屁大的网页，它给我生成了十分钟时间。看看，713 秒，整整十分钟，然后它就变聪明了，效果就变好了。我们预览一下，看是不是病好了。你看，这个也对了。太极生两仪，两仪生四象，四象生八卦。卦位，乾巽，乾坤离坎。先天八卦我记得不清楚了，离坎震兑乾……这他妈对吗？我感觉好像也不对。乾兑离震巽坎艮坤，是不是搞反了呀？
bagua2.html

反正这个网页确实进步很大。这个网页我基本上能够给它 90 分了，但是也不是特别惊艳，因为之前其他的模型我都跑了相关的测试，大家可以去翻一下。就说这个得分是高的，但是我认为跟昨天的 GLM-5.3-Flash 可能就是处于同一个水平，而且它的套路几乎是一模一样。但是人家只是 300B 参数，你这个 700 多 B 参数搞出这么个玩意，这有点说不过去了。而且你的定价也是远远高于 DeepSeek V4 Flash，也是高于 GLM-5.3-Flash。

经过刚才这个测试，我就不敢给它把这个什么思考模式关掉了，肯定要给它开到高。然后现在让它生成一个 SVG，表达钍基熔盐堆的运行原理。它这个 UI 做得也是烂得一逼，就这么一个简单的 SVG，你在这里做一个预览怎么了嘛？你都做不了，也不知道腾讯是怎么想的。

这个是它的成品。这个玩意跟千问 3.8 27B 是同一个水平，并且它是在花了很长时间的情况下生成的。我们看看时间，口说无凭，十分钟。我可以负责任地说，千问 3.8 这个 27B，它可能只需要一分钟不到，最多两分钟，就能把这个问题搞定。当然了，前提是把这个思考模式给它关掉。如果是 DeepSeek V4 Flash，差不多也是这个水平吧。

下面就是生成一个 SVG，表达薛定谔的猫思想实验。这个也花了将近十分钟，这是九分钟。我们看看效果。薛定谔在这。这个生成的效果不错，非常准确地反映了各个实验的要素，原理总结得非常好，这个样式非常清晰，做得不错，猫画得也比较可爱。我给 95 分，这个能力是相当不错的。它肯定是比昨天那个什么 GLM-5.3-Flash 要强，这块是不错的。

但是我跟大家说，每个模型在每一个任务中，它可能表现都有高有低。我们不要通过一个任务就判断一个模型怎么样，不要这样。总体上我们多测一下，尽可能地多测一下，然后最终评判。

然后我是想把它接入 API 来测试一下，就没办法，它这个请求太繁忙了，处理不过来。但是我把这个思考模式开到高之后，就有一次瞎猫碰死耗子，碰巧了，它没有请求繁忙，给我生成了。用这个 Codex，一般而言 Codex 对于编码是有加成的。就是说你模型本身可能比较傻逼，但是接入 Codex 之后，Codex 通过它的 Harness 工程，能够把你这个代码能力给它优化一下，效果会变得更好。

但是显然，把腾讯这个 Hy4 Preview 的思考模式调高之后，它并没有得到这么好的效果。这就是我昨天在视频中跟大家强调的。有些人说，你怎么有一种主观偏见，就是来判定说什么 GLM-5.3-Flash 内置 Harness 工程到 API 中是一种邪路，是一条不归路呢？现在是不是能够验证这个问题？

就是说你这个 Harness 工程本身并不是模型的原生能力。你把这个 Harness 工程给内置到 API 中，会导致什么呢？你外部的这些 Harness 软件、这些框架，它没有办法原生优化你的 API。因为这个工作到底是放到 API 内部，还是放到 Harness 软件中，还是放到这个调度框架中来呢？

我一直不看好 Anthropic 的发展路线，也是因为这个原因。它把大量本来应该放到 Harness 软件中的这些工作给内置到了 API 内部。它的 API 看起来得分比较高，然后做出来的效果也比较好，但是它后期的优化空间、提升空间是很小的，并且它消耗了大量的资源，它的响应速度也是相当的慢，慢到便秘。你如果同样一个任务交给 GPT 和 Claude 来处理，那么 Claude 可以说就是龟速，GPT 的响应速度就要好很多。

同样，我们如果说是调用 DeepSeek，为什么我非常推崇 DeepSeek？就是 DeepSeek 可以完全把思考给它关掉，完全关掉。你说影不影响智力？有一点点影响，但是影响得微乎其微。我在调所有的 DeepSeek API 的时候，看到没有，你看它默认都是轻度，这个就是最低的了。要么就是像我在 DeepSeek Harness 中的这样，看到没有，我是直接把这个推理等级给关掉的。

因为只有这样，才能反映你模型本身的能力。我们不需要官方 API 内置过多的 Harness 工程，我们希望把这个掌控权放到我们自己的手中。比如说像我们现在比较好的一些 Harness 软件，像 DSH，DeepSeek Harness，或者是评论区很多人比较推荐的 PI Agent。那么这样把能力交给 Harness 工程来调度，Harness 框架来调度，而不是把它内置到模型的 API 中。

因为你这样的跑分，讲实话，胜之不武。你拿你这种花 20 分钟时间生成的代码，跟人家 DeepSeek V4 Pro 花几分钟时间生成的代码来比，你赢了又能怎么样呢？而且大家不要认为它这个长时间的思考是免费的，这不是免费的。

我们在执行长链编程任务的时候，大部分时候我们的缓存命中率在 99% 甚至 100%。如果缓存命中的话，价格就是白菜价，非常便宜。但是这个思考是作为输出，它是计入输出价格的。输出价格是最贵的价格，你知道吗？是最贵的，它不是免费的。可能两个 API 官方差价不大，但是如果说你思考过度的话，你的这个 API 调用费用很有可能是对方的好几倍，甚至不夸张地说，5 倍、10 倍都有可能。

由于这个在本地，我接 Agent 没有办法像以前一样，比如说我让它继续我这个 App 开发，你看千问 3.8 也在做。没有办法测怎么办？那我就继续测一下它的基础能力。有些东西是能够反映出一个模型的真正智力的。就很简单嘛，本来我想让它写二叉树的，但是我觉得怎么说呢，让它写一个更简单一点的吧，Ring Buffer 吧，因为可能很多观众看不懂数据结构。

让它生成一个 Ring Buffer，我们看一看。这花了几分钟的时间？四五分钟的时间，四分钟。看它实现的代码，看它自己怎么说的。它说这个代码是非线程安全的。我真的是服了，你一个 Pro 级别的模型，你给我生成一个 Ring Buffer，然后告诉我它是非线程安全的，那这个代码本身有什么意义呢？你是写一个玩具吗？思考了四分钟时间，给出他妈这种代码来，我真的也是服了。

看一看嘛，数据结构对的，函数对，状态查询、字节、批量读写、长度、实现函数，基本的要素都已经有了。这个它能跑起来，我应该是不用怀疑的。看看它实现的细节。这个地方 Ring Buffer 你传进来，最基础的，我没有详细去看，最基础的你这个地方要做一个空指针的判断。当然了，我们一般情况下调用它也不会传一个空指针进来，但是你这个时候要对 NULL 进行一个判断。

#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>

/*==================== 环形缓冲区（字节型 FIFO） ====================*/
typedef struct {
    uint8_t *buffer;   /* 指向用户提供的存储数组 */
    size_t capacity;   /* 总容量（字节数） */
    size_t head;       /* 写指针：下一个写入位置 */
    size_t tail;       /* 读指针：下一个读取位置 */
    size_t count;      /* 当前已用字节数 */
} ring_buffer_t;

void rb_init(ring_buffer_t *rb, uint8_t *buf, size_t capacity) {
    rb->buffer = buf;
    rb->capacity = capacity;
    rb->head = 0;
    rb->tail = 0;
    rb->count = 0;
}

void rb_reset(ring_buffer_t *rb) {
    rb->head = 0;
    rb->tail = 0;
    rb->count = 0;
}

/*==================== 状态查询 ====================*/
size_t rb_capacity(const ring_buffer_t *rb)   { return rb->capacity; }
size_t rb_size(const ring_buffer_t *rb)       { return rb->count; }
size_t rb_free_space(const ring_buffer_t *rb) { return rb->capacity - rb->count; }
int rb_is_empty(const ring_buffer_t *rb)      { return rb->count == 0; }
int rb_is_full(const ring_buffer_t *rb)       { return rb->count == rb->capacity; }

/*==================== 单字节读写 ====================*/
/* 写入一个字节；成功返回 0，缓冲区满返回 -1 */
int rb_put(ring_buffer_t *rb, uint8_t data) {
    if (rb_is_full(rb)) return -1;
    rb->buffer[rb->head] = data;
    rb->head = (rb->head + 1) % rb->capacity;
    rb->count++;
    return 0;
}

/* 读取一个字节到 *data；成功返回 0，缓冲区空返回 -1 */
int rb_get(ring_buffer_t *rb, uint8_t *data) {
    if (rb_is_empty(rb)) return -1;
    *data = rb->buffer[rb->tail];
    rb->tail = (rb->tail + 1) % rb->capacity;
    rb->count--;
    return 0;
}

/* 强制写入：若已满，则覆盖最旧的数据 */
void rb_put_overwrite(ring_buffer_t *rb, uint8_t data) {
    rb->buffer[rb->head] = data;
    rb->head = (rb->head + 1) % rb->capacity;
    if (rb_is_full(rb)) {
        /* 已满：丢弃最旧的一个字节，tail 前移，count 保持不变 */
        rb->tail = (rb->tail + 1) % rb->capacity;
    } else {
        rb->count++;
    }
}

/*==================== 批量读写（高效，自动处理回绕） ====================*/
/* 写入 len 字节，返回实际写入的字节数（空间不足时小于 len） */
size_t rb_write(ring_buffer_t *rb, const uint8_t *src, size_t len) {
    size_t written = 0;
    if (len > rb_free_space(rb)) len = rb_free_space(rb);
    while (len > 0) {
        size_t to_end = rb->capacity - rb->head;   /* 到缓冲区末尾的连续空间 */
        size_t chunk = (len < to_end) ? len : to_end;
        memcpy(&rb->buffer[rb->head], src, chunk);
        rb->head = (rb->head + chunk) % rb->capacity;
        rb->count += chunk;
        src += chunk;
        written += chunk;
        len -= chunk;
    }
    return written;
}

/* 读取 len 字节到 dst，返回实际读取的字节数（数据不足时小于 len） */
size_t rb_read(ring_buffer_t *rb, uint8_t *dst, size_t len) {
    size_t read = 0;
    if (len > rb->count) len = rb->count;
    while (len > 0) {
        size_t to_end = rb->capacity - rb->tail;   /* 到缓冲区末尾的连续数据 */
        size_t chunk = (len < to_end) ? len : to_end;
        memcpy(dst, &rb->buffer[rb->tail], chunk);
        rb->tail = (rb->tail + chunk) % rb->capacity;
        rb->count -= chunk;
        dst += chunk;
        read += chunk;
        len -= chunk;
    }
    return read;
}

/*==================== 测试示例 ====================*/
int main(void) {
    uint8_t storage[8];
    ring_buffer_t rb;
    rb_init(&rb, storage, sizeof(storage));

    /* 1. 批量写入 10 字节，但容量只有 8，实际写入 8 字节 */
    const char *msg = "abcdefghij";
    size_t w = rb_write(&rb, (const uint8_t *)msg, 10);
    printf("1) write %zu bytes (capacity=%zu)\n", w, rb_capacity(&rb));

    /* 2. 批量读取 */
    uint8_t out[16];
    size_t r = rb_read(&rb, out, sizeof(out));
    out[r] = '\0';
    printf("2) read %zu bytes: %s\n", r, (char *)out);   /* 应输出：abcdefgh */

    /* 3. 覆盖写测试：容量 8，写入 10 个字节 'a'~'j' */
    rb_reset(&rb);
    for (int i = 0; i < 10; i++) {
        rb_put_overwrite(&rb, (uint8_t)('a' + i));
    }
    printf("3) after overwrite, size=%zu, data=", rb_size(&rb));
    uint8_t b;
    while (rb_get(&rb, &b) == 0) putchar(b);             /* 应输出：cdefghij */
    putchar('\n');

    /* 4. 单字节 FIFO 测试 */
    rb_reset(&rb);
    rb_put(&rb, 'X');
    rb_put(&rb, 'Y');
    rb_put(&rb, 'Z');
    printf("4) FIFO get: ");
    while (rb_get(&rb, &b) == 0) putchar(b);             /* 应输出：XYZ */
    putchar('\n');

    return 0;
}

rb->head 取模加一，它这个地方为什么要取模呢？我没搞清楚。这个 head 肯定是小于 capacity 的，你做一个 if 判断，它的效率不是更高吗？直接 ++ 就行了呀，rb->head++，做一个 if 判断，防止它溢出。

卧槽，它怎么这么喜欢取模呀？大家可能不太懂 C 语言的语法，这个取模跟除法的开销，它是要比加法跟乘法大很多的。这个东西如果说在我们 PC 处理器上可能影响不大，但是如果说你把它放到嵌入式的设备中，它实际上影响是比较大的，这个玩意是没办法优化的，就非常地不解。而且你这么多取模的情况下，你也没有对 capacity 是 0 这种情况进行判断。这个还不仅仅是能不能取模的问题，它会造成很多问题。

这个环形 Buffer 我个人就不深入谈了，因为很多人可能不懂 C 语言的语法。这个东西得分我只能给它 50 分，很难说给它及格。它的语法还是比较干脆的，基础是有的，但是我认为它对于生产环境的理解不够。尤其是在你自己明确说它不是线程安全的这种情况下，你还给我这个代码，这个就基本上是扯淡了，就没用。你带锁这个是最基本的要求。

总而言之，就是这个模型可能有它的独特之处。你看看，确实经过长时间的思考之后，它刚才生成的这几个网页也好，我把它下载下来了，还是这个 SVG 也好，我个人认为生成的质量都是比较高的，我都是能够给到 95 分的。

但是这个代价跟昨天的 GLM-5.3-Flash 一样。所以说我在视频中，像我这种性格的人，当然也比较急躁，我也不是专家嘛，像我经常去喷这些 AI 厂商，我说这条路是毒药，是一条不归路，这是非常恶劣的习惯。这是我个人情绪，当然可能别人并不一定会这么想。

有的人可能不在乎，我一个任务交给它，它反正一个小时完成，跟十分钟完成也没什么差别。这些人也不会用 AI 来编程，更不会用 AI 来投入生产。他们对于 AI 的理解，就是打开一个网页聊天框，然后吭哧吭哧地打，等半天，等它回出一个消息。哇，这个消息不错，很惊艳，95 分，哇，666，碾压 DeepSeek。

就是他们没想过，企业如果用这个玩意来生产的话，那真的是要了命了。第一，这个时间成本高得惊人。第二，它的 Tokens 消耗应当也是要比模型原生能力强的情况下高很多。

这个说白了就是之前我预测的，就是 Anthropic 搞的这个路线，它会带坏一大批公司。这些公司发布的模型，它不以提升生产力为目标，相反以刷分、骗投资、骗消费者为目标。消费者又不是傻子。非常地失望。

当然了，我相信这个模型也是刚刚发布。就像我给千问时间一样，我们也要给千问、GLM，给它们一点时间。但是我还是想说，在这种情况下，DeepSeek 这家公司为什么值得尊敬？就是人家发布的每一个模型，还是 Harness，人家展现出来的是扎扎实实的生产力。人家不做这种宣传，不做这种无聊的宣传。

你的能力没达到顶尖，你宣布达到顶尖，有什么意义呢？如果宣布能够作数的话，我宣布我跟马斯克、马云一起统治了世界，还有马化腾，是不是？我一人挑三马。

钱反正已经充了，也就 10 块钱。等过两天这个 Hy4 正式发布了，到时候我们再来测一下，看看它的效率有没有提升。反正我讲实话，就现在把它接入 Agent，这个响应的速度，我简直真的是吐血了。

也不知道怎么回事，就这么一股歪风邪气，就能忽然间影响大半个 AI 世界。唉，人心不古，世风日下。

[terry]

Youtube Video