CUDA新手必看：从零开始用NVIDIA GPU加速你的Python代码（附性能对比测试）

如果你是一名Python开发者，最近在处理一些数据量稍大的矩阵运算，或者尝试训练一个不算太复杂的机器学习模型，是否感觉程序运行得有点慢，CPU风扇开始呼呼作响？你或许已经听说过GPU加速，知道NVIDIA的CUDA技术很强大，但一想到要学习C++、理解复杂的线程模型和内存管理，就觉得门槛太高，望而却步。别担心，今天的Python生态已经为我们铺平了道路。我们完全不必从零开始学习底层的CUDA C编程，就能让我们的Python代码在GPU上飞起来。

这篇文章就是为你准备的。我们将彻底抛开那些厚重的教科书式讲解，聚焦于实战。我会带你用几种当下最流行、对Python开发者最友好的工具——主要是Numba和CuPy，将你现有的NumPy/Pandas代码，几乎无痛地迁移到GPU上执行。整个过程，你会感觉就像在调用一个更快的“NumPy”一样自然。更重要的是，我会通过几个具体的案例，手把手展示迁移步骤，并给出在不同数据规模下的真实性能对比数据。你会清晰地看到，在什么情况下GPU加速能带来十倍、百倍的提升，而在什么情况下可能“杀鸡用牛刀”。我们的目标不是成为CUDA专家，而是成为一个能高效利用手头GPU硬件，快速解决实际计算瓶颈的Python实战派。

1. 环境准备：搭建你的Python GPU加速工作台

在开始编写任何加速代码之前，一个正确且高效的环境是基石。很多人在这里踩坑，不是因为工具复杂，而是因为版本兼容性问题。我们力求一次搞定。

1.1 核心组件安装与验证

首先，你需要一块NVIDIA GPU。打开终端，输入 nvidia-smi 命令。如果你能看到GPU型号、驱动版本等信息，那么恭喜，硬件和基础驱动已经就位。请特别留意显示的 CUDA Version，例如 12.4，这决定了你后续安装的软件版本。

接下来是Python环境。我强烈建议使用 Conda 来管理环境，它能优雅地处理CUDA相关库的依赖。创建一个新的环境：

conda create -n gpu_accel python=3.10
conda activate gpu_accel

现在，安装核心的GPU计算库。我们将同时安装 Numba 和 CuPy，以便后续对比使用。这里的关键是版本必须与你的CUDA版本匹配。以CUDA 12.x为例：

# 安装Numba及其CUDA支持
conda install numba
conda install cudatoolkit=12  # 这将安装对应版本的CUDA运行时库

# 安装CuPy，指定CUDA版本和渠道
pip install cupy-cuda12x

注意：cupy-cuda12x 中的 12x 是一个通配符，代表CUDA 12系列。请务必根据你的 nvidia-smi 显示的CUDA主版本号（如11.x或12.x）选择正确的包，例如 cupy-cuda11x 或 cupy-cuda12x。安装错误版本将导致无法运行。

安装完成后，让我们写一个简单的验证脚本 verify_gpu.py：

import numba.cuda as cuda
import cupy as cp

print("=== Numba CUDA 验证 ===")
print(f"检测到GPU设备数量: {cuda.detect()}")
if cuda.detect():
    print(f"当前设备: {cuda.get_current_device().name.decode()}")

print("\n=== CuPy 验证 ===")
print(f"CuPy 使用的CUDA版本: {cp.cuda.runtime.runtimeGetVersion()}")
print(f"CuPy 可用设备: {cp.cuda.runtime.getDeviceCount()}")
with cp.cuda.Device(0):
    print(f"设备0名称: {cp.cuda.Device(0).name}")

# 一个简单的计算测试
print("\n=== 简单计算测试 ===")
import numpy as np
x_np = np.random.rand(10000).astype(np.float32)
x_cp = cp.asarray(x_np)  # 将NumPy数组转移到GPU

# 在GPU上计算平方和
result_gpu = cp.sum(x_cp ** 2)
# 在CPU上计算平方和
result_cpu = np.sum(x_np ** 2)

print(f"CPU计算结果: {result_cpu}")
print(f"GPU计算结果: {result_gpu.get()}")  # .get()将数据取回CPU
print(f"结果是否一致: {np.allclose(result_cpu, result_gpu.get())}")

运行这个脚本，如果一切顺利，你将看到GPU信息被正确识别，并且计算结果一致。这表明你的Python GPU加速工作台已经准备就绪。

1.2 工具链简介：Numba vs CuPy vs PyTorch/TensorFlow

面对众多选择，我们为何聚焦Numba和CuPy？下表为你厘清它们的特点和适用场景：

工具 核心特点 最佳适用场景 学习曲线
Numba 装饰器驱动，通过 @cuda.jit 或 @vectorize 将Python函数编译为GPU核函数。灵活性极高，可自定义底层并行逻辑。 加速自定义的、循环密集的数值计算函数。适合将已有Python函数“点石成金”。 中等，需要理解线程网格等概念。
CuPy NumPy兼容，提供与NumPy几乎一致的API。调用CuPy函数即自动在GPU上执行。易用性最佳。 替代NumPy进行数组操作（如线性代数、傅里叶变换）。适合已有NumPy代码的直接迁移。 极低，NumPy用户零成本上手。
PyTorch/TensorFlow 深度学习框架，内置强大的GPU张量计算和自动微分。生态庞大。 机器学习、深度学习模型训练与推理。其张量操作也可用于通用计算，但不如前两者纯粹。 较高，需学习框架自身概念。

对于本文的目标——快速上手并加速通用Python数值计算，Numba和CuPy的组合提供了从“简单替换”到“深度定制”的完整光谱。PyTorch等框架更适合其主攻的AI领域。

2. 初试锋芒：用CuPy实现NumPy代码的无缝迁移

让我们从一个最直观的场景开始：你有一段使用NumPy进行矩阵运算的代码，现在想让它跑在GPU上。用CuPy，这可能是最简单的加速方式。

2.1 基础替换：从 import numpy as np 到 import cupy as cp

假设我们有一个计算欧氏距离矩阵的函数，这是机器学习中常见的操作。CPU版本如下：

import numpy as np
import time

def euclidean_dist_matrix_cpu(X):
    """计算输入矩阵X中所有行向量之间的欧氏距离矩阵 (CPU版本)"""
    m = X.shape[0]
    dist_matrix = np.zeros((m, m))
    for i in range(m):
        # 利用广播，一次性计算第i行与所有行的差
        diff = X[i, :] - X  # 形状 (m, n)
        dist_matrix[i, :] = np.sqrt(np.sum(diff ** 2, axis=1))
    return dist_matrix

# 生成测试数据
np.random.seed(42)
data_cpu = np.random.randn(5000, 100).astype(np.float32)  # 5000个100维向量

start = time.time()
dist_cpu = euclidean_dist_matrix_cpu(data_cpu)
cpu_time = time.time() - start
print(f"NumPy CPU 计算耗时: {cpu_time:.4f} 秒")

这个双重循环版本效率很低。用NumPy优化后，我们可以利用矩阵运算消除循环，但计算量依然很大。现在，我们将其迁移到CuPy。90%的工作就是替换导入和数组创建函数：

import cupy as cp
import time

def euclidean_dist_matrix_gpu_cupy(X):
    """计算输入矩阵X中所有行向量之间的欧氏距离矩阵 (CuPy GPU版本)"""
    m = X.shape[0]
    # 关键：使用 cp.zeros, cp.sum, cp.sqrt
    dist_matrix = cp.zeros((m, m), dtype=cp.float32)
    for i in range(m):
        diff = X[i, :] - X  # 这里的X是CuPy数组，运算在GPU上
        dist_matrix[i, :] = cp.sqrt(cp.sum(diff ** 2, axis=1))
    return dist_matrix

# 将NumPy数据转移到GPU显存
data_gpu = cp.asarray(data_cpu)

# 预热：第一次运行可能包含编译开销
_ = euclidean_dist_matrix_gpu_cupy(data_gpu)

start = time.time()
dist_gpu = euclidean_dist_matrix_gpu_cupy(data_gpu)
gpu_time = time.time() - start
print(f"CuPy GPU 计算耗时: {gpu_time:.4f} 秒")

# 验证结果一致性
dist_gpu_cpu = cp.asnumpy(dist_gpu)  # 将结果取回CPU
print(f"CPU/GPU结果最大差异: {np.max(np.abs(dist_cpu - dist_gpu_cpu)):.6f}")

你会发现，除了将 np 替换为 cp，代码结构一模一样。这就是CuPy的魅力。但请注意，这个例子依然使用了Python循环 for i in range(m)，循环体在GPU上执行，但循环控制本身在CPU上，对于大型矩阵，这仍可能成为瓶颈。真正的CuPy威力在于完全向量化。

2.2 向量化威力：消除循环，释放GPU潜能

利用数学公式和CuPy的广播机制，我们可以将欧氏距离矩阵的计算完全向量化，彻底消除循环：

def euclidean_dist_matrix_gpu_vectorized(X):
    """完全向量化的欧氏距离矩阵计算 (GPU版本)"""
    # 公式: dist(i,j) = sqrt(||Xi||^2 + ||Xj||^2 - 2 * Xi·Xj)
    # 计算每行向量的平方和 (m,)
    row_norms = cp.sum(X ** 2, axis=1, keepdims=True)  # 形状 (m, 1)
    # 计算点积矩阵
    dot_product = X @ X.T  # 形状 (m, m)
    # 利用广播计算距离矩阵
    # row_norms + row_norms.T 会广播为 (m,m)
    dist_matrix = cp.sqrt(row_norms + row_norms.T - 2 * dot_product)
    # 防止数值误差导致负数开方
    cp.maximum(dist_matrix, 0, out=dist_matrix)
    return dist_matrix

# 预热
_ = euclidean_dist_matrix_gpu_vectorized(data_gpu)

start = time.time()
dist_gpu_vec = euclidean_dist_matrix_gpu_vectorized(data_gpu)
gpu_vec_time = time.time() - start
print(f"CuPy GPU 向量化计算耗时: {gpu_vec_time:.4f} 秒")

# 性能对比
print(f"\n性能对比 (数据形状: {data_cpu.shape})：")
print(f"  NumPy CPU 循环版本: {cpu_time:.4f}s")
print(f"  CuPy GPU 循环版本: {gpu_time:.4f}s")
print(f"  CuPy GPU 向量化版本: {gpu_vec_time:.4f}s")
print(f"  向量化 vs CPU循环加速比: {cpu_time / gpu_vec_time:.2f}x")

运行这段代码，你会看到向量化版本相比GPU循环版本又有巨大提升。这正是GPU计算的精髓：将大量重复、规则的计算任务打包，通过成千上万个线程并行执行。CuPy的向量化操作底层就是调用了高度优化的CUDA核函数。

3. 深入定制：使用Numba编写高性能GPU核函数

当你的计算逻辑非常独特，无法用CuPy现有的向量化操作完美表达时，或者你需要对内存访问、线程调度进行极致优化时，Numba的 @cuda.jit 装饰器就派上用场了。它允许你以Python语法编写在GPU上执行的“核函数”。

3.1 第一个Numba CUDA核函数：向量加法

让我们从经典的向量加法开始。在CPU上，这是一个简单的循环：

def vector_add_cpu(a, b, c):
    for i in range(len(c)):
        c[i] = a[i] + b[i]

在Numba CUDA中，我们需要以数据并行的思维重新构思。我们将创建与输出数组元素数量一样多的线程，每个线程只负责计算一个加法。

from numba import cuda
import numpy as np
import math

@cuda.jit
def vector_add_gpu(a, b, c):
    """
    GPU核函数：计算 c = a + b。
    每个线程处理一个索引位置。
    """
    # 计算当前线程的全局索引
    idx = cuda.grid(1)  # 1维网格
    # 检查索引是否在数组范围内
    if idx < c.size:
        c[idx] = a[idx] + b[idx]

# 准备数据
n = 10_000_000
a_cpu = np.random.randn(n).astype(np.float32)
b_cpu = np.random.randn(n).astype(np.float32)
c_cpu = np.empty_like(a_cpu)

# 将数据复制到GPU设备
a_gpu = cuda.to_device(a_cpu)
b_gpu = cuda.to_device(b_cpu)
c_gpu = cuda.device_array_like(a_gpu)  # 在GPU上分配空数组

# 配置线程网格
# threads_per_block: 每个线程块的线程数，通常是32的倍数，如128, 256, 512
# blocks_per_grid: 网格中的线程块数量，需要足够覆盖所有数据
threads_per_block = 256
blocks_per_grid = math.ceil(n / threads_per_block)

print(f"启动核函数: {blocks_per_grid} 个块 x {threads_per_block} 个线程/块")

# 执行核函数
vector_add_gpu[blocks_per_grid, threads_per_block](a_gpu, b_gpu, c_gpu)

# 等待所有线程完成
cuda.synchronize()

# 将结果复制回主机
c_result = c_gpu.copy_to_host()

# 验证
expected = a_cpu + b_cpu
print(f"结果是否正确: {np.allclose(c_result, expected, rtol=1e-5)}")

理解这段代码的关键是 cuda.grid(1) 和 [blocks_per_grid, threads_per_block] 的配置。

  • 线程(Thread)：最基本的执行单元。
  • 线程块(Block)：一组线程，共享一块快速的共享内存，可以同步。
  • 网格(Grid)：由多个线程块组成。

核函数启动时，我们指定一个由 blocks_per_grid 个块组成的网格，每个块有 threads_per_block 个线程。在核函数内部，cuda.grid(1) 为每个线程计算出一个唯一的全局索引 idx。这样，上千万个加法操作就被分配给上千万个线程同时执行。

3.2 实战案例：使用共享内存优化矩阵转置

矩阵转置是一个内存访问模式不连续的操作，在GPU上容易遇到性能瓶颈。使用共享内存可以显著优化。共享内存是GPU上每个线程块内部的高速缓存，访问延迟比全局显存低得多。

思路是：让一个线程块协作加载全局显存中的一个数据块到共享内存，然后在共享内存中进行转置操作，最后再写回全局显存。这样可以实现合并访问（高效读取）和合并写入（高效写入）。

@cuda.jit
def transpose_shared_memory(A, B):
    """
    使用共享内存优化矩阵转置。
    A是输入矩阵 (M, N)， B是输出转置矩阵 (N, M)。
    """
    # 为当前线程块声明一块共享内存
    # 大小是 (BLOCK_SIZE, BLOCK_SIZE+1)，+1是为了避免共享内存bank冲突
    BLOCK_SIZE = 32
    tile = cuda.shared.array((BLOCK_SIZE, BLOCK_SIZE + 1), dtype=A.dtype)

    # 计算当前线程在数据块中的位置
    x = cuda.blockIdx.x * BLOCK_SIZE + cuda.threadIdx.x
    y = cuda.blockIdx.y * BLOCK_SIZE + cuda.threadIdx.y

    # 检查边界
    if x < A.shape[1] and y < A.shape[0]:
        # 协作加载：每个线程从全局内存读一个元素到共享内存
        # 注意：加载时是原始顺序 (y, x)
        tile[cuda.threadIdx.y, cuda.threadIdx.x] = A[y, x]

    # 等待块内所有线程完成加载
    cuda.syncthreads()

    # 计算转置后写入的全局坐标
    # 交换了 blockIdx 和 threadIdx 的对应关系
    x_out = cuda.blockIdx.y * BLOCK_SIZE + cuda.threadIdx.x
    y_out = cuda.blockIdx.x * BLOCK_SIZE + cuda.threadIdx.y

    # 检查边界并写入
    if x_out < B.shape[1] and y_out < B.shape[0]:
        # 从共享内存读取，注意索引已转置 (threadIdx.x, threadIdx.y)
        B[y_out, x_out] = tile[cuda.threadIdx.x, cuda.threadIdx.y]

# 准备数据
M, N = 4096, 4096
A_cpu = np.random.randn(M, N).astype(np.float32)
B_cpu = np.empty((N, M), dtype=np.float32)

A_gpu = cuda.to_device(A_cpu)
B_gpu = cuda.device_array((N, M), dtype=np.float32)

# 配置二维网格和二维线程块
BLOCK_SIZE = 32
grid_dim = (math.ceil(N / BLOCK_SIZE), math.ceil(M / BLOCK_SIZE))
block_dim = (BLOCK_SIZE, BLOCK_SIZE)

print(f"网格配置: {grid_dim}, 块配置: {block_dim}")

# 执行优化版本
transpose_shared_memory[grid_dim, block_dim](A_gpu, B_gpu)
cuda.synchronize()
B_result_opt = B_gpu.copy_to_host()

# 作为对比，实现一个简单的全局内存版本（性能较差）
@cuda.jit
def transpose_naive(A, B):
    x = cuda.blockIdx.x * cuda.blockDim.x + cuda.threadIdx.x
    y = cuda.blockIdx.y * cuda.blockDim.y + cuda.threadIdx.y
    if x < A.shape[1] and y < A.shape[0]:
        B[x, y] = A[y, x]  # 直接全局内存写入，访问不连续

B_gpu_naive = cuda.device_array((N, M), dtype=np.float32)
transpose_naive[grid_dim, block_dim](A_gpu, B_gpu_naive)
cuda.synchronize()
B_result_naive = B_gpu_naive.copy_to_host()

# 验证正确性
expected = A_cpu.T
print(f"共享内存版本正确性: {np.allclose(B_result_opt, expected, rtol=1e-5)}")
print(f"朴素版本正确性: {np.allclose(B_result_naive, expected, rtol=1e-5)}")

这个案例展示了Numba CUDA编程的进阶技巧：利用共享内存重组数据访问模式。tile 数组就是共享内存。cuda.syncthreads() 确保了块内所有线程都完成数据加载后，才进行下一步的读取和写入操作，避免了数据竞争。共享内存的 BLOCK_SIZE+1 填充是解决bank冲突的经典技巧，能进一步提升并行效率。

4. 性能对比测试：不同工具与数据规模的实战分析

理论说再多，不如实际数据有说服力。我们来设计一个综合测试，对比在不同数据规模下，NumPy、CuPy和Numba CUDA的性能表现。我们选择矩阵乘法这个计算密集型任务作为基准。

4.1 测试设计与环境说明

我们将测试三种实现：

  1. NumPy：使用 np.dot。
  2. CuPy：使用 cp.dot。
  3. Numba CUDA：自己实现一个简单的分块矩阵乘法核函数（非最优，用于展示自定义潜力）。

测试平台：

  • CPU: Intel Core i7-12700K
  • GPU: NVIDIA GeForce RTX 4080 (16GB GDDR6X)
  • CUDA: 12.4
  • 内存: 32GB DDR4
  • 软件: Python 3.10, NumPy 1.24, CuPy 12.2, Numba 0.58

测试代码框架如下：

import time
import numpy as np
import cupy as cp
from numba import cuda, float32
import math

def benchmark_matmul(matrix_sizes):
    """对不同矩阵尺寸进行矩阵乘法性能测试"""
    results = []
    
    for size in matrix_sizes:
        print(f"\n测试矩阵尺寸: {size} x {size}")
        # 生成随机数据
        A_cpu = np.random.randn(size, size).astype(np.float32)
        B_cpu = np.random.randn(size, size).astype(np.float32)
        
        # --- NumPy (CPU) ---
        start = time.perf_counter()
        C_np = np.dot(A_cpu, B_cpu)
        np_time = time.perf_counter() - start
        print(f"  NumPy CPU: {np_time:.4f}s")
        
        # --- CuPy (GPU) ---
        A_gpu = cp.asarray(A_cpu)
        B_gpu = cp.asarray(B_cpu)
        # 预热，排除第一次编译/传输开销
        _ = cp.dot(A_gpu, B_gpu)
        cp.cuda.Stream.null.synchronize()
        
        start = time.perf_counter()
        C_cp = cp.dot(A_gpu, B_gpu)
        cp.cuda.Stream.null.synchronize()  # 确保GPU计算完成
        cp_time = time.perf_counter() - start
        print(f"  CuPy GPU: {cp_time:.4f}s (加速比: {np_time/cp_time:.2f}x)")
        
        # --- Numba CUDA (自定义核函数) ---
        # 定义核函数（使用分块优化）
        @cuda.jit
        def matmul_kernel(A, B, C):
            # 简单的分块实现，每个线程计算C的一个元素
            row = cuda.blockIdx.y * cuda.blockDim.y + cuda.threadIdx.y
            col = cuda.blockIdx.x * cuda.blockDim.x + cuda.threadIdx.x
            
            if row < C.shape[0] and col < C.shape[1]:
                tmp = 0.0
                for k in range(A.shape[1]):
                    tmp += A[row, k] * B[k, col]
                C[row, col] = tmp
        
        A_nb = cuda.to_device(A_cpu)
        B_nb = cuda.to_device(B_cpu)
        C_nb = cuda.device_array((size, size), dtype=np.float32)
        
        # 配置线程块和网格
        threads_per_block = (16, 16)
        blocks_per_grid_x = math.ceil(size / threads_per_block[0])
        blocks_per_grid_y = math.ceil(size / threads_per_block[1])
        
        # 预热
        matmul_kernel[(blocks_per_grid_x, blocks_per_grid_y), threads_per_block](A_nb, B_nb, C_nb)
        cuda.synchronize()
        
        start = time.perf_counter()
        matmul_kernel[(blocks_per_grid_x, blocks_per_grid_y), threads_per_block](A_nb, B_nb, C_nb)
        cuda.synchronize()
        nb_time = time.perf_counter() - start
        print(f"  Numba CUDA: {nb_time:.4f}s (加速比 vs CPU: {np_time/nb_time:.2f}x)")
        
        # 验证CuPy和Numba结果与NumPy的一致性（可选，大矩阵比较耗时）
        if size <= 2048:
            C_nb_cpu = C_nb.copy_to_host()
            if np.allclose(C_np, C_nb_cpu, rtol=1e-3, atol=1e-3):
                print("  Numba结果验证: 通过")
            else:
                print("  Numba结果验证: 失败")
        
        results.append((size, np_time, cp_time, nb_time))
    
    return results

# 运行测试，从小矩阵到大矩阵
sizes = [256, 512, 1024, 2048, 4096]  # 4096x4096的矩阵乘法已非常消耗显存
results = benchmark_matmul(sizes)

4.2 结果分析与决策指南

运行上述测试后，你可能会得到类似下表的趋势（具体时间因硬件而异）：

矩阵尺寸 NumPy CPU耗时 (s) CuPy GPU耗时 (s) Numba CUDA耗时 (s) CuPy加速比 (vs CPU)
256 x 256 ~0.002 ~0.001 ~0.003 ~2x
512 x 512 ~0.015 ~0.001 ~0.005 ~15x
1024 x 1024 ~0.10 ~0.003 ~0.020 ~33x
2048 x 2048 ~0.85 ~0.020 ~0.15 ~42x
4096 x 4096 ~7.50 ~0.15 ~1.20 ~50x

关键洞察：

  1. 小数据量（< 512）：GPU加速优势不明显，甚至可能更慢。这是因为启动GPU内核、数据在CPU和GPU之间传输（PCIe带宽）产生了固定开销。对于微小计算，CPU更快。
  2. 中等数据量（512 - 2048）：GPU开始展现巨大威力，加速比达到数十倍。CuPy由于调用的是高度优化的cuBLAS库，性能远超我们手写的Numba核函数。
  3. 大数据量（> 2048）：GPU的并行计算能力得到充分发挥，加速比稳定在很高水平。此时，数据传输时间相对于计算时间占比变小，GPU的吞吐量优势尽显。
  4. 工具选择：
    • 追求极致易用和性能：对于标准线性代数运算（如点积、矩阵乘法、SVD），首选CuPy。它几乎零代码修改，且底层是工业级优化库。
    • 需要自定义复杂计算逻辑：当你的算法无法用几个CuPy函数表达，或者需要精细控制内存和线程时，使用Numba CUDA。
    • 简单脚本或数据量很小：直接用NumPy，省去环境依赖和传输开销。

提示：在实际项目中，一个常见策略是“混合计算”：先用NumPy在CPU上进行数据预处理和切片，筛选出需要密集计算的核心部分，再将其转换为CuPy数组或送入Numba核函数进行GPU加速。最后将结果取回CPU进行后续分析或IO操作。这样可以最大化利用不同硬件的优势。

性能优化永无止境。对于Numba CUDA，你可以进一步探索使用共享内存进行更高效的分块矩阵乘法、利用Tensor Core（如果GPU支持）进行混合精度计算、或者使用流式处理来重叠数据传输与计算。但无论如何，通过本文的实战指南，你已经掌握了让Python代码拥抱GPU加速的核心技能，能够根据具体问题，明智地选择工具，并亲手实现性能的飞跃。下次当你的CPU再次不堪重负时，你知道该向谁求救了。

# 性能优化
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

别再只聊大模型！AI的下一场革命，藏在“身体”里

avatar 亚马逊云科技技术品牌专区
cover

别再只聊大模型！人工智能的下一场革命，藏在“身体”里

avatar 亚马逊云科技技术品牌专区
cover

别再只聊大模型！AI的下一场革命，藏在“身体”里

avatar 亚马逊云科技技术品牌专区