让大模型写一个 Python 脚本、补一段字段校验,多数时候不用改;让它写一个能在特定芯片上跑赢 PyTorch 的算子,结果往往是编译不过,或者跑出来的数和参考实现对不上。

这两件事看起来只差一个领域,实际差的是验收方式,业务代码的验收是"人能读懂、流程能跑通";算子的验收是"能编译、多个 shape 下与参考实现逐元素对得上、并且比基线快"。前两条可以被一句自然语言兜住,第三条兜不住,它必须靠机器测。

FlagOS 社区开发的 KernelGen 算子生成平台是专门对付这段落差的一个工具,支持算子生成、优化、特化,多芯片后端、多框架接入,分钟级交付,它把检索、生成、自测和迭代串进同一个闭环,最后交付的不是一段代码,而是一组带测试结果的实现。

下面先看这个闭环怎么运转,再解释通用大模型为什么接不住这段落差,最后落到一个 ReLU 算子的完整生成过程,拆解它的两个核心指标是怎么来的,以及这些数字该怎么读。

 

一、四步闭环:把测试放进生成内部

 

KernelGen 的流程分成四步,每一段都在补上生成所缺的关键信息:

收集 Kernel 信息:用户输入语义化的算子定义,包括名字、类型、入参出参、功能描述和目标设备。

搜索代码片段:检索与用户定义相似的真实仓库代码作为参考。这一步就是 RAG,把"模型没见过的好实现"从外部找进来。

生成 Kernel 代码和 CUDA 版基准实现代码:注意是两份代码,一份是被测对象,一份是基线。

基于 CUDA 版基准实现测试 Kernel:正确性测例加加速比测例,输出两个数字。

 

图片

一轮跑完,交付的不是一段代码,而是四样东西:Kernel、CUDA 版基准实现、正确性测例、加速比测例;验收发生在第 4 步,用户拿到的已经是跑过测试的结果。

入口是https://kernelgen.flagos.io/home。首页三个典型案例是ReLU、minimum、RMSNorm,都是 pointwise 或 reduction 这种"语义一句话说清、实现却要抠内存访问"的算子。

要看懂这四步为什么这么设计,得先回答一个问题:通用大模型为什么接不住算子生成。

 

二、通用辅助编程的天花板

 

传统编程的时间大头花在翻资料和敲样板上,而不是设计上。LLM 能接住这件事,靠的是三个层面同时到位:Transformer 的自注意力给了长距离依赖建模和并行计算的能力;自然语言与代码被放进同一个 token 空间,理解与生成得以统一;海量开源代码上的预训练让模型学到的不只是语法,还有编程范式。

落到产品上,就是 Prompt 输入、上下文理解、代码生成、输出与优化四段。前三段模型独立完成,最后一段"根据反馈迭代"——在通用编程里,这一步通常由人完成:人看一眼、改一行、再问一次。到了算子上,这一步必须由机器完成,否则整个链条就断在这里。

GitHub Copilot 是这套范式跑通商业闭环的第一个大样本,底座是最早的 OpenAI Codex(arXiv:2107.03374),论文在 HumanEval 上给出的基线是 Codex 28.8%、采样 100 次时 70.2%。

 

图片

这张图画的是 Copilot 的数据流,重点是三条标注:Provide Editor context、Provide Suggestions、Improve Suggestions。公共互联网代码和私有代码分别进到 Codex Model 和 Copilot Service 两条路径。

这张图也解释了 Copilot 为什么"好用但不敢全信":它的上下文来源是编辑器里你正打开的文件和邻近文件,是语法级和项目级的上下文,不是执行级的上下文。模型不知道这段代码在这块卡上跑出来是快是慢、数值对不对,它没有测量通道。这就是通用辅助编程的天花板:写法层面的问题它全能答,性能与正确性层面的问题它只能猜。

GPU 编程把这道天花板压得更低:编程模型复杂、架构差异大、通用优化策略缺失、并行调度与内存管理门槛高。这四条决定了"一个能跑的 kernel"和"一个跑得快的 kernel"之间隔着大量试错,而这类试错恰恰是通用 LLM 最不擅长的——训练语料里高质量手写 kernel 的密度远低于业务代码,模型没见过足够多"某芯片某 shape 下该怎么切块"的样本。

把通用 LLM 和 KernelGen 放在一起比,差别可以压成一句话:KernelGen 把算子测试放进了生成流程内部,而不是留给用户事后验收。

 

图片

两者的区别不在于输出格式,而在于通用 LLM 交付的是文本,KernelGen 交付的是带证据的实现。这个差别不是产品包装,是工程范式的差别——它把性能回归测试从开发者的日常动作,变成了生成器的内循环。

 

三、Prompt 从一句话变成一张表单

 

回到闭环的第一步:输入定义。KernelGen 对 prompt 的敏感度远高于通用代码助手,同一个算子,两种写法会得到完全不同的结果。

 

图片

 

图片

上面这段把算子名、分类(pointwise)、一个入参的名字与类型、一个出参的名字与类型、形状关系(输出与输入同 shape)、数值语义(max(0, input))全写进去了。下面那句"帮我写一个 ReLU Kernel",除了算子名什么都没给。

差别不在礼貌程度,在可验证性。前者生成的测例能直接对齐语义,后者生成的实现只能靠猜边界:输入是不是 fp16?要不要在内部上转 fp32?输出 dtype 跟输入一致还是固定 fp32?这些一旦猜错,正确性测试就过不了,而用户还看不出是"实现错了"还是"需求没写清"。

这里对写 prompt 给了四条核心原则:

 

图片

  • 明确性:清晰具体地描述算子功能、输入输出张量形状及约束条件。模糊的描述必然导致模糊的结果。

  • 背景与上下文:给出目标硬件平台(如 NVIDIA A100)、性能指标、代码风格。

  • 示例驱动:提供输入输出示例或参考代码(Few-Shot),让模型快速对齐期望。

  • 思维链引导:要求分步展示推理,从分析逻辑到设计布局再到编写代码。

第三条在实际使用中最有效,也最容易被忽略。系统会先检索出相似仓库,让用户挑一个作为参考代码。

 

图片

检索出来的两个仓库是 harleyszhang/lite_llama(163 star)和 JackeyLove1/nano-triton-kernel(0 star),下面还有一个"以上仓库都不合适,直接生成"的兜底选项。这个设计承认检索可能失败,并且把"失败时退化为纯生成"作为显式路径,而不是让模型硬凑一段看起来像参考的东西。工程上这叫降级路径,很多 RAG 产品缺的就是这一条。

最后一步是表单,页面上还标了几条硬约束,都是实际用起来才知道的细节:算子名称要求英文(中文名在检索相似代码、拼进函数名时会出问题);评测设备支持英伟达、天数、海光、华为昇腾、摩尔线程五家,说明后端不止 CUDA 一套;迭代次数越多,生成的算子通常越好,简单算子一轮迭代通常耗时 2~3 分钟。

 

图片

表单里"自动优化最大迭代轮次"填的是 5。这个数字是成本与收益的旋钮:ReLU 这种简单算子一轮 2~3 分钟,5 轮就是十几分钟;复杂算子单轮更久,实际用起来多数人会先跑一到两轮看趋势,再决定加不加。

 

四、ReLU 走一遍:两个数字怎么来的

 

点下"下一步",前面说的四样东西就出来了:Kernel、CUDA 版基准实现、正确性测例、加速比测例。

 

图片

生成的 kernel 是标准的 Triton 语言写法:

import torch
import triton
import triton.language as tl
@triton.jit
def relu(input_ptr,
Pointer to input tensor
output_ptr,
Pointer to output tensor (float32)
n_elements,
Total number of elements
BLOCK_SIZE: tl.constexpr):
pid = tl.program_id(axis=0)
block_start = pid * BLOCK_SIZE
offsets = block_start + tl.arange(0, BLOCK_SIZE)
mask = offsets < n_elements
x = tl.load(input_ptr + offsets, mask=mask, other=0).to(tl.float32)
y = tl.maximum(x, 0.0)
tl.store(output_ptr + offsets, y, mask=mask)
先保留对 Triton kernel 的引用,后面要定义同名的 Python wrapper
relu_kernel = relu
def relu(input: torch.Tensor) -> torch.Tensor:
assert input.is_cuda, "Input tensor must be on CUDA device."
input_contig = input.contiguous()
n_elements = input_contig.numel()
计算统一走 float32
out_fp32 = torch.empty_like(input_contig, dtype=torch.float32)
grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
relu_kernel[grid](input_contig, out_fp32, n_elements, BLOCK_SIZE=1024)
if input.dtype != torch.float32:
return out_fp32.to(dtype=input.dtype)
return out_fp32

这段代码有几个地方值得看,都是"生成质量"的具体体现,而不是空话:

  • relu_kernel = relu 这一行还专门加了注释。Triton 的 @triton.jit 装饰后函数名指向的是一个 JITFunction 对象,如果后面直接 def relu(...) 写 wrapper,这个名字就被覆盖了,kernel 的引用丢失。生成器显式保留了引用,说明它见过真实代码库里的写法,不是按语法规则硬拼出来的。

  • tl.load(...).to(tl.float32):读进来立刻上转 fp32。原因是核对齐基线——CUDA 版基准实现里 fp16/bf16 也是先上转 fp32 再算,被测侧走同一条数值路径,精度比较才有意义。ReLU 本身是精确运算(max(0,x) 不引入舍入),精度损耗只可能来自 dtype 转换,两侧一致就能把变量控制住。

  • BLOCK_SIZE=1024 是写死的,没有 autotune。这是权衡:pointwise 算子的最优 block 与 shape 关系不大,autotune 的编译开销往往抵不过收益;但换成 reduction 类算子,固定 block 就可能是性能瓶颈。生成器默认不给 autotune,需要的人在 wrapper 上加 @triton.autotune 即可。

CUDA 版基准实现也就是被比较的基线,用的是 PyTorch 等价路径:

 

图片

    import torch
    def relu(input: torch.Tensor) -> torch.Tensor:
    orig_dtype = input.dtype
    if input.is_floating_point():
    x = input.to(torch.float32) if input.dtype in (torch.float16, torch.bfloat16) else input
    out = torch.relu(x)
    return out.to(orig_dtype) if out.dtype != orig_dtype else out
    else:
    非浮点类型统一上转 float32 计算,再转回原类型
    x = input.to(torch.float32)
    out = torch.relu(x)
    return out.to(orig_dtype)
    

    注意这里的处理:fp16 / bf16 先上转 fp32 再算、算完再 cast 回去。所以基准侧的开销里包含了两次 dtype 转换。这一点是后面解读加速比的关键——baseline 并不等于"PyTorch 原生 fp16 relu",而是"上转 fp32 的 PyTorch relu"。

    正确性测例把 6 个 shape 和 3 个 dtype 做笛卡尔积,正好 18 组,这就是"18/18"的来源:

    import bench
    from bench.sandbox.test.test_parametrize import parametrize, label
    from bench.sandbox.config import DEVICE as device
    from bench.sandbox.utils.accuracy_utils import gems_assert_close as assert_close
    from bench.sandbox.utils.accuracy_utils import to_reference
    import torch
    @label("relu")
    @parametrize("shape", [(256,), (64, 64), (128, 32), (8, 16, 32), (3, 224, 224), (2, 3, 4, 5)])
    @parametrize("dtype", [torch.float16, torch.float32, torch.bfloat16])
    def test_relu(shape, dtype):
    input = torch.randn(shape, dtype=dtype, device=device)
    ref_input = to_reference(input, True)
    ref_out = bench.relu(ref_input)
    res_out = bench.triton.relu(input)
    assert_close(res_out, ref_out, dtype, reduce_dim=1)

    6 个 shape 从一维 (256,) 到五维 (2,3,4,5),覆盖了"小到只有一个 block"和"多维非连续"两种情况;3 个 dtype 覆盖半精度、单精度和 bf16。reduce_dim=1 是 FlagGems 那套 gems_assert_close 的参数,用于按维度做归约比较;不同框架的误差比较接口签名不一样,这里不要照搬到 torch.testing.assert_close 上,后者没有这个参数。

    加速比测例是 do_bench 的标准用法:

    @label("relu_benchmark")
    @parametrize("shape", [(256,), (64, 64), (128, 32), (8, 16, 32), (3, 224, 224), (2, 3, 4, 5)])
    @parametrize("dtype", [torch.float16, torch.float32, torch.bfloat16])
    def relu_benchmark(shape, dtype):
    from bench_v2.sandbox.test.performance.attri_util import CustomBenchmarkResult
    import triton
    quantiles = [0.5, 0.2, 0.8]
    input = torch.randn(shape, dtype=dtype, device=device)
    ref_input = to_reference(input, True)
    ms_torch, _, _ = triton.testing.do_bench(lambda: bench.relu(ref_input), rep=100, quantiles=quantiles)
    ms_triton, _, _ = triton.testing.do_bench(lambda: bench.triton.relu(input), rep=100, quantiles=quantiles)
    speedup = ms_torch / ms_triton
    return CustomBenchmarkResult(ref_time=ms_torch, res_time=ms_triton, speedup=speedup)
    

    这里有个必须纠正的误读。triton.testing.do_bench 的签名是:

    do_bench(fn, warmup=25, rep=100, grad_to_none=None, quantiles=None, return_mode='mean')

    warmup 和 rep 的单位是毫秒,不是迭代次数。官方文档写得很清楚:这两个参数表示预热和计时的时长窗口,函数会在这个窗口内反复调用 fn,再按需返回均值或分位数。所以代码里的 rep=100 应读作"计时 100 ms",而不是"重复 100 次"。

    这个口径差异会直接影响结论的稳定性。(256,) 这种 shape 单次调用只有几微秒,100 ms 窗口内会跑上万次,取中位数比较稳;而 (3,224,224) 单次几十微秒,窗口内只有几千次,噪声相对大一些。这也是代码取 quantiles[0] 即中位数而不是均值的原因——中位数对偶发调度抖动不敏感。

    结果页给了两个数字:

     

    图片

    正确性测试 18/18,加速比测试 1.3459。展开详情能看到 18 行逐条数据:

     

    图片

     

    五、读加速比之前,先确认基线

     

    把 18 行摊开看。测试条件是 Nvidia 评测设备、6 个 shape × 3 个 dtype、每组 rep=100(毫秒计时窗口)、quantiles=[0.5,0.2,0.8] 取中位数:

     

    图片

    汇总行的 1.346 和迭代页的 1.3459 是同一个数,是 18 个加速比的算术平均,不是"总耗时之比"。这两个口径算出来不一样:把 18 组参考耗时求和得 219.712,Triton 侧求和得 159.504,比值是 1.3775,比 1.3459 高一点。写报告时,"总耗时降低到原来的 72.6%"和"平均加速 1.35 倍"是两件事,不能混着写。

    这张表最有信息量的位置其实是 fp32 那一行:0.99,等于没赢。原因不难解释——ReLU 是逐元素操作,访存受限,PyTorch 的 torch.relu 在 fp32 上已经走的是高度优化的 vectorized elementwise kernel,Triton 手写版本在同样的访存量下很难再挤出空间。而 fp16/bf16 之所以能到 1.4~1.9 倍,从代码结构上看,相当一部分来自基准侧那两次 dtype 转换:to(torch.float32) 要额外申请一块 fp32 内存并做一次全量读写,to(orig_dtype) 再来一遍;Triton 版本在 kernel 内部完成上转、计算、回写,只多了一次寄存器级的类型转换,省掉了中间的显存往返。

    这一条是从两侧代码结构推出的判断。界面上只给了耗时明细,没有带宽层面的 profile 数据,如果要写进正式的性能报告,建议用 ncu 或 nsys 拉一遍访存量核实。

    这不是在说数字有问题,而是在说读加速比必须先看基线是什么。同一份 Triton 实现,对着"上转 fp32 的 PyTorch relu"是 1.55 倍,对着"原生 fp16 relu"可能就只有 1.0 倍出头。结果页那行小字写的是"kernel 和相应的 cuda 实现在各个测试样例上的具体耗时",把基线定义放在"CUDA 版基准实现"这个 tab 里,是为了让人能自己核对。这个设计比只给一个总加速比诚实得多。

     

    六、把这套口径搬到自己的机器上

     

    平台里的 bench.、bench_v2.、gems_assert_close 都是 FlagGems / FlagPerf 侧的内部模块,直接抄代码跑不通。要在自己的机器上复现同样的口径,至少要补三样:kernel、基准,以及一套对齐 dtype 的容差表。

    容差表可以直接用 torch.testing.assert_close 的默认值,官方文档给的判据是 |actual - expected| <= atol + rtol * |expected|,按 dtype 取默认:

    把这套默认值硬编码进去,就能脱离平台复现:

    import torch, triton
    import triton.language as tl
    TOL = {
    torch.float16:  dict(rtol=1e-3,   atol=1e-5),
    torch.bfloat16: dict(rtol=1.6e-2, atol=1e-5),
    torch.float32:  dict(rtol=1.3e-6, atol=1e-5),
    }
    SHAPES = [(256,), (64, 64), (128, 32), (8, 16, 32), (3, 224, 224), (2, 3, 4, 5)]
    DTYPES = [torch.float16, torch.float32, torch.bfloat16]
    QUANTILES = [0.5, 0.2, 0.8]
    @triton.jit
    def relu_kernel(input_ptr, output_ptr, n_elements, BLOCK_SIZE: tl.constexpr):
    pid = tl.program_id(axis=0)
    offsets = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
    mask = offsets < n_elements
    x = tl.load(input_ptr + offsets, mask=mask, other=0).to(tl.float32)
    tl.store(output_ptr + offsets, tl.maximum(x, 0.0), mask=mask)
    def triton_relu(x: torch.Tensor) -> torch.Tensor:
    x = x.contiguous()
    n = x.numel()
    out = torch.empty_like(x, dtype=torch.float32)
    grid = lambda meta: (triton.cdiv(n, meta["BLOCK_SIZE"]),)
    relu_kernel[grid](x, out, n, BLOCK_SIZE=1024)
    return out if x.dtype == torch.float32 else out.to(x.dtype)
    def torch_relu(x: torch.Tensor) -> torch.Tensor:
    orig = x.dtype
    if x.dtype in (torch.float16, torch.bfloat16):
    return torch.relu(x.to(torch.float32)).to(orig)
    return torch.relu(x)
    if
    name
    == "
    main
    ":
    ratios = []
    for dtype in DTYPES:
    for shape in SHAPES:
    x = torch.randn(shape, dtype=dtype, device="cuda")
    ref = torch.relu(x.to(torch.float32))
    参考侧固定 fp32
    torch.testing.assert_close(triton_relu(x), ref.to(dtype), **TOL[dtype])
    ms_ref = triton.testing.do_bench(lambda: torch_relu(x), warmup=25, rep=100, quantiles=QUANTILES)[0]
    ms_tri = triton.testing.do_bench(lambda: triton_relu(x), warmup=25, rep=100, quantiles=QUANTILES)[0]
    ratios.append(ms_ref / ms_tri)
    print(f"{str(dtype):<16}{str(shape):<14}ref={ms_ref:.6f}ms tri={ms_tri:.6f}ms x{ms_ref/ms_tri:.4f}")
    print(f"\n18/18 通过,加速比算术平均 = {sum(ratios)/len(ratios):.4f}")

    如果想把这套算子接进 FlagGems 算子库做端到端验证,路径是现成的:

    pip install flag-gems==5.0.2
      import flag_gems
      flag_gems.enable()
      通过注册 ATen 后端接管算子调用,业务代码不用改

      FlagGems 是 FlagOS 生态里的 Triton 算子库,走的是注册 PyTorch ATen 后端的路子,enable() 之后对 torch.relu 之类的调用会被路由到 Triton 实现,所以"算子写得对不对、快不快"可以直接在真实模型里看端到端指标,而不是只看单算子 microbench。GitHub 的 tools 仓库里也有专门的工具,把 KernelGen 生成的代码转成 FlagGems 格式,这条链路是通的。

       

      七、现在能做什么,不能做什么

       

      KernelGen 的界面上"值得一提"列了三条,都是限制而不是卖点。

      其一,目前仅支持一轮 prompt。用户能改的是生成前的定义,生成后的多轮迭代由平台自动完成,用户没法在中间插话("这个 block size 试试 512")。这跟通用辅助编程设想的"人和模型来回交互"有落差,现在的形态是模型自己跟自己迭代。平台留了一个口子:每轮迭代后可以手动改左侧代码作为下一轮输入,等于把"人插话"降级成了"人改文件"。

      其二,与 FlagOS 生态的对接靠外部工具。生成的代码不是 FlagGems 的原生格式,要过一道转换。这是典型的分层代价:生成侧和运行侧各自演进,中间用工具桥接,好处是两边解耦,坏处是桥接层容易滞后。

      其三,接入 IDE 是计划而非现状。官方提到过把 KernelGen 接入 vscode 等 IDE,这类带时间点的表述要按发布时点理解,不能当成当前状态——产品迭代快,实际能力以官网和文档中心为准。

      除了这三条,还有两条更硬的边界。

      跨平台不等于跨平台等价。表单里评测设备支持英伟达、天数、海光、华为、摩尔线程五家,说明后端矩阵是认真做的。但"支持某芯片"和"在该芯片上能生成出优于基线的 kernel"是两件事。公开数据里,Nvidia 平台的表现明显好于其他平台:新智元 2026 年 2 月 6 日的报道给出的整体口径是,110 个 Torch API 算子 × 5 轮迭代下,生成成功率 82%、执行正确率 62%,其中 Nvidia 平台执行正确率约 70%。这里的 82% 和 62% 定义不同,不能混用:生成成功率是"能编译能运行",执行正确率是"多 shape 下与 Torch 参考数值一致"。前者高说明语法与接口层面基本过关,后者才是能不能用的门槛。

      正确率仍需要人工兜底。62%~75.5% 这个区间意味着每 4 个算子里就有 1 个左右需要人介入。这也是 KernelGen 一定要把正确性测试摆在界面上、把"18/18"当主指标的原因——它不是给人看的装饰,是在告诉你这一次能不能直接用。

      再看一组更新的数据,可以判断这条线的走向。智源社区 2026 年 4 月 25 日的一篇文章提到,DeepSeek V4 的 5 个新算子由 Triton / Triton-TLE 重写,其中 Sparse Attention、Hadamard Transform、FP8 MatMul 三个由 KernelGen 2.0 自动生成;FP8 MatMul 经多轮自动优化达到 TileLang 的 2.47 倍;NV 平台 110 算子基准中,KernelGen 2.0 的生成正确性达 99%、90.8% 的算子加速比超过 100%。

      同一批数据里还有一条容易被忽略的:C++ Wrapper + Triton 的端到端比 DeepSeek 原生快 11%,而纯 Python Wrapper 反而慢 20.05%。同一个 kernel,wrapper 层用 C++ 还是 Python,端到端能差 30 个百分点。这说明算子生成的性能收益有很大一部分不在 kernel 本体,而在调用层。只盯 microbench 的加速比,容易高估真实收益。

       

      八、写在最后

      放到 FlagOS 这个大盘子里,KernelGen 的位置是"工具"层。上面是 Megatron-FL、vLLM-plugin-FL、TransformerEngine-FL 这些生态使能组件,以及 FlagGems、FlagScale、FlagTree、FlagCX 这些核心库,向下兼容的是 Nvidia、NPU、GPGPU、DSA、RISC-V、ARM 这些多种芯片架构。

       

      图片

      KernelGen 干的活,是把"从算子语义到可跑代码"这一段的人力成本压下去,让上层框架在适配新芯片时不用逐个手写算子。

      KernelGen 带来的提效,最直接体现在单个算子的开发周期上:过去从算子语义梳理、Triton 实现、CUDA 基准对齐,到多 shape、多 dtype 的正确性验证和加速比测试,往往需要开发者反复手写、反复调试、反复跑 bench,一个算子耗上数天并不罕见;现在这些环节被检索、生成、自测和迭代串进同一个闭环,简单算子一轮迭代 2~3 分钟,多轮迭代后直接交付 Kernel、基准实现、正确性测例和加速比测例四样东西,把“从语义到可跑代码”这一段的人力成本压到分钟级,让上层框架在适配新芯片时不必再逐个手写算子。

      数据说明

      • ReLU 正确性与加速比数据(18/18、1.3459、18 行明细):KernelGen 平台实测输出;测试条件为 Nvidia 评测设备、6 个 shape × 3 个 dtype、每组 rep=100(毫秒计时窗口)、quantiles=[0.5,0.2,0.8] 取中位数,汇总值为 18 个加速比的算术平均。

      • Codex 指标:arXiv:2107.03374;HumanEval 上 Codex 解决 28.8%,采样 100 次时 70.2%。

      • do_bench 参数语义:Triton 官方 Python API 文档,warmup / rep 单位为毫秒。

      • assert_close 默认容差:PyTorch 官方 torch.testing 文档,判断为 |actual-expected| <= atol + rtol*|expected|。

      • 110 算子 × 5 轮迭代的 82% / 62%:新智元 2026-02-06 报道。

      • KernelGen 2.0 的 99% / 90.8% / 2.47× / 11% / -20.05%:智源社区 2026-04-25 文章。

       

      关于众智FlagOS社区

      为解决不同 AI 芯片大规模落地应用,北京智源研究院联合众多科研机构、芯片企业、系统厂商、算法和软件相关单位等国内外机构共同发起并创立了众智 FlagOS 社区,目前已经有 100多家成员单位。

      FlagOS 是一款专为异构 AI 芯片打造的开源、跨芯系统软件栈,支持 AI 模型一次开发即可无缝移植至各类硬件平台,大幅降低迁移与适配成本。它包括大型算子库、跨芯AI 编译器、并行训推框架、跨芯通信库等核心开源项目,致力于构建「模型-系统-芯片」三层贯通的开放技术生态,通过"一次开发跨芯迁移"释放硬件计算潜力,打破不同芯片软件栈之间生态隔离。

      官网:https://flagos.io

      GitHub 项目地址:https://github.com/flagos-ai

      GitCode 项目地址:https://gitcode.com/flagos-ai

      SkillHub: https://skillhub.flagos.io

      Logo

      欢迎来到FlagOS开发社区,这里是一个汇聚了AI开发者、数据科学家、机器学习爱好者以及业界专家的活力平台。我们致力于成为业内领先的Triton技术交流与应用分享的殿堂,为推动人工智能技术的普及与深化应用贡献力量。

      更多推荐