在深度学习和大语言模型快速发展的今天GPU 编程已成为提升模型性能的关键技能。然而传统的 CUDA 编程门槛较高让许多开发者望而却步。NVIDIA 推出的 TileGym 库为这一问题提供了优雅的解决方案它基于 tile-based 编程范式让开发者能够更轻松地编写高效的 GPU 内核。本文将完整介绍 TileGym 的核心概念、环境搭建、内核编程实践并重点演示如何实现 Flash Attention 等高级优化技术。无论你是刚接触 GPU 编程的新手还是希望优化现有 LLM 项目的开发者都能从本文获得实用的代码示例和工程经验。1. TileGym 与 Tile-based GPU 编程基础1.1 什么是 Tile-based GPU 编程Tile-based GPU 编程是一种新的 GPU 内核开发范式它将计算任务分解为更小的瓦片tiles每个瓦片可以在 GPU 的流多处理器上独立执行。这种方法的优势在于能够更好地利用 GPU 的内存层次结构减少全局内存访问提高计算效率。与传统 CUDA 编程相比tile-based 编程抽象了线程块和线程的复杂管理让开发者更专注于算法逻辑本身。TileGym 在此基础上提供了统一的编程接口支持多种后端实现包括 cuTile、Triton CUDA Tile IR 等。1.2 TileGym 的核心价值TileGym 作为 NVIDIA 官方推出的学习平台具有以下核心价值学习友好提供丰富的内核示例和教程降低 GPU 编程学习曲线生产就绪内核经过实际 LLM 项目验证可直接用于生产环境多后端支持支持 cuTile、Triton、C 等多种编程后端性能优化内置性能基准测试帮助开发者评估和优化内核效率1.3 核心概念解析在深入代码之前需要理解几个关键概念Tile瓦片计算的基本单元类似于 CUDA 中的线程块但具有更规整的数据布局和内存访问模式。TileIRTile 中间表示是描述 tile-based 计算的中间语言支持多种前端和后端。cuTile基于 Python 的 tile 编程前端语法简洁适合快速原型开发。Triton Tile IR将 Triton 编译器与 TileIR 结合提供更强大的优化能力。2. 环境准备与安装配置2.1 硬件与软件要求TileGym 对运行环境有特定要求以下是官方推荐配置GPU 要求首选NVIDIA Blackwell 架构 GPUB200、RTX 5080、RTX 5090兼容NVIDIA Ampere 架构 GPUA100需 CUDA 13.2软件要求CUDA 13.1 或更高版本必须PyTorch 2.9.1 或兼容版本Python 3.82.2 基础环境搭建首先确保系统中已安装正确版本的 CUDA# 检查 CUDA 版本 nvcc --version # 输出应显示 CUDA 13.1 或更高版本 # nvcc: NVIDIA (R) Cuda compiler driver # Copyright (c) 2005-2024 NVIDIA Corporation # Built on Mon_Jan__8_18:30:25_PST_2024 # Cuda compilation tools, release 13.1, V13.1.105如果 CUDA 版本不符合要求需要从 NVIDIA 官网下载并安装正确版本。2.3 安装 PyTorch 和 TritonTileGym 依赖特定版本的 PyTorch 和 Triton# 安装预发布版本的 PyTorch包含 Triton pip install --pre torch --index-url https://download.pytorch.org/whl/cu130 # 验证安装 python -c import torch; print(fPyTorch版本: {torch.__version__}) python -c import triton; print(Triton 安装成功)2.4 安装 TileGym推荐使用 PyPI 安装这是最简单的方式# 完整安装包含 tileiras 编译器 pip install tilegym[tileiras] # 或者如果系统已安装 tileiras 编译器 pip install tilegym如果需要从源码安装用于开发或定制git clone https://github.com/NVIDIA/TileGym.git cd TileGym pip install .[tileiras] # 开发模式可使用 pip install -e .[tileiras]2.5 验证安装创建验证脚本来检查安装是否成功# verify_installation.py import torch import tilegym print(PyTorch版本:, torch.__version__) print(CUDA可用:, torch.cuda.is_available()) print(GPU数量:, torch.cuda.device_count()) if torch.cuda.is_available(): print(当前GPU:, torch.cuda.get_device_name(0)) print(CUDA版本:, torch.version.cuda) # 测试基础导入 from tilegym.ops import matmul print(TileGym 基础操作导入成功) # 检查可用后端 from tilegym.backend.selector import get_available_backends print(可用后端:, get_available_backends())运行验证脚本python verify_installation.py3. cuTile 基础编程实战3.1 第一个 cuTile 程序向量加法让我们从最简单的向量加法开始了解 cuTile 的基本编程模式# vector_add.py import torch import cutile as ct from cutile import tile, program, cast, static tile def vector_add(A: ct.Tensor, B: ct.Tensor, C: ct.Tensor): # 获取全局索引 i ct.get_global_id(0) # 边界检查 if i A.shape[0]: C[i] A[i] B[i] def main(): # 设置张量大小 size 1024 # 创建输入张量 A torch.randn(size, devicecuda) B torch.randn(size, devicecuda) C torch.zeros(size, devicecuda) # 编译并运行内核 kernel program(vector_add, grid(size,), block(256,)) kernel(A, B, C) # 验证结果 expected A B print(结果正确:, torch.allclose(C, expected, atol1e-6)) # 性能测试 import time start time.time() for _ in range(1000): kernel(A, B, C) torch.cuda.synchronize() end time.time() print(f平均执行时间: {(end - start) * 1000 / 1000:.3f} ms) if __name__ __main__: main()3.2 矩阵乘法实现矩阵乘法是深度学习中最常见的操作之一下面是使用 cuTile 的实现# matrix_multiply.py import torch import cutile as ct from cutile import tile, program tile def matrix_multiply(A: ct.Tensor, B: ct.Tensor, C: ct.Tensor, M: int, N: int, K: int): # 瓦片大小 TILE_SIZE 32 # 获取瓦片坐标 tile_i ct.get_group_id(0) tile_j ct.get_group_id(1) # 获取瓦片内的局部坐标 local_i ct.get_local_id(0) local_j ct.get_local_id(1) # 计算全局索引 i tile_i * TILE_SIZE local_i j tile_j * TILE_SIZE local_j # 边界检查 if i M and j N: # 累加变量 acc 0.0 # 分块计算 for k in range(0, K, TILE_SIZE): # 边界检查 if k local_j K and i M: a_val A[i, k local_j] if (k local_j) K else 0.0 else: a_val 0.0 if k local_i K and j N: b_val B[k local_i, j] if (k local_i) K else 0.0 else: b_val 0.0 acc a_val * b_val C[i, j] acc def main(): # 矩阵维度 M, N, K 512, 512, 512 # 创建随机矩阵 A torch.randn(M, K, devicecuda) B torch.randn(K, N, devicecuda) C torch.zeros(M, N, devicecuda) # 计算网格和块大小 block_size (32, 32) grid_size ((M 31) // 32, (N 31) // 32) # 编译内核 kernel program(matrix_multiply, gridgrid_size, blockblock_size) # 运行内核 kernel(A, B, C, M, N, K) # 验证结果 expected torch.matmul(A, B) error torch.abs(C - expected).max() print(f最大误差: {error.item()}) print(结果正确:, torch.allclose(C, expected, atol1e-4)) if __name__ __main__: main()3.3 内存优化技巧在 tile-based 编程中内存访问模式对性能至关重要# optimized_matrix_multiply.py import torch import cutile as ct from cutile import tile, program, shared tile def optimized_matrix_multiply(A: ct.Tensor, B: ct.Tensor, C: ct.Tensor, M: int, N: int, K: int): TILE_SIZE 32 # 共享内存声明 A_shared shared((TILE_SIZE, TILE_SIZE), dtypeA.dtype) B_shared shared((TILE_SIZE, TILE_SIZE), dtypeB.dtype) tile_i ct.get_group_id(0) tile_j ct.get_group_id(1) local_i ct.get_local_id(0) local_j ct.get_local_id(1) i tile_i * TILE_SIZE local_i j tile_j * TILE_SIZE local_j acc 0.0 # 分块循环 for k_tile in range(0, K, TILE_SIZE): # 协作加载数据到共享内存 if i M and (k_tile local_j) K: A_shared[local_i, local_j] A[i, k_tile local_j] else: A_shared[local_i, local_j] 0.0 if (k_tile local_i) K and j N: B_shared[local_i, local_j] B[k_tile local_i, j] else: B_shared[local_i, local_j] 0.0 # 等待所有线程完成数据加载 ct.sync() # 计算当前瓦片 for k in range(TILE_SIZE): acc A_shared[local_i, k] * B_shared[k, local_j] # 等待所有线程完成计算 ct.sync() # 写入结果 if i M and j N: C[i, j] acc def benchmark_optimized(): M, N, K 1024, 1024, 1024 A torch.randn(M, K, devicecuda) B torch.randn(K, N, devicecuda) C torch.zeros(M, N, devicecuda) block_size (32, 32) grid_size ((M 31) // 32, (N 31) // 32) kernel program(optimized_matrix_multiply, gridgrid_size, blockblock_size) # 预热 for _ in range(10): kernel(A, B, C, M, N, K) # 性能测试 start torch.cuda.Event(enable_timingTrue) end torch.cuda.Event(enable_timingTrue) start.record() for _ in range(100): kernel(A, B, C, M, N, K) end.record() torch.cuda.synchronize() elapsed start.elapsed_time(end) / 100 print(f优化版本平均执行时间: {elapsed:.3f} ms) if __name__ __main__: benchmark_optimized()4. Triton 后端集成与优化4.1 Triton 与 TileIR 结合Triton 后端提供了另一种高效的编程方式特别适合复杂的张量操作# triton_tile_example.py import torch import triton import triton.language as tl triton.jit def triton_vector_add( A_ptr, B_ptr, C_ptr, n_elements, BLOCK_SIZE: tl.constexpr, ): # 获取程序ID pid tl.program_id(axis0) # 创建范围 block_start pid * BLOCK_SIZE offsets block_start tl.arange(0, BLOCK_SIZE) # 掩码防止越界 mask offsets n_elements # 加载数据 a tl.load(A_ptr offsets, maskmask) b tl.load(B_ptr offsets, maskmask) # 计算 c a b # 存储结果 tl.store(C_ptr offsets, c, maskmask) def run_triton_example(): size 1024 A torch.randn(size, devicecuda) B torch.randn(size, devicecuda) C torch.zeros(size, devicecuda) # 计算网格大小 grid lambda meta: (triton.cdiv(size, meta[BLOCK_SIZE]),) # 启动内核 triton_vector_add[grid](A, B, C, size, BLOCK_SIZE256) # 验证 expected A B print(Triton 结果正确:, torch.allclose(C, expected)) # 启用 TileIR 后端 import os os.environ[ENABLE_TILE] 1 if __name__ __main__: run_triton_example()4.2 性能对比测试比较不同后端的性能表现# performance_comparison.py import torch import time import cutile as ct from cutile import tile, program import triton import triton.language as tl def benchmark_pytorch(A, B): PyTorch 原生实现基准 start torch.cuda.Event(enable_timingTrue) end torch.cuda.Event(enable_timingTrue) start.record() C torch.matmul(A, B) end.record() torch.cuda.synchronize() return start.elapsed_time(end), C triton.jit def triton_matmul( A_ptr, B_ptr, C_ptr, M, N, K, stride_am, stride_ak, stride_bk, stride_bn, stride_cm, stride_cn, BLOCK_SIZE_M: tl.constexpr, BLOCK_SIZE_N: tl.constexpr, BLOCK_SIZE_K: tl.constexpr, ): # Triton 矩阵乘法实现 pid_m tl.program_id(0) pid_n tl.program_id(1) # 省略具体实现细节... pass def benchmark_all(): M, N, K 2048, 2048, 2048 # 创建测试数据 A torch.randn(M, K, devicecuda, dtypetorch.float16) B torch.randn(K, N, devicecuda, dtypetorch.float16) print(f测试矩阵大小: {M}x{K} * {K}x{N}) # PyTorch 基准 time_torch, result_torch benchmark_pytorch(A, B) print(fPyTorch 执行时间: {time_torch:.3f} ms) # cuTile 基准需要实现对应的内核 # time_cutile benchmark_cutile(A, B) # print(fcuTile 执行时间: {time_cutile:.3f} ms) # Triton 基准 # time_triton benchmark_triton(A, B) # print(fTriton 执行时间: {time_triton:.3f} ms) if __name__ __main__: benchmark_all()5. Flash Attention 实现详解5.1 Flash Attention 原理Flash Attention 是一种高效的自注意力实现通过优化内存访问模式来减少 HBM 访问次数。其核心思想是将计算分解为多个块在 SRAM 中完成大部分计算。5.2 cuTile 实现 Flash Attention下面是使用 cuTile 实现简化版的 Flash Attention# flash_attention_cutile.py import torch import cutile as ct from cutile import tile, program, shared import math tile def flash_attention_forward( Q: ct.Tensor, # [batch, heads, seq_len, dim] K: ct.Tensor, # [batch, heads, seq_len, dim] V: ct.Tensor, # [batch, heads, seq_len, dim] O: ct.Tensor, # 输出 [batch, heads, seq_len, dim] l: ct.Tensor, # 对数求和 [batch, heads, seq_len] m: ct.Tensor, # 最大值 [batch, heads, seq_len] batch_size: int, num_heads: int, seq_len: int, dim: int, BLOCK_SIZE: int ): # 获取索引 batch ct.get_group_id(0) head ct.get_group_id(1) block_i ct.get_group_id(2) local_i ct.get_local_id(0) local_j ct.get_local_id(1) # 共享内存声明 Q_shared shared((BLOCK_SIZE, dim), dtypeQ.dtype) K_shared shared((BLOCK_SIZE, dim), dtypeK.dtype) V_shared shared((BLOCK_SIZE, dim), dtypeV.dtype) # 初始化局部统计量 local_m -float(inf) local_l 0.0 local_o ct.local_array(dim, dtypeO.dtype) # 分块处理 for block_j in range(0, (seq_len BLOCK_SIZE - 1) // BLOCK_SIZE): # 加载 K, V 块到共享内存 # 实现细节... pass # 计算注意力分数 # 实现细节... pass # 更新局部统计量 # 实现细节... pass # 写入最终结果 # 实现细节... pass class FlashAttention: def __init__(self, dim, heads8, block_size64): self.dim dim self.heads heads self.block_size block_size self.kernel program( flash_attention_forward, gridlambda meta: (meta[batch_size], meta[num_heads], (meta[seq_len] meta[BLOCK_SIZE] - 1) // meta[BLOCK_SIZE]), block(block_size, 1) ) def forward(self, Q, K, V): batch_size, seq_len, _ Q.shape # 初始化输出和中间变量 O torch.zeros_like(Q) l torch.zeros(batch_size, self.heads, seq_len, deviceQ.device) m torch.full((batch_size, self.heads, seq_len), -float(inf), deviceQ.device) # 调用内核 self.kernel(Q, K, V, O, l, m, batch_size, self.heads, seq_len, self.dim, self.block_size) return O def test_flash_attention(): batch_size, seq_len, dim, heads 2, 512, 64, 8 # 创建测试数据 Q torch.randn(batch_size, seq_len, dim, devicecuda) K torch.randn(batch_size, seq_len, dim, devicecuda) V torch.randn(batch_size, seq_len, dim, devicecuda) # 标准注意力实现用于验证 def standard_attention(Q, K, V): scores torch.matmul(Q, K.transpose(-2, -1)) / (dim ** 0.5) attn torch.softmax(scores, dim-1) return torch.matmul(attn, V) # 标准实现 expected standard_attention( Q.view(batch_size, seq_len, heads, dim // heads).transpose(1, 2), K.view(batch_size, seq_len, heads, dim // heads).transpose(1, 2), V.view(batch_size, seq_len, heads, dim // heads).transpose(1, 2) ).transpose(1, 2).contiguous().view(batch_size, seq_len, dim) print(Flash Attention 测试完成) if __name__ __main__: test_flash_attention()6. 性能优化与调试技巧6.1 性能分析工具使用 NVIDIA Nsight Systems 进行性能分析# 安装 Nsight Systems # 下载并从 NVIDIA 开发者网站安装 # 分析 Python 程序 nsys profile --statstrue python your_script.py # 生成详细报告 nsys profile -o report.qdrep python your_script.py nsys stats report.qdrep6.2 内存访问优化优化内存访问模式的实用技巧# memory_optimization.py import cutile as ct from cutile import tile, program, shared tile def optimized_kernel(A: ct.Tensor, B: ct.Tensor, C: ct.Tensor): # 技巧1: 使用共享内存减少全局内存访问 shared_mem shared((32, 32), dtypeA.dtype) # 技巧2: 合并内存访问 # 确保相邻线程访问相邻内存地址 i ct.get_global_id(0) j ct.get_global_id(1) # 技巧3: 使用向量化加载 # 一次加载多个数据元素 # 技巧4: 避免 bank conflict # 通过调整访问模式避免共享内存 bank conflict def check_memory_access_pattern(): 检查内存访问模式 import torch from cutile import analyze_memory_access # 分析内核的内存访问模式 kernel_info analyze_memory_access(optimized_kernel) print(内存访问分析:, kernel_info) # 性能计数器监控 def monitor_performance_counters(): 监控 GPU 性能计数器 import pynvml pynvml.nvmlInit() handle pynvml.nvmlDeviceGetHandleByIndex(0) # 获取内存使用情况 info pynvml.nvmlDeviceGetMemoryInfo(handle) print(fGPU 内存使用: {info.used / 1024**2:.1f} MB / {info.total / 1024**2:.1f} MB) # 获取利用率 utilization pynvml.nvmlDeviceGetUtilizationRates(handle) print(fGPU 利用率: {utilization.gpu}%) print(f内存利用率: {utilization.memory}%)6.3 自动性能调优使用 TileGym 内置的自动调优功能# auto_tuning.py from tilegym.autotune import AutoTuner import tilegym.ops as ops def auto_tune_matmul(): 自动调优矩阵乘法 tuner AutoTuner( op_classops.Matmul, input_shapes[(1024, 1024), (1024, 1024)], dtypefloat16 ) # 搜索最佳配置 best_config tuner.tune( max_trials100, metricthroughput, # 优化目标吞吐量 constraints{max_shared_memory: 49152} # 共享内存限制 ) print(最佳配置:, best_config) return best_config def benchmark_autotuned(): 测试自动调优结果 best_config auto_tune_matmul() # 使用最佳配置创建操作 matmul_op ops.Matmul(configbest_config) # 性能测试 A torch.randn(1024, 1024, devicecuda, dtypetorch.float16) B torch.randn(1024, 1024, devicecuda, dtypetorch.float16) start torch.cuda.Event(enable_timingTrue) end torch.cuda.Event(enable_timingTrue) start.record() for _ in range(100): C matmul_op(A, B) end.record() torch.cuda.synchronize() elapsed start.elapsed_time(end) / 100 print(f自动调优后执行时间: {elapsed:.3f} ms)7. 实际项目集成示例7.1 与 Transformer 模型集成将 TileGym 内核集成到实际的 Transformer 模型中# transformer_integration.py import torch import torch.nn as nn from tilegym.ops import attention, matmul class TileGymAttention(nn.Module): 使用 TileGym 优化的注意力层 def __init__(self, dim, heads8): super().__init__() self.heads heads self.dim dim self.head_dim dim // heads # 使用 TileGym 优化后的操作 self.attention_op attention.AttentionOp() self.matmul_op matmul.Matmul() def forward(self, Q, K, V, maskNone): batch_size, seq_len, _ Q.shape # 重塑为多头格式 Q Q.view(batch_size, seq_len, self.heads, self.head_dim).transpose(1, 2) K K.view(batch_size, seq_len, self.heads, self.head_dim).transpose(1, 2) V V.view(batch_size, seq_len, self.heads, self.head_dim).transpose(1, 2) # 使用优化后的注意力计算 if mask is not None: output self.attention_op(Q, K, V, mask) else: output self.attention_op(Q, K, V) # 重塑回原始格式 output output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.dim) return output class OptimizedTransformerLayer(nn.Module): 优化的 Transformer 层 def __init__(self, dim, heads, mlp_ratio4): super().__init__() self.dim dim self.heads heads self.attention TileGymAttention(dim, heads) self.norm1 nn.LayerNorm(dim) self.norm2 nn.LayerNorm(dim) # MLP 层也使用优化后的矩阵乘法 mlp_dim dim * mlp_ratio self.mlp nn.Sequential( nn.Linear(dim, mlp_dim), nn.GELU(), nn.Linear(mlp_dim, dim) ) def forward(self, x, maskNone): # 注意力子层 attn_output self.attention(self.norm1(x), self.norm1(x), self.norm1(x), mask) x x attn_output # MLP 子层 mlp_output self.mlp(self.norm2(x)) x x mlp_output return x def benchmark_transformer_layer(): 性能对比测试 dim, heads, seq_len, batch_size 512, 8, 1024, 2 # 创建测试数据 x torch.randn(batch_size, seq_len, dim, devicecuda) # 标准 Transformer 层 standard_layer nn.TransformerEncoderLayer( d_modeldim, nheadheads, dim_feedforwarddim*4, batch_firstTrue ).cuda() # 优化后的层 optimized_layer OptimizedTransformerLayer(dim, heads).cuda() # 性能测试 def benchmark_layer(layer, x, name): torch.cuda.synchronize() start torch.cuda.Event(enable_timingTrue) end torch.cuda.Event(enable_timingTrue) # 预热 for _ in range(10): _ layer(x) start.record() for _ in range(100): _ layer(x) end.record() torch.cuda.synchronize() elapsed start.elapsed_time(end) / 100 print(f{name} 平均执行时间: {elapsed:.3f} ms) return elapsed time_standard benchmark_layer(standard_layer, x, 标准 Transformer) time_optimized benchmark_layer(optimized_layer, x, 优化 Transformer) speedup time_standard / time_optimized print(f性能提升: {speedup:.2f}x)8. 常见问题与解决方案8.1 安装与环境问题问题1: ModuleNotFoundError: No module named triton解决方案# 确保安装了正确版本的 PyTorch pip install --pre torch --index-url https://download.pytorch.org/whl/cu130 # 或者单独安装 Triton pip install triton问题2: CUDA 版本不兼容解决方案# 检查 CUDA 版本 nvcc --version # 如果版本过低升级 CUDA 工具包 # 从 NVIDIA 官网下载 CUDA 13.1 版本问题3: 显卡架构不支持解决方案# 检查显卡计算能力 nvidia-smi --query-gpucompute_cap --formatcsv # 如果计算能力低于 8.0考虑升级硬件或使用云 GPU 服务8.2 编程与运行时问题问题4: 内核编译失败常见原因和解决方案# 调试内核编译 try: kernel program(your_kernel, gridgrid_size, blockblock_size) except Exception as e: print(f编译错误: {e}) # 检查张量形状和设备一致性 print(张量设备:, A.device, B.device) print(张量形状:, A.shape, B.shape)问题5: 性能不如预期优化检查清单内存访问模式确保合并访问共享内存使用避免 bank conflict计算强度平衡计算和内存访问块大小选择根据硬件特性调整8.3 高级调试技巧使用 TileGym 的调试工具# debugging_tools.py from tilegym.debug import KernelDebugger def debug_kernel(): 内核调试示例 debugger KernelDebugger() # 启用详细日志 debugger.set_log_level(DEBUG) # 分析内核性能 kernel_info debugger.analyze_kernel(your_kernel) print(内核分析报告:, kernel_info) # 检查内存访问模式 access_pattern debugger.check_memory_access(your_kernel) print(内存访问模式:, access_pattern) # 生成优化建议 suggestions debugger.get_optimization_suggestions(your_kernel) print(优化建议:, suggestions)9. 最佳实践与工程建议9.1 代码组织规范项目结构建议project/ ├── kernels/ # 自定义内核 │ ├── attention/ # 注意力相关内核 │ ├── matmul/ # 矩阵运算内核 │ └── utils/ # 工具函数 ├── models/ # 模型定义 ├── benchmarks/ # 性能测试 ├── tests/ # 单元测试 └── requirements.txt # 依赖管理内核开发规范# kernel_template.py 内核模块文档字符串 描述功能、输入输出、性能特性 import cutile as ct from cutile import tile, program, shared tile def well_documented_kernel( input_tensor: ct.Tensor, output_tensor: ct.Tensor, param1: int, param2: float ): 内核函数文档 Args: input_tensor: 输入张量描述 output_tensor: 输出张量描述 param1: 参数1描述 param2: 参数2描述 # 清晰的代码结构 # 适当的注释 # 边界检查 # 错误处理9.2 性能优化策略层次化优化方法算法级优化选择最适合的算法实现级优化优化内存访问模式架构级优化利用硬件特性系统级优化减少系统开销性能监控指标计算吞吐量 (TFLOPS)内存带宽利用率内核执行时间资源使用率9.3 生产环境部署容器化部署# Dockerfile FROM nvidia/cuda:13.1-devel-ubuntu20.04 # 安装系统依赖 RUN apt-get update apt-get install -y \ python3.10 \ python3-pip \ rm -rf /var/lib/apt/lists/* # 安装 Python 依赖 COPY requirements.txt . RUN pip install -r requirements.txt # 安装 TileGym RUN pip install tilegym[tileiras] # 复制应用代码 COPY . /app WORKDIR /app CMD [python, main.py