【TVM 学习资料】使用 Auto-scheduling 优化算子

微软四大AI编译器解析:MLIR、异构调度与端到端延迟可控 AI编译器是连接模型算法与硬件执行的关键系统层工具,其核心原理在于通过中间表示(如MLIR)实现计算图的跨平台优化与硬件适配。随着大模型落地边缘、车规、嵌入式等多样化场景,单一通用编译器已无法兼顾功耗、实时性、安全性和部署效率等多重技术价值。当前主流需求聚焦于硬件异构调度、算子级自动优化、内存感知编排及最坏情况执行时间(WCET)保障,广泛应用于工业质检、车载ADAS、TinyML终端和云边协同推理等工程场景。本文深入拆解微软新发布的四大领域专用AI编译器——Ebb、Flare、Glimmer与Halo,覆 阅读详情

本篇文章译自英文文档 Optimizing Operators with Auto-scheduling 作者是 Lianmin Zheng,Chengfan Jia。更多 TVM 中文文档可访问→TVM 中文站

本教程将展示 TVM 的 Auto Scheduling 功能,如何在不编写自定义模板的情况下,找到最佳 schedule。

与基于模板的 AutoTVM 依赖手工模板来定义搜索空间不同,auto-scheduler 不需要任何模板。用户只需编写计算声明,无需任何 schedule 命令或模板。auto-scheduler 可以自动生成一个大的搜索空间,并在空间中找到最优 schedule。

本教程中使用矩阵乘法作为示例。

注意,本教程不会在 Windows 或最新版本的 macOS 上运行。如需运行,请将本教程的主体放在 if name == “main”: 代码块中。

import os

import numpy as np
import tvm
from tvm import te, auto_scheduler

定义矩阵乘法

首先,定义一个带有偏置加法的矩阵乘法。注意,这里使用了 TVM 张量表达式语言中的标准操作。主要区别在于函数定义上方使用了 register_workload 装饰器。该函数应返回输入/输出张量列表。通过这些张量,auto-scheduler 可以得到整个计算图。

@auto_scheduler.register_workload  # Note the auto_scheduler decorator
def matmul_add(N, L, M, dtype):
    A = te.placeholder((N, L), name="A", dtype=dtype)
    B = te.placeholder((L, M), name="B", dtype=dtype)
    C = te.placeholder((N, M), name="C", dtype=dtype)

    k = te.reduce_axis((0, L), name="k")
    matmul = te.compute(
        (N, M),
        lambda i, j: te.sum(A[i, k] * B[k, j], axis=k),
        name="matmul",
        attrs={"layout_free_placeholders": [B]},  # enable automatic layout transform for tensor B
    )
    out = te.compute((N, M), lambda i, j: matmul[i, j] + C[i, j], name="out")

    return [A, B, C, out]

创建搜索任务

定义函数后,可以为 auto_scheduler 创建要搜索的任务。我们为这个矩阵乘法指定了特定的参数,如这里是两个大小为 1024x1024 的矩阵乘法。然后我们创建一个 N=L=M=1024 和 dtype=“float32” 的搜索任务

使用自定义 TARGET 提高性能
为让 TVM 充分利用特定的硬件平台,需要手动指定 CPU 功能。例如:
启用 AVX2:将下面的 llvm 替换为 llvm -mcpu=core-avx2
启用 AVX-512:将下面的 llvm 替换为 llvm -mcpu=skylake-avx512

target = tvm.target.Target("llvm")
N = L = M = 1024
task = tvm.auto_scheduler.SearchTask(func=matmul_add, args=(N, L, M, "float32"), target=target)

# 检查计算图
print("Computational DAG:")
print(task.compute_dag)

输出结果:

Computational DAG:
A = PLACEHOLDER [1024, 1024]
B = PLACEHOLDER [1024, 1024]
matmul(i, j) += (A[i, k]*B[k, j])
C = PLACEHOLDER [1024, 1024]
out(i, j) = (matmul[i, j] + C[i, j])

设置 auto-scheduler 的参数

接下来,为 auto-scheduler 设置参数。

num_measure_trials 表示搜索过程中可用的测试试验次数。本教程为了快速演示只进行了 10 次试验。实际上,1000 是搜索收敛的最佳数量。可以根据自己的时间预算进行更多试验。
此外,我们用 RecordToFile 将测试记录记录到文件 matmul.json 中。测试记录可用于查询历史最佳、恢复搜索以及以后进行更多分析。
有关更多参数,参见 TuningOptions

log_file = "matmul.json"
tune_option = auto_scheduler.TuningOptions(
    num_measure_trials=10,
    measure_callbacks=[auto_scheduler.RecordToFile(log_file)],
    verbose=2,
)

开始搜索

准备好所有输入就可以开始搜索,让 auto-scheduler 发挥它的作用。经过一些测试试验后,可从日志文件中加载最佳 schedule 并应用。

# 运行 auto-tuning(搜索)
task.tune(tune_option)
# 应用最佳 schedule
sch, args = task.apply_best(log_file)

检查优化的 schedule

auto-scheduling 完成后,可将 schedule 降级来查看 IR。auto-scheduler 执行合适的优化,包括多级循环切分、布局转换、并行化、向量化、循环展开和算子融合。

print("Lowered TIR:")
print(tvm.lower(sch, args, simple_mode=True))

输出结果:

Lowered TIR:
@main = primfn(A_1: handle, B_1: handle, C_1: handle, out_1: handle) -> ()
  attr = {"from_legacy_te_schedule": True, "global_symbol": "main", "tir.noalias": True}
  buffers = {A: Buffer(A_2: Pointer(float32), float32, [1048576], []),
             B: Buffer(B_2: Pointer(float32), float32, [1048576], []),
             C: Buffer(C_2: Pointer(float32), float32, [1048576], []),
             out: Buffer(out_2: Pointer(float32), float32, [1048576], [])}
  buffer_map = {A_1: A, B_1: B, C_1: C, out_1: out}
  preflattened_buffer_map = {A_1: A_3: Buffer(A_2, float32, [1024, 1024], []), B_1: B_3: Buffer(B_2, float32, [1024, 1024], []), C_1: C_3: Buffer(C_2, float32, [1024, 1024], []), out_1: out_3: Buffer(out_2, float32, [1024, 1024], [])} {
  allocate(auto_scheduler_layout_transform: Pointer(global float32), float32, [1048576]), storage_scope = global {
    for (ax0.ax1.fused.ax2.fused: int32, 0, 128) "parallel" {
      for (ax4: int32, 0, 256) {
        for (ax6: int32, 0, 4) {
          for (ax7: int32, 0, 8) {
            auto_scheduler_layout_transform_1: Buffer(auto_scheduler_layout_transform, float32, [1048576], [])[((((ax0.ax1.fused.ax2.fused*8192) + (ax4*32)) + (ax6*8)) + ax7)] = B[((((ax4*4096) + (ax6*1024)) + (ax0.ax1.fused.ax2.fused*8)) + ax7)]
          }
        }
      }
    }
    for (i.outer.outer.j.outer.outer.fused: int32, 0, 16384) "parallel" {
      allocate(matmul: Pointer(global float32x8), float32x8, [4]), storage_scope = global;
      for (i.outer.inner: int32, 0, 2) {
        matmul_1: Buffer(matmul, float32x8, [4], [])[0] = broadcast(0f32, 8)
        matmul_1[1] = broadcast(0f32, 8)
        matmul_1[2] = broadcast(0f32, 8)
        matmul_1[3] = broadcast(0f32, 8)
        for (k.outer: int32, 0, 256) {
          for (k.inner: int32, 0, 4) {
            let cse_var_2: int32 = (((floormod(i.outer.outer.j.outer.outer.fused, 128)*8192) + (k.outer*32)) + (k.inner*8))
            let cse_var_1: int32 = ((((floordiv(i.outer.outer.j.outer.outer.fused, 128)*8192) + (i.outer.inner*4096)) + (k.outer*4)) + k.inner)
             {
              matmul_1[0] = (matmul_1[0] + (broadcast(A[cse_var_1], 8)*auto_scheduler_layout_transform_1[ramp(cse_var_2, 1, 8)]))
              matmul_1[1] = (matmul_1[1] + (broadcast(A[(cse_var_1 + 1024)], 8)*auto_scheduler_layout_transform_1[ramp(cse_var_2, 1, 8)]))
              matmul_1[2] = (matmul_1[2] + (broadcast(A[(cse_var_1 + 2048)], 8)*auto_scheduler_layout_transform_1[ramp(cse_var_2, 1, 8)]))
              matmul_1[3] = (matmul_1[3] + (broadcast(A[(cse_var_1 + 3072)], 8)*auto_scheduler_layout_transform_1[ramp(cse_var_2, 1, 8)]))
            }
          }
        }
        for (i.inner: int32, 0, 4) {
          let cse_var_3: int32 = ((((floordiv(i.outer.outer.j.outer.outer.fused, 128)*8192) + (i.outer.inner*4096)) + (i.inner*1024)) + (floormod(i.outer.outer.j.outer.outer.fused, 128)*8))
          out[ramp(cse_var_3, 1, 8)] = (matmul_1[i.inner] + C[ramp(cse_var_3, 1, 8)])
        }
      }
    }
  }
}

检查正确性并评估性能

构建二进制文件并检查其正确性和性能。

func = tvm.build(sch, args, target)
a_np = np.random.uniform(size=(N, L)).astype(np.float32)
b_np = np.random.uniform(size=(L, M)).astype(np.float32)
c_np = np.random.uniform(size=(N, M)).astype(np.float32)
out_np = a_np.dot(b_np) + c_np

dev = tvm.cpu()
a_tvm = tvm.nd.array(a_np, device=dev)
b_tvm = tvm.nd.array(b_np, device=dev)
c_tvm = tvm.nd.array(c_np, device=dev)
out_tvm = tvm.nd.empty(out_np.shape, device=dev)
func(a_tvm, b_tvm, c_tvm, out_tvm)

# Check results
np.testing.assert_allclose(out_np, out_tvm.numpy(), rtol=1e-3)

# Evaluate execution time.
evaluator = func.time_evaluator(func.entry_name, dev, min_repeat_ms=500)
print(
    "Execution time of this operator: %.3f ms"
    % (np.median(evaluator(a_tvm, b_tvm, c_tvm, out_tvm).results) * 1000)
)

输出结果:

Execution time of this operator: 93.286 ms

使用记录文件

在搜索过程中,所有测试记录都保存到记录文件 matmul.json 中。测试记录可用于重新应用搜索结果、恢复搜索和执行其他分析。

下面是从文件中加载最佳 schedule,并打印等效的 Python schedule API 的例子。可用于调试和学习 auto-scheduler 的行为。

print("Equivalent python schedule:")
print(task.print_best(log_file))

输出结果:

Equivalent python schedule:
matmul_i, matmul_j, matmul_k = tuple(matmul.op.axis) + tuple(matmul.op.reduce_axis)
out_i, out_j = tuple(out.op.axis) + tuple(out.op.reduce_axis)
matmul_i_o_i, matmul_i_i = s[matmul].split(matmul_i, factor=4)
matmul_i_o_o_i, matmul_i_o_i = s[matmul].split(matmul_i_o_i, factor=1)
matmul_i_o_o_o, matmul_i_o_o_i = s[matmul].split(matmul_i_o_o_i, factor=2)
matmul_j_o_i, matmul_j_i = s[matmul].split(matmul_j, factor=8)
matmul_j_o_o_i, matmul_j_o_i = s[matmul].split(matmul_j_o_i, factor=1)
matmul_j_o_o_o, matmul_j_o_o_i = s[matmul].split(matmul_j_o_o_i, factor=1)
matmul_k_o, matmul_k_i = s[matmul].split(matmul_k, factor=4)
s[matmul].reorder(matmul_i_o_o_o, matmul_j_o_o_o, matmul_i_o_o_i, matmul_j_o_o_i, matmul_k_o, matmul_i_o_i, matmul_j_o_i, matmul_k_i, matmul_i_i, matmul_j_i)
out_i_o_i, out_i_i = s[out].split(out_i, factor=4)
out_i_o_o, out_i_o_i = s[out].split(out_i_o_i, factor=2)
out_j_o_i, out_j_i = s[out].split(out_j, factor=8)
out_j_o_o, out_j_o_i = s[out].split(out_j_o_i, factor=1)
s[out].reorder(out_i_o_o, out_j_o_o, out_i_o_i, out_j_o_i, out_i_i, out_j_i)
s[matmul].compute_at(s[out], out_j_o_i)
out_i_o_o_j_o_o_fused = s[out].fuse(out_i_o_o, out_j_o_o)
s[out].parallel(out_i_o_o_j_o_o_fused)
s[matmul].pragma(matmul_i_o_o_o, "auto_unroll_max_step", 8)
s[matmul].pragma(matmul_i_o_o_o, "unroll_explicit", True)
s[matmul].vectorize(matmul_j_i)
s[out].vectorize(out_j_i)

恢复搜索则更为复杂,需要自己创建搜索策略和 cost model,并通过日志文件恢复搜索策略和 cost model 的状态。下面的示例进行了 5 次试验来恢复它们的状态:

def resume_search(task, log_file):
    print("Resume search:")
    cost_model = auto_scheduler.XGBModel()
    cost_model.update_from_file(log_file)
    search_policy = auto_scheduler.SketchPolicy(
        task, cost_model, init_search_callbacks=[auto_scheduler.PreloadMeasuredStates(log_file)]
    )
    tune_option = auto_scheduler.TuningOptions(
        num_measure_trials=5, measure_callbacks=[auto_scheduler.RecordToFile(log_file)]
    )
    task.tune(tune_option, search_policy=search_policy)

resume_search(task, log_file)

输出结果:

Resume search:
/usr/local/lib/python3.7/dist-packages/xgboost/training.py:17: UserWarning: Old style callback is deprecated.  See: https://xgboost.readthedocs.io/en/latest/python/callbacks.html
  warnings.warn(f'Old style callback is deprecated.  See: {link}', UserWarning)

最后的说明和总结

本教程展示了如何在不指定搜索模板的情况下,使用 TVM Auto-Scheduler 自动优化矩阵乘法。从张量表达式(TE)语言开始,演示了一系列关于 TVM 如何优化计算操作的示例。

下载 Python 源代码
下载 Jupyter Notebook

以上就是该文档的全部内容,查看更多 TVM 中文文档,请访问→TVM 中文站

【信息科学与工程学】计算机科学与自动化——第二十四篇 编译器05 由于16列横向排版过长,我将采用。 阅读详情

相关推荐

【信息科学与工程学】计算机科学与自动化——第二十四篇 编译器10——编译原理与词法分析02

链接时优化:全局DCE(579)、LTO(580)安全编译:CFI(581、586)、ASan(582)、UBSan(583)、MSan(584)、TSan(585)、CET(587)、PAC(588)、MTE(589)、SFI(590)、Wasm沙箱(591)侧信道与秘密:侧信道缓解(592)、常量时间(593)、秘密清理(594)内存安全:ASLR(595)、栈保护(596)、整数溢出检测(597)、除零检测(598)、空指针检测(599)、数组边界检查(600)至此编号达到600。

weixin_49199313的博客 197

TVM中的auto-scheduling机制(Ansor)学习笔记

背景 TVM沿用了Halide中算法的计算与调度分离的思想。用户使用Tensor Expression(TE)这种DSL定义计算,然后编译器优化相应的schedule,最后生成目标平台的代码。因此,要根据给定的计算自动产生高性能的算子实现,其核心就是找到好的schedule。然而这个schedule不仅和计算相关,还与硬件平台相关。这个搜索空间很大,本质上是个np-complete的组合优化问题。因此,TVM引入了auto-tuning机制,它使得编译出的算子实现性能上有了很大提升。最早一代的auto-tu

世事难料,保持低调 9981

【信息科学与工程学】【数据中心】 第十九篇 MFU的优化提升方法03

等级模块类型子模块子子模块功能描述MFU影响因子优化优先级L0​算术逻辑单元(ALU)标量ALU整数ALU标量整数运算α_int = 0.1-0.3中浮点ALU标量浮点运算α_fp_scalar = 0.2-0.4中向量处理单元(VPU)SIMD单元128-bit SIMD短向量运算β_SIMD128 = 0.3-0.6高256-bit SIMD中向量运算β_SIMD256 = 0.4-0.7高512-bit SIMD长向量运算β_SIMD512 = 0.5-0.8极高矩阵处理单元(MPU)Tensor C

weixin_49199313的博客 1015

【tvm官网教程】AutoSchedule:无模板的自动调度

【tvm官网教程】AutoSchedule:无模板的自动调度目的1. 自动调度GPU的卷积层2. 为x86 CPU自动调度NN 目的 autotvm是基于模板的调优,效果依赖于手动设计的搜索空间。 auto-scheduler不再基于模板,用户只需要编写计算声明,而无需任何调度命令或模板。auto-scheduler可以自动生成一个较大的搜索空间,并在该空间中找到良好的调度。 1. 自动调度GPU的卷积层 不需要定义搜索空间,但是还是要指定一些调度参数,知道在搜索过程中如何进行测量。 定义计算: @auto

B10030607的博客 2060

无刷直流电机矢量控制(四):基于滑模观测器的无传感器控制

无刷直流电机矢量控制,采用转速、电流双环控制,电流环dq解耦,d轴采用id=0控制,q轴采用转速外环。采用滑模观测器(SMO),根据电压电流信息进行电机位置角度动态估算,模型可直接运行,转速和角度跟踪精度较高。 本文整理了该方法的基本原理,介绍了在MATLAB/Simulink中的建模和仿真过程,最后附上完整的模型文件。 一、基本原理 滑模观测器(下文简称SMO)是基于滑模变结构控制方法的一种状态观测器。其针对无刷直流电机转子位置估算的实现过程如下。 假设采用矢量控...

Forster-C的博客 6869

Allegro17.4原理图-PCB双向联动技巧:从网表生成到同步高亮

本文深入解析了Cadence Allegro 17.4中原理图与PCB的深度双向联动技巧。核心在于通过精准的网表生成与管理、实时的跨窗口交互高亮与信号追踪,以及元件与封装的智能匹配更新,构建高效协同设计工作流。掌握这些技巧能显著提升高速、高密度电路设计的效率与准确性,实现从逻辑设计到物理实现的无缝衔接。

weixin_29178069的博客 359

ANSOR:一种Auto-Scheduler方法

Ansor(TVM auto shedule)学习调研

Dong_HFUT的博客 7083

三相逆变器拓扑结构的分析及应用场景

三相逆变器是电力电子领域中广泛应用的一种设备,用于将直流电转换为交流电。不同的拓扑结构在性能、成本、复杂度和应用领域上存在差异。小编将在本文中将进一步拓展对三相逆变器拓扑结构的分析,并探讨其适用的应用场景。

道合顺的博客 2240

TVM推理性能调优终极指南:从算子优化到整体部署的10个技巧

TVM深度学习编译器作为业界领先的开源深度学习编译器,专门针对CPU、GPU和各种专用加速器提供端到端的优化解决方案。无论你是AI应用开发者还是系统优化工程师,掌握TVM推理性能调优技巧都能让你的模型运行速度提升数倍! ## 为什么选择TVM进行推理优化? TVM编译器通过自动化的调度优化和算子融合技术,能够显著提升深度学习模型的推理性能。其独特的跨平台特性支持从云端服务器到边缘设备的全场景部

gitblog_00113的博客 766

#Linux内存管理# 用一个案例详细介绍ARMv7-A架构 缺页中断处理的原理

跳转到异常向量:根据 异常向量表基地址(通常配置在 VBAR 寄存器中,例如 0xFFFF0000) + 数据中止异常的偏移量 0x10,跳转到数据中止异常的处理程序入口点 0xFFFF0010(实践中,这个入口通常是一条跳转到更复杂处理函数的指令)。malloc 通常不会立即分配物理内存页,它只是在内核为该进程维护的虚拟地址空间中找到一段足够大的空闲虚拟地址区域(比如 0x00008000 - 0x00008FFF),标记为已用,并返回起始地址(例如 0x00008000)给程序。

sinat_37817094的博客 993

3分钟创建智能体

智能体简介会在首页以及名片页展示,需要简洁明了的介绍智能体用途✅优秀示例:最好用第三人称直接说明智能体用途~如:打造生动文案好帮手、专业解梦,探寻梦境奥秘等❌反面教材:简介并未介绍用途、语义含糊。如:今天写点啥、看看你做的梦等以上步骤完成后,点击发布,就能成功创建属于你自己的智能体啦~仅自己可访问(免审):发布后仅开发者本人账号可访问、预览、使用该智能体仅链接可访问:发布后任何人均可通过链接访问、预览、使用该智能体。

soso1968的博客 2086

SpringBoot定时任务---------学习第六天

愿你我共同成长! 今天的定时任务有两种: 1.Schedudel定时任务器 2.Quartz定时任务 一,Schedudel定时任务器(Scheduled 定时任务器:是 Spring3.0 以后自带的一个定时任务器。,没什么好多说的,直接上代码 ) 首先引入依赖 <!-- 添加 Scheduled 坐标 --> <depende...

zxs281的博客 342

无线通信中的多智能体强化学习:基于CTDE-MAPPO的功率控制优化

无线通信中的多智能体强化学习:基于CTDE-MAPPO的功率控制优化 摘要:本研究提出了一种基于集中训练分布式执行(CTDE)框架的多智能体近端策略优化(MAPPO)算法,用于解决无线通信网络的分布式功率控制问题。通过将多个基站建模为协作智能体,该系统能够在复杂动态环境中优化网络效用。算法采用集中训练获取全局信息优势,分布式执行实现高效在线决策,显著提升了网络容量和能效。实验结果表明,该方法在5G/6G网络环境中表现出优于传统方法的性能,为大规模无线网络的智能资源管理提供了有效解决方案。

huanghm88的专栏 811

TVM:使用 Auto-scheduling 来优化算子

TVM:使用 Auto-scheduling 来优化算子 在本教程中,我们将展示 TVM 的 Auto-scheduling 功能如何在无需编写自定义模板的情况下找到最佳 schedule。 与基于模板的 AutoTVM 依赖手动模板定义搜索空间不同,auto-scheduler 不需要任何模板。 用户只需编写计算声明,无需任何调度命令或模板。 auto-scheduler 可以自动生成一个大的搜索空间,并在该空间中找到一个好的 schedule。 我们在本教程中同样使用矩阵乘法作为示例。 import o

weixin_44966641的博客 1262

【箱子之字形摆放】python实现-附ChatGPT解析

箱子之形摆放有一批箱子(形式为宁符串,设为str) ,要求将这批箱子按以之形的顺序摆放在宽度为n的空地,请输出箱子的摆放结果。例如:箱子为ABCDEFG,空地宽度为3,摆放结果如图:则输出结果为:AFGBECD输入一行字符串,通过空格分制,前面部分为字母或数字组成的字符串str,表示;后面部分为一个数字n,表示。ABCDEFG 3箱子摆放结果,如题目示例所示AFGBECD。

sinat_29950703的博客 371

三维重建(十八)——colmap的使用(粗浅)

三维重建(十八)——colmap的使用(粗浅)

河海大学研究生在读的学习笔记 1378

使用Auto-scheduling优化算子

本文翻译自Optimizing Operators with Auto-scheduling — tvm 0.9.dev0 documentation 在本教程中,我们将展示TVM的自动调度功能如何在不编写自定义模板的情况下找到最佳调度。 基于模板的AutoTVM通过手写模板来定义搜索空间,而自动调度器不需要任何模板。用户只需要编写计算声明,不需要任何调度命令或模板。自动调度器可以自动生成一个较大的搜索空间,并在这个空间中找到一个好的调度。 我们在本教程中使用矩阵乘法作为例子。 注意:本教程的代码不

zx_ros的博客 417

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

TVM官方文档翻译入口

TVM官方文档翻译

zx_ros的博客 601

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Apache TVM 文档导航与快速上手实践指南

Apache TVM 是一个面向"任意设备、任意环境"的机器学习编译框架(Open Machine Learning Compiler Framework),其官方文档入口 [docs/index.rst](https://link.gitcode.com/i/4a7fe03a2e54cd6786b66dfc7327a8cc) 以 7 组 `toctree` 导航目录,完整组织了从安装、入门、实战

gitblog_00973的博客 388

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

TVM 架构设计全解:从端到端编译流程到逻辑模块分层

本文以 TVM 官方架构文档 [docs/arch/index.rst](https://link.gitcode.com/i/0bae02ac4a634412c4eb4c5a4ed9def5) 为核心骨架,面向希望理解 TVM 编译栈整体设计、乃至希望参与 TVM 开发的技术人员。文章先沿着一条典型的端到端编译流程,剖析 Import(导入)、Transformation(变换)、Target

gitblog_00027的博客 405

Triton GPU编程:用Python编写高性能AI算子的原理与实践

GPU加速计算的核心在于高效利用硬件并行性与内存带宽,其底层依赖对SM调度、shared memory bank、warp divergence等架构特性的精细控制。传统CUDA开发需深入硬件手册,抽象层级低、跨平台难、调试成本高;而Triton通过将Python函数作为IR、编译器动态生成SASS指令,实现了‘高层语义+硬件感知’的统一。它自动处理memory coalescing、bank conflict规避、Tensor Core映射等关键优化,显著降低custom op开发门槛。在A100/H10

weixin_30381317的博客 408

AI 编译器全景解析:从朴素编译器到通用编译器的演进、通用架构与未来挑战

AI 编译器是连接神经网络模型与异构 AI 芯片之间的关键桥梁,它通过将训练好的模型或高层语言程序转换为可在特定硬件上高效执行的代码,帮助开发者摆脱手工优化算力的人力成本。本文基于 AISystem 项目中《AI 编译器》章节的系列文档,系统梳理 AI 编译器诞生的背景与必要性、三阶段发展历程、通用架构(前端/后端、IR、优化 Pass)以及当前主流编译器(TVM、XLA、nGraph、TC、Gl

gitblog_00315的博客 607

Mini-SGLang 实战指南:从零部署 OpenAI 兼容的高性能 LLM 推理服务

Mini-SGLang 是 SGLang 的一个紧凑实现,用约 5000 行 Python 代码构建出一套完整可用的 LLM 推理与 Serving 系统,目标是"去神秘化"现代 LLM serving 的复杂性。本文以仓库 [README.md](https://link.gitcode.com/i/95c66cb1db20db6734c667e64dc3b470) 为主线,结合 [docs/f

gitblog_00072的博客 437

AISystem 系列:AI 编译器通用架构详解——从前端 IR 到后端代码生成

> 本文是 [AI 编译器](https://link.gitcode.com/i/935e665f6babc2c9b8194e7d0b2ecf99) 系列课程的架构篇。在前文 [AI 编译器历史阶段](https://link.gitcode.com/i/aa5cbce7c0f23dcf080ca039527a76b6) 中,我们把 AI 编译器的发展划分为朴素编译器、专用编译器、通用编译器三个

gitblog_00568的博客 381

TileLang 自动调优(Auto-Tuning)实践指南:保留参数、候选配置搜索与并行基准测试

TileLang 的自动调优机制将“手写一个带预留优化参数的 kernel、给出候选配置空间、并行编译并基准测试选出最优配置”封装为一条标准工作流。本文基于 [官方教程](https://link.gitcode.com/i/92fe6248eaa1b4123792c66dc19aaaf3),结合 [AutoTuner 源码](https://link.gitcode.com/i/196aaab9

gitblog_00424的博客 203

AI芯片软硬件协同设计:从算法到硅片的系统工程实践

AI芯片并非单纯硬件加速器,而是面向高算力、低功耗、实时性约束的异构计算系统。其核心在于打破冯·诺依曼瓶颈,通过软硬件协同优化实现计算、存储与通信的全局平衡。关键技术涵盖RISC-V向量扩展、存算近邻架构、编译器驱动的算子映射及动态内存规划,支撑Transformer、YOLO等主流模型在边缘端高效落地。本文聚焦AI芯片设计中‘能效比’与‘编译器优化’两大关键热词,解析从PyTorch模型拆解、张量单元RTL实现到FPGA原型验证的全链路工程方法,覆盖消费电子、智能驾驶与工业质检等真实部署场景。

weixin_33805992的博客 673
上一篇: 【TVM 学习资料】用 Schedule 模板和 AutoTVM 优化算子
下一篇: 6 大经典机器学习数据集,3w+ 用户票选得出,建议收藏
HyperAI超神经
博客等级 码龄7年 8873粉丝 1753原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值