24 小时内用 672 美元重现 GPT-2！

CSDN资讯

已于 2024-07-16 09:29:35 修改

阅读量1.2k

点赞数 17

文章标签： gpt

于 2024-07-15 17:25:59 首次发布

本文链接：https://blog.csdn.net/csdnnews/article/details/140453043

版权

随着时间的推移，大模型的训练成本再降，如今只需几百美元，就可以复现 GPT-2。

编译 | 苏宓

出品 | CSDN（ID：CSDNnews）

OpenAI 在 2019 年推出了 GPT-2 时，据外媒 Tom‘s Hardware 报道称，当时训练费用为每小时 256 美元。如今五年过去了，随着 GPT-4 以及旗舰级 GPT-4o 的到来，AI 大模型的训练成本是否降了？

对此，特斯拉前 AI 总监、OpenAI 联合创始人 Andrej Karpathy 于近日重现 GPT-2 项目之后给出了具体的答案，其表示，「今天，你可以花费约 672 美元训练自己的模型，在一个 8XH100 GPU 节点上运行 24 小时。」事实证明，硬件、软件和数据方面的进步意味着训练同一个模型所需的时间和金钱都会减少。

与此同时，Andrej Karpathy 还在自己的 GitHub 项目页面（https://github.com/karpathy/llm.c/discussions/677）中分享了整个重现的过程，我们不妨来看看这位大神是怎么做的。

只用 672 美元的价格在 24 小时内重现 GPT-2 模型

值得一提的是，Andrej Karpathy 于今年 2 月宣布从 OpenAI 友好地离职后，没多久，他就带来了自己徒手编写的 1000 行 C 代码即实现 GPT-2 训练的新项目——LLM.c（https://github.com/karpathy/llm.c）。在这个项目基础上，Andrej Karpathy 时下直接重现了完整的 15.58 亿个参数的 GPT-2 项目，就是彼时 OpenAI 在《更好的语言模型及其影响》（https://openai.com/index/better-language-models/）中介绍的那个 GPT-2。

Andrej Karpathy 表示，llm.c 直接在 C/CUDA 中完成（共约 5000 行代码），而不需要传统的训练栈，该堆栈涉及到了 Python 解释器和 PyTorch/JAX、huggingface/transformers 等明显更复杂的深度学习库。

2019 年，训练 GPT-2 是一个需要整个团队参与的项目，被认为是一次大型模型运行实践，但 5 年后的今天，由于计算（H100 GPU）、软件（CUDA、cuBLAS、cuDNN、FlashAttention）和数据（如 FineWeb-Edu 数据集）的改进，他们做到了可以在单个 8XH100 节点上以 672 美元的价格在 24 小时内重现这个模型。

“这是非常不可思议的”，Andrej Karpathy 说道。不过，这其中也有一些注意事项和挑战——llm.c 仍未得到完美调整和充分稳定（我们仍时不时会看到 loss 峰值和不良激活范围），而且评估也不够全面（例如，没有仔细评估多语言、代码和数学）。

复现准备工作

Andrej Karpathy 分享道，使用 llm.c 训练 GPT-2 非常简单，因为它是用 C/CUDA 编写的，所以不需要 minconda、Python、PyTorch 等软件。

你只需要一个 8XH100 GPU。

不过，llm.c 的计算方式很灵活——如果你只有 1 个 GPU，你仍然可以获得 GPT-2，只是需要等待 8 天，而不是 1 天。如果你有 16 个 GPU（例如使用新的 Lambda 1 Click Clusters），你就可以进行多节点训练，只需等待 12 个小时。

启动节点后，以下是训练 GPT-2 的完整说明（从空白框到开始执行只需约 1 分钟的时间）：

# install cudnn so we can use FlashAttention and run fast (optional)
# https://developer.nvidia.com/cudnn-downloads
# for me, CUDA 12 (run `nvcc --version`) running on Linux x86_64 Ubuntu 22.04
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
sudo apt-get -y install libcudnn9-dev-cuda-12




# "install" cudnn-frontend to ~/
git clone https://github.com/NVIDIA/cudnn-frontend.git




# install MPI (optional, if you intend to use multiple GPUs)
# (you might also have to install NVIDIA NCCL if it doesn't come with your setup)
sudo apt -y install openmpi-bin openmpi-doc libopenmpi-dev




# download and enter llm.c repo
git clone https://github.com/karpathy/llm.c.git
cd llm.c




# download the "starter pack" (~1GB download)
# contains GPT2-124M weights (used in tests), tokenizer, eval data .bin s
./dev/download_starter_pack.sh




# download the training dataset (FineWeb-Edu 100B token) .bin data shards
# note: this is a total of 1001 data shards. If you only want to test things
# out and don't want to do an actual run, feel free to append the number of
# training shards to download (e.g. for just 10 shards: ./edu_fineweb.sh 10)
# the full dataset is ~200GB, we can store it here in dev/data directory.
cd dev/data
./edu_fineweb.sh




# compile (~1 min 1st time for cuDNN mostly, few sec from then on)
cd ../../
make train_gpt2cu USE_CUDNN=1




# and train! (wait 24 hours here)
mpirun -np 8 ./train_gpt2cu \
-i "dev/data/edu_fineweb100B/edu_fineweb_train_*.bin" \
-j "dev/data/edu_fineweb100B/edu_fineweb_val_*.bin" \
-o "log_gpt2_1558M" \
-v 250 -s 300000 -g 384 \
-h 1 \
-b 16 -t 1024 \
-d 1048576 \
-r 0 \
-z 1 \
-c 0.1 \
-k "cosine" \
-l 0.0006 \
-q 0.1 \
-u 700 \
-n 2000 \
-x 32000 \
-ge 1 \
-y 1 \
  -e "d48"

接下来，你将看到一堆打印滚动，然后优化将开始：

num_parameters: 1557686400 => bytes: 3115372800
allocated 2971 MiB for model parameters
batch_size B=16 * seq_len T=1024 * num_processes=8 and total_batch_size=1048576
=> setting grad_accum_steps=8
created directory: log_gpt2_1558M
allocating 40409 MiB for activations
val loss 11.129390
allocating 2971 MiB for parameter gradients
allocating 742 MiB for AdamW optimizer state m
allocating 742 MiB for AdamW optimizer state v
allocating 742 MiB for master copy of params
step    1/32000 | loss 11.133732 (+nanz)| norm 52.9732 (+nanz)| lr 8.57e-07 | 3056.36 ms | 42.6% bf16 MFU | 343080 tok/s
step    2/32000 | loss 10.539388 (+nanz)| norm 43.5996 (+nanz)| lr 1.71e-06 | 2747.19 ms | 47.4% bf16 MFU | 381690 tok/s
step    3/32000 | loss 9.894109 (+nanz)| norm 23.2229 (+nanz)| lr 2.57e-06 | 2753.25 ms | 47.3% bf16 MFU | 381259 tok/s
step    4/32000 | loss 9.566241 (+nanz)| norm 28.4920 (+nanz)| lr 3.43e-06 | 2741.47 ms | 47.5% bf16 MFU | 381690 tok/s
step    5/32000 | loss 9.482848 (+nanz)| norm 23.7817 (+nanz)| lr 4.29e-06 | 2752.07 ms | 47.3% bf16 MFU | 381507 tok/s
step    6/32000 | loss 9.332832 (+nanz)| norm 15.9113 (+nanz)| lr 5.14e-06 | 2751.01 ms | 47.3% bf16 MFU | 381431 tok/s
step    7/32000 | loss 9.165650 (+nanz)| norm 10.5941 (+nanz)| lr 6.00e-06 | 2753.03 ms | 47.3% bf16 MFU | 381327 tok/s
step    8/32000 | loss 9.132234 (+nanz)| norm 16.2733 (+nanz)| lr 6.86e-06 | 2748.91 ms | 47.3% bf16 MFU | 381348 tok/s
step    9/32000 | loss 9.097384 (+nanz)| norm 12.1342 (+nanz)| lr 7.71e-06 | 2748.73 ms | 47.3% bf16 MFU | 381367 tok/s
step   10/32000 | loss 9.072879 (+nanz)| norm 10.5923 (+nanz)| lr 8.57e-06 | 2749.40 ms | 47.3% bf16 MFU | 381369 tok/s
...

可以看到，每一步骤的时间约为 2.75 秒，一共有 32000 个步骤，所以现在我们要等待约 24 小时。

在每一步骤中，训练运行都会从 FineWeb-EDU （这些都是互联网上的教育网页）中抽取约 100 万个 token，并更新模型的 1.558 亿个权重，以便更好地预测序列中的下一个 token。

最后，总共处理了 32,000 * 1048576 = 336 亿个 token。随着能更好地预测下一个 token，loss 也会随之减少。常模将稳定在 0.1-1 左右，学习率在前几步中得到了预热。所以，这里的模型单元利用率（MFU）约为 50%，即相当高效。

现在等待 24 小时后，可以使用 dev/vislog.ipynb jupyter notebook 查看 main.log 日志文件。为此，你还需要安装 Python 和 matplotlib。

验证与评估

根据上图所示，左边追踪的是 FineWeb-EDU 验证数据的 loss。如果只运行 OpenAI 发布的 GPT-2 并评估其在这一数据上的 loss，就会得到红色水平线（loss 为 2.83）。

对比之下，Andrej Karpathy 模型的运行速度很快就超过了它，步长约为 5,000。

不过，Andrej Karpath 坦言，这种比较并不公平，因为 GPT-2 是在从未发布的 WebText 数据集上训练的，因此可能存在较大的分布偏移。因此，举例来说，如果以 LR 1e-4 对 OpenAI 模型进行 1000 步的微调，loss 会迅速下降到蓝线（损失为 2.61），因为它正在快速适应新的数据统计。

“我喜欢把验证 loss 看成是理智的检查，但实际比较时，我们还是要看固定的第三方评估结果。HellaSwag 评估是一种表现良好、平稳、常见、经常被引用的评估，它还能提供早期信号。这些都是简单的常识性场景，模型必须选择正确的延续”，Andrej Karpath写道。

在右侧窗格中对 HellaSwag 进行评估，可以看到 llm.c 模型在大约 25K 步左右超越了 GPT-2 模型（早于 GPT-2，据估计 GPT-2 是在 ~100B 个词组上训练出来的。这可能与数据质量的提高有关，Andrej Karpath 称，在之前的 124M 运行中也观察到了这一点）。

绿线是相同规模的 GPT-3 模型，它的模型架构与 GPT-2 基本相同，只是略有不同（上下文长度为 1024 -> 2048），但训练了 3 亿个 token（即比我们在这里训练的 token 多 10 倍）。

Andrej Karpath 表示，「我想说的是，即使是 HellaSwag 也不是一个理想的单点比较选项，因为它测试的是简单的英语和常识，而不是多语言、数学或代码。可能是 WebText 数据集在这些方面的权重较大，而这些领域在某种程度上"窃取"了模型的能力，我们不得而知，因为它从未发布过。最后，一般来说，在 GPT-2 这样的低模型能力下，好的评估结果更难，因为模型不理解多项选择，而且它们的样本质量不够高，无法在标准数学或代码 evals 中取得高于偶然性的效果。」

参数指南

让我们来详细了解一下现在传入训练的参数。OpenAI 发布的 GPT-2 包含模型权重，但细节很少；而 GPT-3 没有权重，但细节很多。因此，在很多情况下，Andrej Karpath 采用 GPT-3 论文中的超参数，因为 GPT-2 论文中的信息非常非常少：

mpirun -np 8 ./train_gpt2cu （启动命令：使用 mpi 启动 8 个进程，每个进程在 1 个 GPU 上运行训练，在这个 8XH100 节点上共有 8 个 GPU）。如果有 4 个 GPU，请使用 -np 4。如果只有 1 个 GPU，则可以跳过 mpi，即只需将其更改为 ./train_gpt2cu。
-i -j 是训练和验证分割标记文件，通过 edu_fineweb.sh 下载
-o 是将日志和检查点写入的输出目录
-v 250 要求每 250 步评估并记录验证loss
-s 300000 要求每 300000 步采样一些 token。由于总步数将小于此值，因此这是一种关闭采样的简便方法，只会在最后采样一次。
-g 384 设置最后采样的标记数为 384
-h 1 要求评估 HellaSwag 的准确性
-b 16 将微批大小设置为 16。如果内存不足，可以减小该值，例如尝试 8、4、2，直至 1。
-t 1024 将最大序列长度设置为 1024，与 GPT-2 相同。
-d 1048576 按照 GPT-3 的超参数表，要求总批次大小为 20 的 2 次方。代码将确保满足所需的总批次大小，并计算优化 "内循环 "步骤所需的梯度累积。例如，在上面我们看到有 8 个 GPU，每个 GPU 处理 16 X 1024 个代币，那么每个微步（单次前进后退）就是 8 X 16 X 1024 = 131,072 个代币，因此代码计算出梯度累积步骤为 8，以满足每步所需的 100 万批次大小，即前进+后退 8 次，然后单次更新。
-r 0 设置重新计算为零。重新计算是一种权衡计算和内存的方法。如果 -r 为 1，那么我们将在后向过程中重新计算前向过程的一部分（GeLU）。这意味着我们不必缓存它，从而节省了内存，但代价是需要更多的计算量。因此，如果内存不足，可以试试 -r 1 或 -r 2（也会重新计算布局）。
-z 1 在多个 GPU 上开启 ZeRO-1（即优化器状态分片）。如果训练使用的 GPU 超过 1 个，则无需考虑此设置，基本上应始终开启。在使用 1 个 GPU 的情况下，此设置为无效。
-c 0.1 将权重衰减设置为 0.1。只有（2D）权重的衰减与 GPT-2 完全相同，这个数字来自 GPT-3 论文。
-k "余弦"设置余弦学习率计划，这是默认设置。
-l 0.0006 将最大学习率设置为 6e-4。GPT-3 的论文中说该模型大小应使用 2e-4，但在这里使用了三倍的学习率，似乎训练速度更快，而且没有任何问题。这还没有经过仔细调整。
-Q 0.1 表示在训练过程中，将把学习率衰减到最大 LR 的 10%，这与 GPT-3 论文一致。
-u 700 表示将在前 700 次迭代中将学习率从 0 提升到最大学习率，按照 GPT-3 论文的要求，在总批次大小为 0.5M 时，学习率为 3.5 亿个 token。
-n 2000 要求每 2000 步保存模型检查点。
-x 32000 要求总步数为 32K 步。之所以选择这个数字，是因为它是一个很好的数字，而且正好适合 24 小时。
-ge 1 为 CublasLt 设置一个新近合并的 gelu 重新计算设置（可选）
-y 1 设置"恢复"标志。如果你的训练因故崩溃或挂起，你可以 CTRL+C 并重新运行这条命令，它会尝试恢复优化。llm.c 是 bit 确定的，所以你会得到与没有崩溃时相同的结果。
-e "d48" 要求从头初始化一个深度为 48 的 GPT-2 模型。

内存指南

大多数人可能面临的最大限制是他们的 GPU 没有 80GB 的内存。

Andrej Karpath 表示，“没关系，如果你有耐心，仍然可以运行上述所有内容，只是速度会变慢。所以，如果模型不适合，你可以调整什么呢？最重要的是调整微批次大小 -b。尝试减小它，但要保持整齐的数字。例如，从 16 到 8，再到 4，2，1。

在此基础上，还可以尝试调整重计算设置 -r，值为 0（最快，内存占用大）、1（稍微慢一点，但节省大量内存）或 2（稍微慢一点，节省较少内存）。

接下来可以做的是禁用 fp32 中的主权重，使用 -w 0（默认值为1）可以做到这一点。”

Karpath 称，他们不会维护 fp32 的参数副本。在之前的几次运行中，经验表明这样做是可以的，可能是由于他们使用了随机舍入。如果即便这样也不合适，你可以尝试降低最大序列长度 -t，默认值为1024，可以降到512，256等，但这会使你的模型变得更糟，因为你降低了它的最大注意范围。

代码

“毫无疑问，我可能有偏见，但 llm.c 确实很优雅”，Karpathy 表示：

它运行只需要基本的 CUDA 依赖项。
它是一个直接、简洁且可读的C/CUDA实现。llm.c总共约有5000行C/CUDA代码。我们尽量使用C而不是C++，以保持简单。神经网络训练只是一个while循环，执行相同的、简单的算术运算（比如+、-、*、/）在一个浮点数组上，实际上不应该那么复杂。
它编译和运行非常快（几秒钟），所以你会花更多时间在调试上，减少等待时间。
它在开始时一次性分配所有的GPU内存，从那以后在训练过程中内存占用保持完全不变。所以一旦你开始训练，你就知道在整个运行过程中不会出现内存不足的问题。
它是 bit 级确定性的。
它的效率很高，接近~50%的最大浮点数运算利用率（MFU）。
主要入口点和大部分代码在文件train_gpt2.cu中。该文件包含GPT-2模型定义和训练循环，大约有2000行代码，并从llmc目录中导入了许多包含各种工具和各层实现的辅助文件。cloc llmc报告有23个文件，共3170行代码，而cloc train_gpt2.cu目前有1353行代码。

多节点训练

如果你属于拥有大量 GPU 的上层阶级，llm.c 支持多节点训练。

Karpathy 分享道，其个人目前做过的最大规模训练是在 Lambda 的全新一键集群功能上，用 2 个节点的 16XH100 GPU 进行的。这是「失业的坏处之一」，毕竟没有钱了。

同时，他还说道，Lambda 团队提供了详细的说明，教你如何在他们的一键集群上训练 llm.c模型。例如，使用 512 个 GPU 的 H100 集群，每小时费用为2,300 美元，你可能在大约30分钟内训练好GPT-2。你需要增加总批量大小（例如到约800万），可能还需要稍微调整超参数。不过，Karpathy自己没有尝试过，但其表示，「它可能可行，而且会非常酷」。

PyTorch 比较

Karpathy 认为，使用其并行 PyTorch 实现，在 PyTorch 中进行相对可比的运行应该是这样的：

torchrun --standalone --nproc_per_node=8 train_gpt2.py \
    --input_bin "dev/data/edu_fineweb100B/edu_fineweb_train_*.bin" \
    --input_val_bin "dev/data/edu_fineweb100B/edu_fineweb_val_*.bin" \
    --write_tensors 0 \
    --model d48 \
    --batch_size 8 --sequence_length 1024 --total_batch_size 1048576 \
    --dtype bfloat16 \
    --compile 1 \
    --tensorcores 1 \
    --flash 1 \
    --num_iterations 32000 \
    --warmup_iters 700 \
    --weight_decay 0.1 \
    --overfit_single_batch 0 \
    --learning_rate 0.0006 \
    --zero_stage 1

PyTorch 代码仅供测试参考，而非实际实现，因此训练循环在某些地方略有不同（例如，数据加载器不会对分片进行置换等），但这仍可能作为参考点有用。他还将默认词汇大小修改为 50257 -> 50304 以提高效率，然后当前的 PyTorch 夜间版本给出：

step   16/32000 | train loss 8.903997 | norm 8.3474 | lr 1.37e-05 | (3381.88 ms | 310057 tok/s)
step   17/32000 | train loss 8.870140 | norm 3.7936 | lr 1.46e-05 | (3381.95 ms | 310051 tok/s)
step   18/32000 | train loss 8.875732 | norm 9.4993 | lr 1.54e-05 | (3393.09 ms | 309033 tok/s)
step   19/32000 | train loss 8.817432 | norm 2.8345 | lr 1.63e-05 | (3379.75 ms | 310253 tok/s)
step   20/32000 | train loss 8.798056 | norm 4.1234 | lr 1.71e-05 | (3386.53 ms | 309631 tok/s)
step   21/32000 | train loss 8.777574 | norm 2.8010 | lr 1.80e-05 | (3386.05 ms | 309675 tok/s)
...

现在，Andrej Karpathy表示，“不能说我完全有信心 PyTorch 脚本已得到最大程度的调整，但可以进行以下观察”。

PyTorch 似乎占用了更多内存（此次运行约为 80GB），而 llm.c 占用了 57GB（提高了 29%）。内存很重要，因为它允许你增加批处理大小（例如，llm.c 在此处可以增加到 24 个微批处理），这样速度会更快一些。

其次，pytorch 每次迭代大约为 3386 毫秒，而 llm.c 则为 2750 毫秒，因此 llm.c 的速度提高了约 19%。一些性能提升的原因是已知的，例如 llm.c 包含了像启动反向传播的 Fused classifier 之类的优化，而 Andrej Karpathy 透露，torch.compile 目前并未实现这一点。但也有可能这个脚本尚未完全调优，不过无论如何，Andrej Karpathy 展示这个对比是为了：

1) 让其他人可以查看、试用、比较和帮助调优，

2) 表明llm.c在GPT-2/3训练的特定情况下已经相当优化和快速。

最终模型

main.log 文件（http://llmc.s3-us-west-2.amazonaws.com/gpt2_1558M/main.log）。
model_00032000.bin llm.c bin 模型文件（http://llmc.s3-us-west-2.amazonaws.com/gpt2_1558M/model_00032000.bin）
转换为 huggingface transformers GPT-2 模型的模型，已上传到了这里：karpathy/gpt2_1558M_final2_hf（https://huggingface.co/karpathy/gpt2_1558M_final2_hf）。
现在还添加了一个经过 100k （https://huggingface.co/karpathy/gpt2_1558M_final3_hf）步训练的模型版本，该模型的 HellaSwag 值为 57.7，而经过 330K（https://huggingface.co/karpathy/gpt2_1558M_final4_hf）步训练的模型的 HellaSwag 值为 62.7。

模型导出

例如，模型导出可按如下方式进行：

python dev/eval/export_hf.py --input log_gpt2_128M/model_00032000.bin --output gpt2_1558M_export

然后，你就可以运行 Eleuther 评估工具，或者运行 huggingface 采样管道来获取模型样本：

# take model for spin
import torch


output = "./gpt2_1558M_final2_hf"


# set pytorch seeds
torch.manual_seed(42)
torch.cuda.manual_seed(42)


prompt = "In a shocking finding, scientist discovered a herd of unicorns living in a remote, previously unexplored valley, in the Andes Mountains. Even more surprising to the researchers was the fact that the unicorns spoke perfect English."
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(output)
model = AutoModelForCausalLM.from_pretrained(output, attn_implementation="flash_attention_2", torch_dtype=torch.bfloat16, device_map='cuda')
model.eval()
tokens = tokenizer.encode(prompt, return_tensors="pt")
tokens = tokens.to('cuda')


output = model.generate(tokens, max_new_tokens=500, pad_token_id=tokenizer.eos_token_id, do_sample=True, top_k=50, num_return_sequences=4)
samples = tokenizer.batch_decode(output)
for sample in samples:
    print('-'*30)
    print(sample)

400B token 运行

除此之外，Andrej Karpathy 还尝试用远超 33B token 的规模来训练 GPT-2。具体而言，他将 -x 改为 400,000，以训练 420B token（规模甚至比使用 300B 训练的 GPT-3 模型还要大）。

这个模型在运行到第 330,000 步骤之前一直很好：

该模型在 HellaSwag 上大大超越了同等大小的 GPT-2 和 GPT-3（最高可达约 61%），但遗憾的是，从那时起它就变得不稳定并出现了问题。

在这个过程中，有更多较小的峰值，但 Karpathy 将代码配置改为当检测到瞬时不稳定时跳过更新（其中使用了 -sl 5.0 -sg 5.0 标记），这有助于缓解和推迟问题。

对此，Karpathy 认为其对初始化、激活范围和整体模型训练稳定性还不够谨慎，并且存在更深层次的问题，这些问题会逐渐使模型陷入不稳定状态，尤其是对于较大的模型和长时间的训练。这也是他们未来想要进一步研究和探讨的地方。

以上，便是 Karpathy 此次实践的整个经过。

人工智能训练不会越来越便宜

不过，也有人认为硬件、软件和训练数据的进步并不意味着尖端的 AI 训练会越来越便宜。

Anthropic 公司首席执行官 Dario Amodei 表示，目前正在训练的人工智能模型已经耗资 10 亿美元，而更昂贵的模型在 2025 年就会达到 1000 亿美元。

这是因为虽然硬件性能越来越强大，但价格也越来越昂贵。例如，NVIDIA H100 目前每台售价 4 万美元。尽管如此，下一代 Blackwell AI 芯片的售价预计将达到 7 万美元，除非我们能找到像 Sohu AI 芯片（专为变压器设计的 ASIC）这样的硬件突破，否则一个完整的服务器机架的售价将达到 300 万美元甚至更高。

除了成本方面的影响，AI 数据中心日益增长的电力需求也开始引起一些专家的关注。仅一块 H100 芯片，以平均 61% 的年利用率运行，每年就会消耗 3.7 兆瓦时的电力。仅以平均 61% 的年利用率运行的一个 H100 芯片每年就要消耗 3.7 兆瓦时的电力。去年，Nvidia 和其他所有参与者共售出超过 380 万台 AI GPU，相当于每年 14.3 TWh 的电力，足以为 130 万个普通美国家庭供电。

但即使投入大量资金和精力在 AI 上，谷歌 DeepMind 首席执行官表示，目前的模型仍然只处于猫的智商水平。因此，我们仍然需要为未来的模型再投资数十亿美元。但是，如果你想尝试使用旧模型构建自己的 LLM，通过 Karpathy的方法，只要几百美元就够了。

来源：

https://github.com/karpathy/llm.c/discussions/677

https://www.tomshardware.com/tech-industry/artificial-intelligence/former-tesla-ai-director-reproduces-gpt-2-in-24-hours-for-only-672

▶程序员凭一己之力自研浏览器，挑战Chrome：GitHub联合创始人力挺，投百万美元支持！

▶万字巨制！阿里、百度、腾讯、字节、蚂蚁等 9 大技术专家同台，“卷”出 AI 编码新未来

炎炎夏日🔥，AI 科技大本营送清凉福利！

扫码回复“抽奖”即有机会获得时尚 T 恤、精选图书和大会精品 PPT 等好礼~

CSDN资讯

关注

17
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
24 小时内用 672 美元重现 GPT-2！

随着时间的推移，大模型的训练成本再降，如今只需几百美元，就可以复现 GPT-2。编译 | 苏宓出品 | CSDN（ID：CSDNnews）OpenAI 在 2019 年推出了 GPT-2 时，据外媒 Tom‘s Hardware 报道称，当时训练费用为每小时 256 美元。如今五年过去了，随着 GPT-4 以及旗舰级 GPT-4o 的到来，AI 大模型的训练成本是否降了？对此，特斯拉前 AI 总监...
复制链接

扫一扫