斯坦福开源新突破:百行代码助H100性能提升30%

用ldmatrix与mma指令模拟wgmma指令 英伟达即将发布下一代架构,SM号12.0,以下简称sm120。相比于目前的主流Hopper架构(SM号9.0,简称sm90),很明显的一个改动是TensorCore不再支持warpgroup MMA指令,“退化”到了类似于Ampere架构mma指令。而目前爆火的DeepSeek、特别是其重要的组成部分,其实现与sm90深度绑定。 阅读详情

提高 GPU 利用率,就是这么简单。

AI 的快速发展,伴随而来的是大计算量。这就自然而然的引出了一个问题:如何减少 AI 对计算的需求,并提高现有 AI 计算效率。

为了回答这一问题,来自斯坦福的研究者在博客《GPUs Go Brrr》中给出了答案。

图片

文章主要专注于两个问题:一是硬件真正需要什么?二是如何满足硬件需求?

文章用大量篇幅讨论了如何让 GPU 更快的运行,并发布了一个库 ThunderKittens,用户可以很容易地在 CUDA 上编写快速的深度学习内核。其具有以下特点:

  • 简单,ThunderKittens 写起来非常简单。
  • 可扩展性,如果用户需要 ThunderKittens 无法提供的功能,可以进行功能扩展。
  • 速度快。

图片

ThunderKittens 使得一些棘手的事情变得非常简单,从而在现代硬件上实现了非常高的利用率。项目中,作者用 ThunderKittens 编写了一个 RTX 4090 简单的 FlashAttention-2 内核,代码总共有 58 行代码(不包括空格),结果显示,ThunderKittens 在 RTX 4090 上实现了大约 122 TFLOP(理论最大值的 74%)。此外,内核程序只有 100 行的情况下,ThunderKittens 在 H100 上的性能比 FlashAttention-2 高出约 30%。

英伟达 H100 有些小怪癖

该研究重点关注 NVIDIA H100,不过所介绍的内容也适用于其他 GPU。

图片

H100 SXM GPU 包含:

  • 80 GB HBM3,带宽为 3 TB/s(实际上带宽会少一些);
  • 50 MB 二级缓存,带宽 12 TB/s,在 GPU 上分成两个 25MB 的部分,通过 crossbar 连接;
  • 132 个流多处理器 (SM,streaming multiprocessors)。

除了上述这些,H100 SXM GPU 还有很多可关注的东西,例如内存控制器、指令缓存等。

研究者表示保持张量核心的运行流畅并不容易。他们发现了一些 AI 硬件上的怪癖,这些怪癖中的很多内容也适用于非 H100 GPU,但 H100 尤其棘手。(相比之下,RTX 4090 则非常容易使用),这些怪癖包括:

  • WGMMA 指令是必需的,但使用起来也非常令人恼火;
  • 共享内存实际上并没有那么快,并且需要非常小心;
  • 地址生成成本很高;
  • 占用率仍然有帮助,寄存器通常是关键资源。

图片

文章进一步描述了 GPU 这些怪癖的具体内容。

WGMMA 指令令人恼火

H100 有一组新指令,称为「warp group matrix multiply accumulate,WGMMA」(PTX 中的 wgmma.mma_async,或 SASS 中的 HGMMA/IGMMA/QGMMA/BGMMA)。以前的 GPU 上可用的张量核心指令是 wmma.mma.sync 和 mma.sync 。通过这些指令,SM 单个象限上的 32 个线程将同步地将其数据块馈送到张量核心并等待结果。

不同的是,wgmma.mma_async 指令并非如此,128 个连续线程(分布在 SM 的所有象限中)协作同步,并直接从共享内存(也可以选择寄存器)异步启动矩阵乘法。

在基准测试中,研究团队发现这些指令对于提取 H100 的完整计算是必要的。如果没有它们,GPU 的峰值利用率似乎只能达到峰值利用率的 63% 左右。

在这里插入图片描述

共享内存

共享内存的单次访问延迟约为 30 个周期,这听起来似乎不算多,但在这段时间内,SM 的张量核心几乎可以完成两个完整的 32x32 矩阵乘法运算。

共享内存处理起来有些棘手,因为它被存储(banked)在 32 个独立的内存存储中。如果不小心,这可能会导致所谓的 bank 冲突,即同一内存 bank 被要求同时提供多个不同的内存片段,导致请求被串行化,这可能会不成比例地减慢内核的速度 - 而 wgmma 和 mma 指令所需的寄存器布局会受到这些 bank 冲突的影响。解决方法是使用各种交错模式重新排列共享内存,以避免这些冲突。

地址生成

H100 其中一个特点是张量核心和内存都足够快,以至于仅仅生成用于获取数据的内存地址就占据了芯片资源的相当一部分。

NVIDIA 似乎已经意识到了这一点,因为他们赋予了 GPU 张量内存加速器(或称之为 TMA)。TMA 允许用户在全局和共享内存中指定多维张量布局,这节省了所有的地址生成成本,并且还使得构建 pipeline 更加容易。

研究团队还发现 TMA 和 wgmma.mma_async 一样,在实现 H100 的全部潜力方面是完全不可或缺的。

占用

在某些方面,与前几代硬件相比,H100 对占用率的依赖程度较低。NVIDIA 确实在设计 GPU 时考虑了占用率。虽然对于 H100 来说,占用率只能说有用,但作用不大。研究者发现在 A100 和 RTX 4090 上它变得越来越重要。

ThunderKittens

那么,如何才能更轻松地编写内核,同时仍兼具硬件的全部功能?

研究团队设计了一个嵌入 CUDA 中的 DSL,被命名为 ThunderKittens。

在这里插入图片描述

ThunderKittens 旨在尽可能简单,并包含四种模板类型:

  • 寄存器 tile—— 寄存器文件中的 2D 张量。
  • 寄存器向量 —— 寄存器文件中的 1D 张量。
  • 共享 tile—— 共享内存中的 2D 张量。
  • 共享向量 —— 共享内存中的 1D 张量。

tile 通过高度、宽度和布局进行参数化,寄存器向量由长度和布局参数化,共享向量仅由长度参数化。这样通常不会遭受 bank 冲突的困扰。

研究团队还提供了一些必要操作:

初始化,如将共享向量清零

  • 一元运算,如 exp
  • 二元运算,如 mul
  • 行 / 列操作,如 row_sum

该研究给出了一个用 ThunderKittens 编写的,用于 RTX 4090 的简单前向 flash attention 内核:

#define NUM_WORKERS 16 // This kernel uses 16 workers in parallel per block, to help issue instructions more quickly.
using namespace kittens; // this kernel only handles headdim=64 for simplicity. Also n should be a multiple of 256 here.
__global__ void attend_ker64(int n, const bf16* __restrict__ __q__, const bf16* __restrict__ __k__, const bf16* __restrict__ __v__, bf16* __o__) {

      auto warpid        = kittens::warpid();    
      auto block_start   = blockIdx.x*(n*64);    
      const bf16 *_q = __q__ + block_start, *_k = __k__ + block_start, *_v = __v__ + block_start;          
      bf16 *_o = __o__ + block_start;
      
      extern __shared__ alignment_dummy __shm[]; // this is the CUDA shared memory
      shared_allocator al((int*)&__shm[0]);
      
      // K and V live in shared memory -- this is about all that will fit.
      st_bf_1x4<ducks::st_layout::swizzle> (&k_smem)[NUM_WORKERS] = al.allocate<st_bf_1x4<ducks::st_layout::swizzle>, NUM_WORKERS>();
      st_bf_1x4<ducks::st_layout::swizzle> (&v_smem)[NUM_WORKERS] = al.allocate<st_bf_1x4<ducks::st_layout::swizzle>, NUM_WORKERS>();
      
      // Initialize all of the register tiles.
      rt_bf_1x4<> q_reg, k_reg, v_reg; // v_reg need to be swapped into col_l
      rt_fl_1x1<> att_block;
      rt_bf_1x1<> att_block_mma;
      rt_fl_1x4<> o_reg;
      rt_fl_1x1<>::col_vec max_vec_last, max_vec; // these are column vectors for the attention block
      rt_fl_1x1<>::col_vec norm_vec_last, norm_vec; // these are column vectors for the attention block
      
      int qo_blocks = n / (q_reg.rows*NUM_WORKERS), kv_blocks = n / (q_reg.rows*NUM_WORKERS);
      
      for(auto q_blk = 0; q_blk < qo_blocks; q_blk++) {
      
      // each warp loads its own Q tile of 16x64, and then multiplies by 1/sqrt(d)
      load(q_reg, _q + (q_blk*NUM_WORKERS + warpid)*q_reg.num_elements, q_reg.cols);
      mul(q_reg, q_reg, __float2bfloat16(0.125f)); // temperature adjustment
      
      // zero flash attention L, M, and O registers.
      neg_infty(max_vec); // zero registers for the Q chunk
      zero(norm_vec);
      zero(o_reg);
      
      // iterate over k, v for these q's that have been loaded
      for(auto kv_idx = 0; kv_idx < kv_blocks; kv_idx++) {
      
          // each warp loads its own chunk of k, v into shared memory
          load(v_smem[warpid], _v + (kv_idx*NUM_WORKERS + warpid)*q_reg.num_elements, q_reg.cols);
          load(k_smem[warpid], _k + (kv_idx*NUM_WORKERS + warpid)*q_reg.num_elements, q_reg.cols);
          __syncthreads(); // we need to make sure all memory is loaded before we can begin the compute phase
          
          // now each warp goes through all of the subtiles, loads them, and then does the flash attention internal alg.
          for(int subtile = 0; subtile < NUM_WORKERS; subtile++) {
          
          load(k_reg, k_smem[subtile]); // load k from shared into registers
          
          zero(att_block); // zero 16x16 attention tile
          mma_ABt(att_block, q_reg, k_reg, att_block); // Q@K.T
          
          copy(norm_vec_last, norm_vec);
          copy(max_vec_last,  max_vec);
          
          row_max(max_vec, att_block, max_vec); // accumulate onto the max_vec
          sub_row(att_block, att_block, max_vec); // subtract max from attention -- now all <=0
          exp(att_block, att_block); // exponentiate the block in-place.
          
          sub(max_vec_last, max_vec_last, max_vec); // subtract new max from old max to find the new normalization.
          exp(max_vec_last, max_vec_last); // exponentiate this vector -- this is what we need to normalize by.
          mul(norm_vec, norm_vec, max_vec_last); // and the norm vec is now normalized.
          
          mul(norm_vec, norm_vec, max_vec_last); // and the norm vec is now normalized.
          div_row(att_block, att_block, norm_vec); // now the attention block is correctly normalized
          
          mul(norm_vec_last, norm_vec_last, max_vec_last); // normalize the previous norm vec according to the new max
          div(norm_vec_last, norm_vec_last, norm_vec); // normalize the previous norm vec according to the new norm
          
          copy(att_block_mma, att_block); // convert to bf16 for mma_AB
          
          load(v_reg, v_smem[subtile]); // load v from shared into registers.
          rt_bf_1x4<ducks::rt_layout::col> &v_reg_col = swap_layout_inplace(v_reg); // this is a reference and the call has invalidated v_reg
          
          mul_row(o_reg, o_reg, norm_vec_last); // normalize o_reg in advance of mma_AB'ing onto it
          mma_AB(o_reg, att_block_mma, v_reg_col, o_reg); // mfma onto o_reg with the local attention@V matmul.
      } 
      __syncthreads(); // we need to make sure all warps are done before we can start loading the next kv chunk
   }
   store(_o + (q_blk*NUM_WORKERS + warpid)*q_reg.num_elements, o_reg, q_reg.cols); // write out o. compiler has an issue with register usage if d is made constexpr q_reg.rows :/
}
}



      

总共大约有 60 行 CUDA 代码,硬件利用率为 75%,虽然非常密集,但大部分复杂性在于算法,而不是混合模式或寄存器布局。

TMA、WGMMA、swizzling 模式和描述符的复杂度又如何呢?如下是用 ThunderKittens 编写的, H100 的 FlashAttention-2 前向传递:

template<int D>
__global__  __launch_bounds__((NUM_WORKERS)*kittens::WARP_THREADS, 2)
void fwd_attend_ker_dim(int N, const CUtensorMap* tma_q, const CUtensorMap* tma_k, const CUtensorMap* tma_v, CUtensorMap* tma_o) {    
extern __shared__ int __shm[]; // this is the CUDA shared memory    
tma_swizzle_allocator al((int*)&__shm[0]);

    constexpr int tile_width = fwd_attend_ker_tile_dims<D>::tile_width; // 
    constants    constexpr int qo_height  = fwd_attend_ker_tile_dims<D>::qo_height;    
    constexpr int kv_height  = fwd_attend_ker_tile_dims<D>::kv_height;
    
    st_bf<qo_height, tile_width, layout_q>          (&q_smem)   [NUM_WARPGROUPS] = al.allocate<st_bf<qo_height, tile_width, layout_q>,          NUM_WARPGROUPS>();    
    st_bf<kv_height, tile_width, layout_k>          (&k_smem)[2][NUM_WORKERS_KV] = al.allocate<st_bf<kv_height, tile_width, layout_k>, 2,       NUM_WORKERS_KV>();    
    st_bf<kv_height, tile_width, layout_v>          (&v_smem)[2][NUM_WORKERS_KV] = al.allocate<st_bf<kv_height, tile_width, layout_v>, 2,       NUM_WORKERS_KV>();
    
    int tic = 0, toc = 1;     
    rt_fl<1, kv_height> att_block;    
    rt_bf<1, kv_height> att_block_mma;    
    rt_fl<1, qo_height> o_prev;    
    col_vec<rt_fl<1, kv_height>> max_vec_last, max_vec;    
    col_vec<rt_fl<1, kv_height>> norm_vec_last, norm_vec;
    
    int warpid      = kittens::warpid();    
    int warpgroupid = warpid/kittens::WARPGROUP_WARPS;
    
    int kv_blocks = N / (NUM_WORKERS_KV*k_smem[0][0].rows);
    __shared__ uint64_t qsmem_barrier, kvsmem_barrier;//, vsmem_barrier;
    int q_phasebit = 0;    
    int kv_phasebit = 0;
    
    if (threadIdx.x == 0) {        
        tma::init_barrier<st_bf<qo_height, tile_width, layout_q>, NUM_WARPGROUPS>(qsmem_barrier, 1);             
        tma::init_barrier<st_bf<kv_height, tile_width, layout_k>, NUM_WORKERS_KV*2>(kvsmem_barrier, 1);     
    }
    if (warpid == 0) {        
        for (int wg = 0; wg < NUM_WORKERS/kittens::WARPGROUP_WARPS; wg++) { // load q            
            int tile_idx = (blockIdx.y * NUM_WARPGROUPS * gridDim.x) + (blockIdx.x * NUM_WARPGROUPS) + wg;            
            tma::load_async((q_smem[wg]), tma_q, qsmem_barrier, tile_idx);         
        }        
        for (int w = 0; w < NUM_WORKERS_KV; w++) { // load k, v                  
            int tile_idx = (blockIdx.y * NUM_WORKERS_KV * kv_blocks) + (0 * NUM_WORKERS_KV) + w;             
            tma::load_async((k_smem[tic][w]), tma_k, kvsmem_barrier, tile_idx);             
            tma::load_async((v_smem[tic][w]), tma_v, kvsmem_barrier, tile_idx);         
        }    
    }
    neg_infty(max_vec); // zero registers for the Q chunk    
    zero(norm_vec);    
    zero(o_prev);    
    __syncthreads();
    
    tma::arrive_and_wait(qsmem_barrier, q_phasebit);    
    q_phasebit ^= 1;
    	
    if constexpr (D == 64) { warpgroup::mul(q_smem[warpgroupid], q_smem[warpgroupid], __float2bfloat16(0.125f)); }     
    else { warpgroup::mul(q_smem[warpgroupid], q_smem[warpgroupid], __float2bfloat16(0.08838834764f)); }
    
    for (auto kv_idx = 0; kv_idx < kv_blocks; kv_idx++, tic ^= 1, toc ^= 1) {        
        tma::arrive_and_wait(kvsmem_barrier, kv_phasebit);        
        kv_phasebit ^= 1;
        
        __syncthreads();        
        if (warpid == 0) {            
           tma::set_bytes(kvsmem_barrier, 2 * NUM_WORKERS_KV * k_smem[0][0].num_elements * sizeof(bf16));
           
           if (kv_idx + 1 < kv_blocks) {                
               for (int w = 0; w < NUM_WORKERS_KV; w++) {                            
                   int tile_idx = (blockIdx.y * NUM_WORKERS_KV * kv_blocks) + ((kv_idx + 1) * NUM_WORKERS_KV) + w;                     
                   tma::load_async((k_smem[toc][w]), 
                   tma_k, kvsmem_barrier, tile_idx);                     tma::load_async((v_smem[toc][w]), tma_v, kvsmem_barrier, tile_idx);                
                   }            
            }        
      }
      warpgroup::mma_fence(att_block);        
      warpgroup::mm_ABt(att_block, q_smem[warpgroupid], k_smem[tic][0]);        
      warpgroup::mma_commit_group();
      
      copy(norm_vec_last, norm_vec);       
      copy(max_vec_last,  max_vec);
      
      warpgroup::mma_async_wait();
      
      row_max(max_vec, att_block, max_vec); // accumulate onto the max_vec        
      sub_row(att_block, att_block, max_vec);        
      exp(att_block, att_block);
      
      sub(max_vec_last, max_vec_last, max_vec);        
      exp(max_vec_last, max_vec_last);        
      mul(norm_vec, norm_vec, max_vec_last);
      
      row_sum(norm_vec, att_block, norm_vec); // accumulate onto the norm_vec        
      div_row(att_block, att_block, norm_vec);
      
      mul(norm_vec_last, norm_vec_last, max_vec_last);        
      div(norm_vec_last, norm_vec_last, norm_vec);
      
      copy(att_block_mma, att_block); // convert to bf16 for mma        
      mul_row(o_prev, o_prev, norm_vec_last); // normalize o_prev in advance of mma'ing onto it
      
      warpgroup::mma_fence(o_prev);        
      warpgroup::mma_AB(o_prev, att_block_mma, v_smem[tic][0]);        
      warpgroup::mma_commit_group();   
  }
      
  auto (*o_smem) = reinterpret_cast<st_bf<qo_height, tile_width, layout_o>(*)>(q_smem); // reuse q memory    
  warpgroup::store(o_smem[warpgroupid], o_prev);     
  __syncthreads();        
  
  if (warpid % 4 == 0) { // store o        
      int tile_idx = (blockIdx.y * NUM_WARPGROUPS * gridDim.x) + (blockIdx.x * NUM_WARPGROUPS) + warpgroupid;        
      tma::store_async(tma_o, (o_smem[warpgroupid]), tile_idx);         
      tma::store_commit_group();     
  }
  	
    tma::store_async_wait();
}

这个内核只有 100 行代码,它在 H100 上的性能比 FlashAttention-2 高出约 30%。ThunderKittens 负责 wrap up 布局和指令,并提供一个可以在 GPU 上使用的 mini-pytorch。

在这里插入图片描述
H100 SXM 上各种配置的 FlashAttention-2(Pytorch)与 ThunderKittens 的比较。

此外,研究团队还发布了基于线性注意力的内核和其他架构。基于线性注意力内核的运行速度为 215 TFLOP(如果考虑算法中固有的重计算,则运行速度超过 300 TFLOP)。

虽然理论上线性注意力更高效,但从实践经验来看,线性注意力在硬件上的效率大大降低。因此,ThunderKittens 有望开辟广泛的高吞吐量应用。

在这里插入图片描述
)使用 ThunderKittens 可以非常快地实现线性注意力。*

tile 看起来是个好点子

在研究团队看来,ThunderKittens 之所以运行良好,是因为它不会试图做所有事情。CUDA 确实比 ThunderKittens 更有表现力,而 ThunderKittens 又小又简单。

不过,ThunderKittens 具有很好的抽象能力,它具有小的 tile,这与 AI 和硬件的发展相匹配。ThunderKittens 不支持任何少于 16 的维数。但在研究团队看来,这一点并不重要,尤其对于硬件而言。如果你的矩阵乘法小于 16x16,你确定自己做的还是 AI 吗?

从哲学的视角来看,研究团队认为框架迁移是合理的。「寄存器」当然不应该像旧 CPU 那样的 32 位。CUDA 使用的 1024 位宽向量寄存器无疑朝着正确方向迈出了一步。但对研究团队而言,「寄存器」是 16x16 的数据 tile。他们认为 AI 想要这样,它仍然只是矩阵乘法、规约和重塑。当然硬件也想要这样,小的矩阵乘法寻求硬件支持,而不仅仅是 systolic mma。

实际上,从更广泛的视角来看,研究团队认为应该围绕硬件的良好映射来重新调整 AI 思路。比如,循环状态应该有多大?SM 能够容纳多大尺寸?计算密度是多少?这些都不亚于硬件的要求。

研究团队表示,这项工作未来的一个重要方向是利用他们对硬件的了解来帮助设计与硬件相匹配的 AI。

最后,AMD 硬件上适配的 ThunderKittens 也将很快推出。

如何学习大模型 AI ?

由于新岗位的生产效率,要优于被取代岗位的生产效率,所以实际上整个社会的生产效率是提升的。

但是具体到个人,只能说是:

“最先掌握AI的人,将会比较晚掌握AI的人有竞争优势”。

这句话,放在计算机、互联网、移动互联网的开局时期,都是一样的道理。

我在一线互联网企业工作十余年里,指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家,也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑,所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限,很多互联网行业朋友无法获得正确的资料得到学习提升,故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

在这里插入图片描述

第一阶段(10天):初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识,对大模型 AI 的理解超过 95% 的人,可以在相关讨论时发表高级、不跟风、又接地气的见解,别人只会和 AI 聊天,而你能调教 AI,并能用代码将大模型和业务衔接。

  • 大模型 AI 能干什么?
  • 大模型是怎样获得「智能」的?
  • 用好 AI 的核心心法
  • 大模型应用业务架构
  • 大模型应用技术架构
  • 代码示例:向 GPT-3.5 灌入新知识
  • 提示工程的意义和核心思想
  • Prompt 典型构成
  • 指令调优方法论
  • 思维链和思维树
  • Prompt 攻击和防范
  • …

第二阶段(30天):高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习,学会构造私有知识库,扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架,抓住最新的技术进展,适合 Python 和 JavaScript 程序员。

  • 为什么要做 RAG
  • 搭建一个简单的 ChatPDF
  • 检索的基础概念
  • 什么是向量表示(Embeddings)
  • 向量数据库与向量检索
  • 基于向量检索的 RAG
  • 搭建 RAG 系统的扩展知识
  • 混合检索与 RAG-Fusion 简介
  • 向量模型本地部署
  • …

第三阶段(30天):模型训练

恭喜你,如果学到这里,你基本可以找到一份大模型 AI相关的工作,自己也能训练 GPT 了!通过微调,训练自己的垂直大模型,能独立训练开源多模态大模型,掌握更多技术方案。

到此为止,大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗?

  • 为什么要做 RAG
  • 什么是模型
  • 什么是模型训练
  • 求解器 & 损失函数简介
  • 小实验2:手写一个简单的神经网络并训练它
  • 什么是训练/预训练/微调/轻量化微调
  • Transformer结构简介
  • 轻量化微调
  • 实验数据集的构建
  • …

第四阶段(20天):商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知,可以在云端和本地等多种环境下部署大模型,找到适合自己的项目/创业方向,做一名被 AI 武装的产品经理。

  • 硬件选型
  • 带你了解全球大模型
  • 使用国产大模型服务
  • 搭建 OpenAI 代理
  • 热身:基于阿里云 PAI 部署 Stable Diffusion
  • 在本地计算机运行大模型
  • 大模型的私有化部署
  • 基于 vLLM 部署大模型
  • 案例:如何优雅地在阿里云私有部署开源大模型
  • 部署一套开源 LLM 项目
  • 内容安全
  • 互联网信息服务算法备案
  • …

学习是一个过程,只要学习就会有挑战。天道酬勤,你越努力,就会成为越优秀的自己。

如果你能在15天内完成所有的任务,那你堪称天才。然而,如果你能完成 60-70% 的内容,你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

在这里插入图片描述

Hopper H100 GEMM优化实战:从TMA、WGMMA到Warp Specialization的性能爬坑记录 本文详细记录了在Hopper H100架构上优化GEMM性能的实战经验,从基础实现到最终超越cuBLAS性能的全过程。重点探讨了TMA(Tensor Memory Accelerator)、WGMMA(Warpgroup Matrix Multiply Accumulate)等关键技术的应用,以及Warp Specialization和寄存器分配优化等高级技巧,最终实现750 TFLOPS的性能突破。 阅读详情

相关推荐

wgmma指令解析

上图中的T0{d0,d1}表示的是thread0中的寄存器0和寄存器1中是A矩阵ROW0 * B矩阵COL0和A矩阵的ROW0和B矩阵的COL1的结果,T1{d0,d1}表示的是thread1中的寄存器0和寄存器1中是A矩阵ROW0 * B矩阵COL2和A矩阵的ROW0和B矩阵的COL3的结果,T4{d0,d1}表示的是thread4中的寄存器0和寄存器1中是A矩阵ROW1 * B矩阵COL0和A矩阵的ROW1和B矩阵的COL1的结果。

youzjuer的博客 466

探索高速深度学习魔法:ThunderKittens 框架

ThunderKittens 是一个专为 CUDA 设计的框架,旨在简化并加速深度学习内核的开发。它不仅易于上手,而且具备可扩展性,并承诺提供与从零开始编写的内核相当甚至更快的速度。无论你是经验丰富的开发者还是初涉GPU编程的新手,ThunderKittens 都能为你带来惊喜。 ## 项目介绍 ThunderKittens 的核心理念是利用现代GPU的硬件特性,通过处理小块数据(至少16x1...

gitblog_00011的博客 696

vscode中创建vue快捷键

1.安装Vetur插件(扩展里面直接搜) 2.vscode 界面里面左上角选则 文件=> 首选项=> 用户代码片段=>新建全局代码片段=>在输入框中新建名称为vue.json 3.删除里面的注释,当然你也可以留着,把下面的代码粘贴进去! { // Place your 全局 snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and // descri

Leon_940002463的博客 3209

ThunderKittens 开源项目教程

ThunderKittens 是一个由 HazyResearch 团队开发的开源项目,旨在提供一个高效且易于使用的框架,用于处理大规模数据集和复杂计算任务。该项目结合了最新的研究成果和工业界实践,旨在为数据科学家和工程师提供一个强大的工具集,以便在各种应用场景中快速构建和部署高性能的计算模型。 ## 项目快速启动 ### 环境准备 在开始使用 ThunderKittens 之前,请确保您的开...

gitblog_00119的博客 1078

U-Boot 适配新型号 SPI Nor Flash 实战解析

本文详细解析了U-Boot适配新型号SPI Nor Flash的全过程,从JEDEC ID识别错误入手,深入源码分析Flash信息数据库,结合实际手册参数添加新设备支持。重点介绍了设备树同步和验证调试的关键步骤,并总结了常见问题与解决方案,为嵌入式开发者提供实用参考。

weixin_29170327的博客 205

YOLOv11的对比学习预训练改进-(通过SimCLR预训练增强特征提取)

本文介绍了将SimCLR对比学习预训练与YOLOv11目标检测模型相结合的创新方法。文章首先概述了目标检测领域的发展现状和YOLOv11的架构优化,包括主干网络、特征金字塔和检测头的改进设计。其次详细解析了SimCLR对比学习的核心原理,涵盖数据增强、投影头设计和NT-Xent损失函数。最后探讨了如何将对比学习与目标检测有效结合,通过特征空间对齐和渐进式微调策略提升模型性能。该方法显著增强了特征提取能力,提高了检测精度和训练效率,特别是在小目标和遮挡目标的检测上表现突出。

本博客聚焦 YOLOv11 全流程落地,涵盖架构优化、数据集处理、训练技巧与多场景部署,兼及国产数据库、Java 开发与 AI 模型应用,内容兼顾理论与工程实践,为开发者提供系统干货,助力高效提升技术能力。 687

一文看懂英伟达A100、A800、H100、H800各个版本有什么区别?

虽然对于这些国产AI芯片厂商来说,美国的新的AI芯片限制政策是一个利好消息,但是对于国内依赖于高性能AI芯片提供AI硬件的厂商、以及提供AI服务的互联网厂商及一些AI技术厂商来说则是一个利空,毕竟如果缺少了强大的AI芯片的支撑,那么其AI技术的发展及所能够提供的AI服务也将受到负面影响。,在目前供需失衡不正常的市场情况下,市面大部分商家是无法供应的,甚至提供不属实的信息,如果是科研服务器的话首选风虎云龙科研服务器,入围政采,品质和售后服务都有保障。,其中就包括了对于高性能计算芯片对中国大陆的出口限制。

Ai17316391579的博客 1万+

如何用 Claude Code 阅读和理解陌生代码

摘要: 在接手陌生代码时,Claude Code能显著提升理解效率。核心策略是结构化拆解而非逐行阅读: 从整体入手:先扫描目录结构、定位核心模块,建立项目地图; 聚焦关键路径:通过数据流追踪、异常逻辑分析,识别技术债与风险点; 规避常见错误:避免抽象提问或一次性提交全部代码,应分模块精准提问; 高阶应用:可生成逻辑分层图、标记高复杂度区域,甚至定制阅读顺序。 最终目标是通过结构优先的提问策略,将理解周期从数天压缩至数小时。

sg_knight的专栏 1023

CUTLASS学习之WGMMA学习笔记

英文原文:翻译文: 构建共享内存布局tile_to_shape 如果A, B是MN_major的 sA或sB: ((_64,_2),(_8,_8)):((_1,_512),(_64,_1024))的layout形状(加粗维度为图中红字维度,斜体维度为图中绿字维度) 那么sA, sB则为: ((_8,_16),(_64,_1))😦(_64,_512),(_1,_0))的layout形状为: MMA thread layout A, B矩阵thread layout tCsA,tCsB的layout

karishima的博客 2044

Parasoft C++Test软件单元测试_操作指南

本文主要为使用C++TEST进行单元测试的流程性操作讲解,后续文章将以专题形式进行详细讲解,以及用一些被测函数作为示例进行实例讲解。

文章主要涉及嵌入式软件开发、测试、项目管理等,欢迎交流,共同进步。 1580

SAP-MM-采购过账接口(与WMS集成)-代码

1、判断传入值非空检验; 2、判断过账日期是否允许在当前期间; 3、判断是否为集采订单业务,是否审批完成; 4、判断是否发布标准成本发布(此业务场景与价格控制3+S有关) 5、保存日志表; 6、判断业务公司订单审批状态; 7、创建STO交货单、集采公司订单过账、STO公司间创建交货单、交货单过账(两步法)、过账失败回滚(冲销交货、删除交货单、冲销集采入库)

qq_32198063的博客 421

为AI加速选择平台?一文读懂SXM与PCIE的真正区别

SXM与PCIe GPU的核心差异在于设计理念:PCIe作为通用标准提供灵活性和成本优势,适合中小规模计算;而SXM通过NVLink专有互联实现极致性能,专为大规模AI训练优化。关键区别体现在通信路径(直接互联vs PCIe中转)、物理形态(模块化vs插卡)、供电散热和系统集成(封闭专用vs开放兼容)。选择取决于应用场景——PCIe适合大多数通用计算需求,SXM则是大模型训练等极限场景的专业解决方案。

HPC_Evan的博客 4770

华为OD机试真题2026双机位C卷 Java&Go 实现【用户入网定期复评】

用户开立支付账户,在开户完成后立即对用户进行一次风险模型评级,输出一个评分风险,评分范围1-100,等区间的分为5个等级,1-19为等级1,20-39为等级2,40-59为等级3,60-79为等级4,80-100为等级5,系统每天会任务对全量入网用户进行计算复评时间,输出评分给出新的风险等级。复评规则如下:

MISAYAONE的博客 151

ThunderKittens入门教程:10分钟学会编写高性能CUDA内核

🚀 **ThunderKittens** 是一个让编写快速深度学习CUDA内核变得简单的框架,专为现代NVIDIA GPU优化设计。本文将带你快速掌握这个强大的工具,让你在10分钟内学会编写高性能CUDA内核! ## 什么是ThunderKittens? **ThunderKittens** 是基于三个核心原则构建的框架: 1. **简单性** - 编写极其简单 2. **可扩展性** -

gitblog_00301的博客 531

RH850从0搭建Autosar开发环境【3X】- Davinci Configurator之EcuM模块配置详解(上)

RH850从0搭建Autosar开发环境【3X】- Davinci Configurator之EcuM模块配置详解(上)

weixin_42412049的博客 1023

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

cargo-mobile2 性能优化技巧:加速构建和提升开发效率的 10 个方法

cargo-mobile2 是一款让 Rust 在移动平台开发变得简单的工具,通过优化构建流程和开发环境,可以显著提升开发效率。本文将分享 10 个实用技巧,帮助开发者加速 cargo-mobile2 项目的构建速度并优化日常开发体验。 ## 1. 配置 CARGO_TARGET_DIR 优化编译路径 通过设置 `CARGO_TARGET_DIR` 环境变量,可以自定义编译输出目录,避免默认路径

gitblog_00880的博客 749

假人有限元模型

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

ThunderKittens内核模板系统:LCSF、LCSC、LCF三大模板详解

ThunderKittens内核模板系统是专为现代GPU架构设计的高性能计算框架,通过LCSF、LCSC、LCF三大模板实现快速深度学习的CUDA内核开发。这个开源项目基于三个核心原则:简单性、可扩展性和速度,让开发者能够轻松编写出接近硬件理论极限的加速内核。🚀 ## 什么是ThunderKittens内核模板系统? ThunderKittens是一个革命性的CUDA编程框架,它从根本上改变

gitblog_07631的博客 320

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

NVIDIA A100 和 H100 硬件架构学习

WGMMA指令的引入,合并SM里面的4个tensor core 效果类似于一个大的tensor core,减少load tensor次数(A/B tensor 共用),同时支持Tcore core 的inputs 来源于share memory(A100架构及之前的架构,inputs 必须from registers),具体的WGMMA指令inputA from registers or share memory,inputB must from share memory。

qq_27763933的博客 4033

一图看透:910B、H20、A100、H100、H200性能对比!

一图看透:910B、H20、A100、H100、H200性能对比!

qq_42068614的博客 4万+

H100显卡环境对应的cuda和torch版本

原本的cuda版本是12.1,torch版本是2.0.1。新申请了几张H100的显卡,但运行程序会出现提示。卸载掉之前安装的,重新安装11.8版本的cuda。

yaogepila的博客 1万+

FlashInfer - 测试的GPU H100 SXM、A100 PCIe、RTX 6000 Ada、RTX 4090

flyfish

二分掌柜的 1932

疯狂的 H100:现代 GPU 体系结构浅析,从算力焦虑开始聊起

得益于 ChatGPT 引发的新一波 AI 浪潮,2023 年各大科技公司大量采购 NVIDIA 生产的 H100 等系列 GPU。据 NVIDIA 2024 财年第二季度财报[1],NVIDIA 收入创下纪录新高,达到 135.07 亿美元,远超分析师给出 110.4 亿美元预期。目前市场上对 H100 的需求在 43.2 万张左右,每张售价约 3.5 万美元,受限于台积电的产能,2023 年 ...

图灵教育 4194

Win11Debloat系统优化完整实操走查

每次开机都要等一堆弹窗刷完,设置页里还塞满广告,这是不少 Windows 11 用户的日常。Win11Debloat 系统优化就是为了解决这件事:一个免费开源的 PowerShell 脚本(Windows 自带命令行工具,无需安装),帮你移除预装应用、关掉遥测和广告,几分钟把电脑理干净,反悔也能回滚。 ## 🎯 为什么是它:不只是又一个"清理工具" **免费开源,没有广告位。** 市面上一堆

gitblog_00622的博客 383

ThunderKittens核心架构解析:Warp、WarpGroup、Block三级设计终极指南

ThunderKittens是一个专为现代GPU设计的高性能计算库,通过其独特的Warp、WarpGroup、Block三级架构设计,为深度学习和大规模矩阵运算提供了前所未有的计算效率。这个开源项目采用先进的Tile原语技术,在H100和Blackwell架构GPU上实现了接近理论极限的性能表现。 ## 🚀 三级并行架构设计精髓 ### Warp级别:单线程组基础运算 Warp是Thund

gitblog_00368的博客 702

WechatDataBackup多账号管理终极指南:轻松切换不同微信数据的完整教程

想要同时管理多个微信账号的沟通记录吗?WechatDataBackup作为一款专业的PC微信沟通记录导出工具,提供了强大的多账号管理功能,让您轻松切换不同微信数据。本指南将详细介绍如何利用WechatDataBackup进行多账号数据管理和切换。😊 ## 为什么需要多账号管理? 在日常生活中,很多人都会使用多个微信账号: - **工作与生活分离**:区分工作账号和个人账号 - **多客户端登

gitblog_00769的博客 584
上一篇: 深入比较:AI大模型中的LLM与多模态模型
下一篇: 一文讲清大模型AI应用架构
AI大模型_学习君
博客等级 码龄3年 6138粉丝 551原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值