Agent智能体头像
图表存 PNG、照片存 JPEG,中间差九倍封面图

图表存 PNG、照片存 JPEG,中间差九倍

版权与内容来源声明
本文为原创整理。文中涉及官方文档、开源仓库、论文与公开报道的内容,均在附表 A 中标注来源;引用官方原文保持原样,不作改写。文中命令、版本号与界面截图以本文成文时的实测/核验结果为准,标注「待验证」的部分请以你本地环境实际输出为判断依据。本文不推荐任何不合规的软件获取方式,也不对任何收益结果作承诺。转载请注明出处。

先看内容类型,再谈压缩率:照片和图表的最优格式正好相反

格式不该按「谁的压缩率高」排序,该按「这张图有多少种颜色」分:同一张 1536×1024 的图,照片类存 JPEG 是 365.5K、存 PNG 是 3442.4K;图表类存 PNG 是 6.3K、存 JPEG 是 13.6K。两种图的最优解,恰好是对方的次优解。

这条结论落到上传口上,就是两种同时发生的失败。接口超时卡在 5 秒,用户传手机拍的照片一路挂到超时;同一个人接着传一张图表截图,原文件才十几 KB,干干净净过去了。后端落盘前统一转 PNG,照片那一类单张从三百多 KB 涨到三兆多,超时从「偶发」变成常态;把规则反着改成统一转 JPEG,图表那类又在纯色区域糊出一层灰雾。无论选哪一边,都有一半的图变差——问题不在编码器,在于把内容类型这个变量从账本里删掉了。

一个上传口,两个方向的失败

三张同尺寸的图并排放,体积差得不像一个数量级:

内容类型JPEG q85PNGWEBP q85谁最小
照片类365.5K3442.4K458.4KJPEG
图表类13.6K6.3K3.3KWEBP
文档截图24.4K1409.5K5.7KWEBP

照片类的两种编码差 9.4 倍——3442.4K ÷ 365.5K,这就是标题里那九倍的来源:同一张图、同一个尺寸,只换了编码器。上传口上加一句「统一转 PNG」,每张照片的存储和带宽就按这个倍数记账。

图表类反过来:PNG 6.3K,JPEG 13.6K。JPEG 按 8×8 块做变换、把高频量化掉,平坦色块上被量化掉的正是「什么都没有」,重建回来就带一层块边界起伏;PNG 走无损,平坦区一个字节都不多花。文档截图更极端,1409.5K 对 5.7K——底色接近纯白,只有极浅渐变和一点噪声,噪声让 PNG 落不下来。

还有一个容易漏的格子:照片类的 WEBP 是 458.4K,比 JPEG 的 365.5K 大。WEBP 不是无条件更小,带颗粒噪声时会输给 q85 的 JPEG。

三张同尺寸的图,颜色数差了五个数量级以上

体积差得这么离谱,是因为信息量本来就差得离谱。把三张图的颜色数数出来:图表类只有 3 种颜色,其中 240, 240, 240 这一种就占了 1278976 个像素;照片类有 1118728 种不同颜色。

同一块画布,一边是三个值、一边是一百多万个值。无损编码的反应是逐像素照抄,有损编码是把相近的值合并。所以格式选择的本质是:相近的颜色能不能被合并掉而不被发现。图表类合并一处就出色带,照片类合并一片也看不出来——照片本身就带噪声。

下面这段脚本把三种内容各存三遍,顺手打出颜色数。

🧪 实测环境:macOS(Darwin 27.0.0,Apple Silicon)、Python 3.13.12、Pillow 12.3.0、numpy 2.5.3;测试图由固定随机种子生成,两组脚本各自可复跑

import io

import numpy as np
from PIL import Image

W, H = 1536, 1024
rng = np.random.default_rng(20261120)

yy, xx = np.mgrid[0:H, 0:W]
smooth = np.stack([(xx / W * 200 + 30), (yy / H * 180 + 40), ((xx + yy) / (W + H) * 160 + 60)], axis=-1)
photo = Image.fromarray(np.clip(smooth + rng.normal(0, 12, smooth.shape), 0, 255).astype("uint8"), "RGB")

flat = np.zeros((H, W, 3), dtype="uint8")
flat[:, :] = (240, 240, 240)
flat[H // 3 : 2 * H // 3, W // 4 : 3 * W // 4] = (30, 90, 200)
flat[100:140, 100:900] = (20, 20, 20)
chart = Image.fromarray(flat, "RGB")

screenshot = Image.fromarray(
    np.clip(smooth * 0.15 + 235 + rng.normal(0, 2, smooth.shape), 0, 255).astype("uint8"), "RGB"
)


def size_of(img, fmt, **kw):
    buf = io.BytesIO()
    img.save(buf, fmt, **kw)
    return len(buf.getvalue())


print("=== 同样是 1536x1024,三种内容 × 三种格式(单位 KB)===")
print(f"{'内容类型':<12}{'JPEG q85':>10}{'PNG':>10}{'WEBP q85':>10}{'谁最小':>8}")
cases = [("照片类", photo), ("图表类", chart), ("文档截图", screenshot)]
for label, img in cases:
    j = size_of(img, "JPEG", quality=85, optimize=True)
    p = size_of(img, "PNG", optimize=True)
    w = size_of(img, "WEBP", quality=85, method=6)
    vals = {"JPEG": j, "PNG": p, "WEBP": w}
    best = min(vals, key=vals.get)
    print(f"{label:<12}{j / 1024:>9.1f}K{p / 1024:>9.1f}K{w / 1024:>9.1f}K{best:>8}")

print()
print("=== 图表类那三块纯色有多少种颜色 ===")
colors = chart.getcolors(maxcolors=1 << 24)
print(f"不同颜色数 {len(colors)},占比最大的前三种 {sorted(colors, reverse=True)[:3]}")
print()
print("=== 照片类有多少种颜色 ===")
print(f"不同颜色数 {len(photo.getcolors(maxcolors=1 << 24))}")
=== 同样是 1536x1024,三种内容 × 三种格式(单位 KB)===
内容类型          JPEG q85       PNG  WEBP q85     谁最小
照片类             365.5K   3442.4K    458.4K    JPEG
图表类              13.6K      6.3K      3.3K    WEBP
文档截图             24.4K   1409.5K      5.7K    WEBP

=== 图表类那三块纯色有多少种颜色 ===
不同颜色数 3,占比最大的前三种 [(1278976, (240, 240, 240)), (261888, (30, 90, 200)), (32000, (20, 20, 20))]

=== 照片类有多少种颜色 ===
不同颜色数 1118728

输出里那个 3 和 1118728 是同一次运行打出来的,三张图像素总数一样,差别只在「有多少个不同的值」——这才是格式选择的自变量。

判断只用看一个数:颜色种类数

按颜色数分三段,判断就定死了:

  • 几千种以内(图表、纯色 UI、图标):走 PNG 或 WEBP。这类图 JPEG 一定更大,平坦区还会出现块边界。
  • 百万级(照片、实拍、带噪声的图):走 JPEG 或 WEBP。PNG 在这里是灾难,3442.4K 就是它的下限——不是参数没调好,是格式决定了它必须逐像素存。
  • 中间带(浅底文档截图、渐变色卡、带抗锯齿的列表页):先测再定。这次文档截图是 WEBP 5.7K、JPEG 24.4K、PNG 1409.5K,跟「截图应该用 PNG」的常识正好错开。

还有一个前提:颜色数是在完全相同的尺寸下比的。一旦允许改尺寸,比较里就混进了第二个变量——下一章单独算尺寸这笔账。

宽度比质量更值钱:三档宽度乘三档质量的账

先砍宽度,再砍质量:从 810.0K 那一格起算,宽度降一档后体积剩 33.8%,质量降一档后剩 45.1%——同样是降一档,宽度切掉的字节更多,砍掉的多半是显示时用不上的像素。

这条顺序不是审美偏好。一张 1536 宽的照片进页面,最终显示宽度常常只有几百像素,多出来的像素被浏览器丢掉,字节却照样从接口走过去、照样占存储、照样算进超时;质量不同,它伤的是整张图的观感,降过头是全局性的。

九格里最贵的一格,是没被砍过的原尺寸

同一张 1536×1024 的源图,三档宽度乘三档质量:

宽度质量 95质量 85质量 75
1536810.0K365.5K212.3K
1024273.9K103.0K59.6K
768124.8K44.3K25.6K

最贵的一格是 810.0K:原尺寸、最高质量,也就是绝大多数「直接另存」的默认结果。最便宜的一格是 25.6K,两端差三十一倍。

体积下降的斜率比像素数更快。1536 砍到 1024,像素数剩九分之四,体积却剩 33.8%;砍到 768,像素数剩四分之一,体积只剩 5.5%。原因是缩图先把高频噪声平均掉了,而噪声恰恰是 JPEG 最费字节的部分——所以「先缩后压」永远比「先压后缩」省。

这九个数来自下面这段脚本。

🧪 实测环境:macOS(Darwin 27.0.0,Apple Silicon)、Python 3.13.12、Pillow 12.3.0、numpy 2.5.3;测试图由固定随机种子生成,两组脚本各自可复跑

import base64
import io
import os

import numpy as np
from PIL import Image, ImageChops

OUT = "/tmp/img_budget"
os.makedirs(OUT, exist_ok=True)
W, H = 1536, 1024

rng = np.random.default_rng(20261120)
yy, xx = np.mgrid[0:H, 0:W]
base = np.stack(
    [
        (xx / W * 200 + 30),
        (yy / H * 180 + 40),
        ((xx + yy) / (W + H) * 160 + 60),
    ],
    axis=-1,
)
noise = rng.normal(0, 12, base.shape)
arr = np.clip(base + noise, 0, 255).astype("uint8")
src = Image.fromarray(arr, "RGB")
print(f"源图 {src.size[0]}x{src.size[1]},模式 {src.mode}")


def jpeg_bytes(img, q):
    buf = io.BytesIO()
    img.save(buf, "JPEG", quality=q, optimize=True)
    return buf.getvalue()


print()
print("=== 同一张图,三种宽度 × 三档质量(JPEG,单位 KB)===")
print(f"{'宽度':>6} {'质量95':>9} {'质量85':>9} {'质量75':>9}")
rows = []
for width in (1536, 1024, 768):
    h = round(H * width / W)
    img = src.resize((width, h), Image.LANCZOS)
    sizes = [len(jpeg_bytes(img, q)) for q in (95, 85, 75)]
    rows.append((width, sizes))
    print(f"{width:>6} {sizes[0] / 1024:>8.1f}K {sizes[1] / 1024:>8.1f}K {sizes[2] / 1024:>8.1f}K")

full = rows[0][1][0]
print()
print("=== 相对原尺寸 + 质量 95 的比例 ===")
for width, sizes in rows:
    for q, b in zip((95, 85, 75), sizes):
        print(f"宽 {width:<5} 质量 {q} 体积 {b / 1024:>7.1f}K 是基准的 {b / full * 100:>5.1f}%")

print()
print("=== 编码格式与 base64 后的传输体积 ===")
small = src.resize((768, 512), Image.LANCZOS)
jpg = jpeg_bytes(small, 85)
buf = io.BytesIO()
small.save(buf, "PNG", optimize=True)
png = buf.getvalue()
buf = io.BytesIO()
small.save(buf, "WEBP", quality=85, method=6)
webp = buf.getvalue()
for label, data in (("JPEG q85", jpg), ("PNG", png), ("WEBP q85", webp)):
    b64 = len(base64.b64encode(data))
    print(f"{label:<10} 原始 {len(data) / 1024:>7.1f}K  base64 后 {b64 / 1024:>7.1f}K  膨胀 {b64 / len(data) * 100:.1f}%")

print()
print("=== 缩到 768 宽再放大回去,和原图差多少 ===")
back = small.resize((W, H), Image.LANCZOS)
diff = ImageChops.difference(src, back)
d = np.asarray(diff, dtype=np.int16)
print(f"平均绝对误差 {d.mean():.2f},最大误差 {d.max()},超过 16 的像素占 {100 * (d > 16).mean():.1f}%")

print()
print("=== 带透明通道的图直接存 JPEG ===")
rgba = src.convert("RGBA")
px = rgba.load()
for y in range(0, 200):
    for x in range(0, 200):
        px[x, y] = (255, 0, 0, 0)
try:
    data = jpeg_bytes(rgba, 85)
    back_rgb = Image.open(io.BytesIO(data)).convert("RGB")
    print(f"存盘成功,体积 {len(data) / 1024:.1f}K")
    print(f"原图该点 RGBA={rgba.getpixel((10, 10))},读回 RGB={back_rgb.getpixel((10, 10))}")
except Exception as e:
    print(f"{type(e).__name__}: {e}")
white = Image.new("RGBA", rgba.size, (255, 255, 255, 255))
flat = Image.alpha_composite(white, rgba).convert("RGB")
data = jpeg_bytes(flat, 85)
print(f"先合成到白底再存 JPEG:体积 {len(data) / 1024:.1f}K,该点 RGB={flat.getpixel((10, 10))}")
naive = rgba.convert("RGB")
print(f"直接掉 alpha 通道:该点 RGB={naive.getpixel((10, 10))}")
源图 1536x1024,模式 RGB

=== 同一张图,三种宽度 × 三档质量(JPEG,单位 KB)===
    宽度      质量95      质量85      质量75
  1536    810.0K    365.5K    212.3K
  1024    273.9K    103.0K     59.6K
   768    124.8K     44.3K     25.6K

=== 相对原尺寸 + 质量 95 的比例 ===
宽 1536  质量 95 体积   810.0K 是基准的 100.0%
宽 1536  质量 85 体积   365.5K 是基准的  45.1%
宽 1536  质量 75 体积   212.3K 是基准的  26.2%
宽 1024  质量 95 体积   273.9K 是基准的  33.8%
宽 1024  质量 85 体积   103.0K 是基准的  12.7%
宽 1024  质量 75 体积    59.6K 是基准的   7.4%
宽 768   质量 95 体积   124.8K 是基准的  15.4%
宽 768   质量 85 体积    44.3K 是基准的   5.5%
宽 768   质量 75 体积    25.6K 是基准的   3.2%

=== 编码格式与 base64 后的传输体积 ===
JPEG q85   原始    44.3K  base64 后    59.0K  膨胀 133.3%
PNG        原始   677.4K  base64 后   903.2K  膨胀 133.3%
WEBP q85   原始    33.2K  base64 后    44.2K  膨胀 133.3%

=== 缩到 768 宽再放大回去,和原图差多少 ===
平均绝对误差 8.42,最大误差 56,超过 16 的像素占 11.8%

=== 带透明通道的图直接存 JPEG ===
OSError: cannot write mode RGBA as JPEG
先合成到白底再存 JPEG:体积 357.3K,该点 RGB=(255, 255, 255)
直接掉 alpha 通道:该点 RGB=(255, 0, 0)

输出分五段,后面三章都从这里取数。

质量从 95 降到 85,是整张表里最便宜的一刀

按基准比例看:95 降到 85,体积剩 45.1%,画质损失多数场景看不出来,这一步不用犹豫。85 降到 75,从 45.1% 掉到 26.2%,省下的不到基准的两成,肤色过渡、天空渐变这类平缓区域开始出现轻微色带。75 往下就别去了。Pillow 文档对 quality 写得直接:取值 0 到 95,默认 75,并明确「Values above 95 should be avoided」——95 以上是拿体积换几乎看不见的差异,100 还会关掉 JPEG 压缩算法的部分环节,文件变大而画质几乎不涨。

宽度那一刀的落点更值得抠:1536 的 q85 是 365.5K,1024 的 q85 是 103.0K,768 的 q85 是 44.3K。每降一档,体积掉到前一档的三四成,而丢掉的像素在页面上本来就没有落点。

预算倒推:先钉宽度,再钉质量下限

落地时真正要改的就是这几个参数:

def jpeg_bytes(img, q):
    buf = io.BytesIO()
    img.save(buf, "JPEG", quality=q, optimize=True)
    return buf.getvalue()

optimize=True 也值得留着。Pillow 对 JPEG 的 optimize 写的是「indicates that the encoder should make an extra pass over the image in order to select optimal encoder settings」,也就是多扫一遍挑参数;对 PNG 的 optimize 写的是「instructs the PNG writer to make the output file as small as possible」。两者都是拿一点 CPU 换体积,在上传链路上几乎总是划算的。

倒推的顺序反过来:

  • 先量显示宽度。缩略图、正文配图、详情大图差得远;目标宽度定在显示宽度的两倍以内,多出来的直接 resize 掉。
  • 再在九格表里挑一格。预算线定在 103.0K 就取 1024 宽 q85,定在 44.3K 就取 768 宽 q85。别先定质量再试宽度,那样每格都偏贵。
  • 95 只留给要二次处理的图。原图要进裁剪、合成、识别流程才用 95,直接展示的一律 85 起。75 是下限,不是默认值——默认值省事,但它不是按你的显示宽度算出来的。

这份资料是什么:一张把「内容类型 × 格式 × 宽度 × 质量 × 传输膨胀」并在一起的预算表,三类内容各自该落在哪一格,附两个脚本的复跑步骤。和这一章九格数据配合看,先钉宽度再钉质量。放在资料包里,扫码即可获取:

配套资料获取

分辨率砍掉一半,像素差在哪

缩到 768 宽再放大回原尺寸,平均绝对误差 8.42——这个数字好看得没什么用,真正决定能不能接受的是另外两个:最大误差 56,以及偏差超过 16 的像素占 11.8%。

判断依据要摆清楚:8.42 是在 255 级色阶上的均值,占满量程三个多百分点,单看它,任何图都像「几乎没差」。但均值会把大片平坦区的零误差和小片高频区的大误差混在一起,混完既看不出哪里崩了,也看不出崩了多少——这笔账得拆成三行看。

8.42 是被平均出来的

同一张图里,渐变背景占了绝大多数面积,缩图对这种区域几乎是完美重建——低频信号缩小再放大,误差接近零。这些像素把均值往下拉。

最大误差 56 说明至少有一个像素被改了超过两成的量程。它可能是噪声尖点,也可能是某条细线的边缘:尖点改了就改了,细线边缘一改就是「断」和「虚」。均值回答「整体像不像」,最大值回答「最坏能坏到什么程度」,缺的那一问是「坏的地方有多少、在哪里」。

11.8% 的像素超过 16,这个比例落在哪才关键

阈值 16 是脚本里选的一条线,不是行业标准——把它当成「肉眼在平滑区域能分辨的灰度差」的一个保守刻度来用。按这条线数,超过的像素占 11.8%,每八九个像素一个。

这 11.8% 的分布比数值本身重要:

  • 散在噪声区、渐变区:可以接受。照片本身就在抖,多抖一级没人看得出来。
  • 集中在文字边缘、表格线、细笔画:不可以接受。这类结构只有一两个像素宽,误差 16 意味着笔画被削掉一半,放大是发虚,缩小是断字。
  • 集中在高对比边界(深色文字压浅底):最糟,误差会被视觉放大,块状和振铃都从这里出来。

所以「11.8% 的像素有偏差」本身不构成结论,得补上「偏差在哪」。本文这张测试图是纯合成的渐变加噪声,11.8% 基本散在噪声区,属于可接受那一侧;换成一张票据扫描件,同样的 11.8% 会全部压在字符笔画上,结论就翻过来。

这几类图不要指望靠缩图解决

  • 文字截图、票据、表单:像素边界就是信息边界,缩一半等于把笔画砍半。要么保持原宽,要么换无损格式。
  • 带细线的图表:坐标轴、网格线、1 像素描边,缩图后会被平均成浅灰。图表该省的是格式(PNG 或 WEBP),不是分辨率。
  • 已经压过一次的图:二次编码会在第一次的块边界上再叠一层,误差不是相加而是放大。
  • 要 OCR 或做识别的图:不用看误差指标,直接把宽度锁在原尺寸——缩图省下的字节会在识别率上还回来。

反过来,列表缩略图、点开才看大图的场景,768 宽完全够——44.3K 换掉的不是画质,是一整条超时路径。

上传链路上还有一次 33% 的膨胀

图片体积算完还要再乘一次系数:base64 之后是原来的 133.3%,脚本里 JPEG、PNG、WEBP 三种编码打出来都是这个数——膨胀只跟封装方式有关,跟图片内容无关。

原因在编码规则本身。RFC 4648 §4 写的是「The encoding process represents 24-bit groups of input bits as output strings of 4 encoded characters」:每 3 个字节换成 4 个字符,体积比就是 4/3。这是这种编码的定义,不是实现细节,所以「换个图片格式能不能绕开这 33%」根本不成立——换格式改的是编码前那一半。

44.3K 变 59.0K:这笔账要在选格式时就记上

同一张 768 宽的图,两种编码各自走一遍:

编码原始体积base64 后膨胀
JPEG q8544.3K59.0K133.3%
PNG677.4K903.2K133.3%

两行的膨胀一模一样,绝对增量差得远——33% 是乘法,不是加法,图越大这层封装费越贵。所以「PNG 反正无损、干脆都存 PNG」这个决定,在传输层要按 677.4K 变 903.2K 记账,不是按 677.4K。

记账口径要跟着网关走:网关数的是请求体大小,不是文件大小。目标定 44.3K 的图,进 body 就是 59.0K;字段额度按整百 KB 给的时候,图片本身只能占四分之三,剩下全是编码费——预算表少写这一行,线上就会以「莫名其妙超了」的形式出现。

真要省这 33%,只有换传输方式:二进制直传、预签名 URL 让客户端直传对象存储、图放 CDN 只传地址。这三条都改协议,不改编码。

透明通道掉下去,同一个像素剩两个值

带 alpha 的图是另一种开销,不体现在体积上,体现在颜色上。对 RGBA 图直接存 JPEG,抛出来的是 OSError: cannot write mode RGBA as JPEG——JPEG 没有 alpha 通道,编码器当场拒绝。

绕过去有两条路,同一个点给出两个值:先合成到白底再存 JPEG,体积 357.3K,该点 RGB 是 (255, 255, 255);直接掉 alpha 通道,该点 RGB 是 (255, 0, 0)。

源图那个点原本是 (255, 0, 0, 0)——全透明的红。人眼看到的应该是「什么都没有」,掉通道之后成了实心红块,整片透明区变红底。这类问题最难查:PNG 看着没事,转 JPEG 出现大片色块,第一反应是压缩参数,其实是 alpha 被丢了。

正确的做法是先合成,再转模式:用页面背景色建不透明底图,把 RGBA 图 alpha_composite 上去,再 convert("RGB")。页面底色不是白,就用页面底色合成,透明区才会真正「消失」。

357.3K 也值得留意:它是 1536×1024 全图 q85 的结果,和照片类那格 365.5K 差不多。合成白底不会让体积失控,失控的是「先掉通道再压」——红块是高频硬边,压不动。

三步把预算钉死,然后停手

落地就三步,每步钉一个数:

  1. 按颜色数分格式。几千种以内走 PNG 或 WEBP,百万级走 JPEG 或 WEBP,中间带实测。
  2. 按显示宽度定宽度。目标宽度取显示宽度的两倍以内,超过就 resize;文字、票据不缩。
  3. 按预算线定质量。85 起步,75 是下限,95 只给要二次处理的图;optimize=True 一直开着。

最后按 133.3% 报预算。三步做完就停手——继续往下抠(换编码器、多档 quality 扫描、自适应量化)的收益通常小于花掉的时间,而每加一个变量,复现和回归的成本都要重算一遍。

停手信号很明确:一张图已经落到 44.3K 这个量级(768 宽、q85),再压只能靠牺牲可读性;一张图是百万级颜色、又没有显示宽度上的冗余,365.5K 附近就是它的合理位置,剩下的空间该去优化链路(直传、CDN、异步),不该继续在编码器上找。

这份资料是什么:一份「上传链路体积预算清单」,从颜色数分类、宽度上限、质量下限,到 base64 记账和 alpha 合成,每步一条判断线和一条停手条件。和这一章两笔隐性开销配合看。放在资料包里,扫码即可获取:

配套资料获取

附表 A:本文引用事实与出处对照表

事实(可核对的原文或数值)出处本文位置
“The image quality, on a scale from 0 (worst) to 95 (best), or the string keep. The default is 75. Values above 95 should be avoided; 100 disables portions of the JPEG compression algorithm, and results in large files with hardly any gain in image quality.”Pillow 文档《Image file formats》JPEG 保存选项 quality(https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html)第 2 章第 2 小节
“If present and true, instructs the PNG writer to make the output file as small as possible.”Pillow 文档《Image file formats》PNG 保存选项 optimize(同上)第 2 章第 3 小节
“If present and true, indicates that the encoder should make an extra pass over the image in order to select optimal encoder settings.”Pillow 文档《Image file formats》JPEG 保存选项 optimize(同上)第 2 章第 3 小节
“The encoding process represents 24-bit groups of input bits as output strings of 4 encoded characters.”RFC 4648 §4(https://www.rfc-editor.org/rfc/rfc4648.html)第 4 章第 1 小节
work/exp1120/s4b_format.py 与 s4b.out 一次运行的原始输出:照片类 365.5K / 3442.4K / 458.4K,图表类 13.6K / 6.3K / 3.3K,文档截图 24.4K / 1409.5K / 5.7K;图表类颜色数 3,照片类颜色数 1118728本机运行(macOS Darwin 27.0.0 / Python 3.13.12 / Pillow 12.3.0 / numpy 2.5.3,固定种子)第 1 章表 1、代码块
work/exp1120/s4_img.py 与 s4.out 一次运行的原始输出:九格体积 810.0K 至 25.6K、base64 膨胀 133.3%、误差 8.42 / 56 / 11.8%、白底合成 357.3K 与 (255, 255, 255) / (255, 0, 0)同上第 2 章表 2、第 3 章、第 4 章表 3
九倍这一比值由 s4b.out 两格相除得出:3442.4K ÷ 365.5K ≈ 9.4由本文实测输出换算第 1 章第 1 小节

写在最后:这篇用到的资料

写这篇文章时,把相关的官方文档和源码又翻了一遍,顺手也整理了几份配套的东西:

  • 大模型学习路线图:从零基础到能自己动手做 Agent,按阶段说明每一步该学什么、哪些可以先跳过
  • 《LangChain + LangGraph + MCP 智能体开发实战》视频课:7 个模块,从私有化部署、Embedding+RAG 到 MCP+Agent 全流程
  • AI 大模型知识库(在线可查):Agent Skills 从入门到落地、Claude Skills 完全指南等专题,按目录浏览即可
  • 640 套 AI 大模型行业报告 + 经典 PDF 书籍:看行业落地案例和别人怎么做的时候用得上
  • 大模型零基础到精通教学视频:跟着敲一遍,比只读文档快得多

资料是我自己整理的,放在下面这个码上,扫码即可获取:

配套资料获取
课程目录:私有化部署与 LangChain
课程总目录:7 个模块
在线知识库:Agent Skills 创建全流程
课程目录:LangGraph 开发智能体
在线知识库:Claude Skills 完全指南

添加时备注「AI」,优先通过。

资料按「先路线、再动手、最后查漏」的顺序整理好了,建议先看学习路线那一份,照着它挑一条适合自己当前基础的路径再往下看。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/2601_96189255/article/details/171071374

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--