企业官网建设流程全解析

• 深度学习
• 后端
• 开发工具

本篇技术指南以本仓库 benchmarks/ResNet-50_v1.5_Performance_Comparison_TensorFlow_1.12_GCP.md 为骨架，系统拆解 Google Brain 团队在 GCP 上对比 Cloud TPU v2 Pod 与 NVIDIA V100 GPU 训练 ResNet-50 v1.5 时采用的性能测量方法论，并给出 V100 GPU 与 Cloud TPU 两条完整、可复现的实验操作路径。读完本文，你将掌握一套公平、可复现的 ML 训练基准设计原则，理解 ResNet-50 v1.5 与原始 ResNet 的架构差异、bfloat16/FP16 精度策略、LARS 大 batch 优化原理，并能按步骤在 GCP 上跑通训练、评估与计时全过程。

一、性能测量方法论：公平可复现基准的设计思路

机器学习训练性能基准的最大难点在于：硬件配置、软件框架、训练协议各不相同，任何一环的差异都会让对比结果失真。该文档强调"构建能公平且可复现地对比 ML 训练性能的基准需要极大的细心"，并据此确定了本次对比的几个关键约束。

硬件与框架选型：对比对象锁定为当时 Google Cloud 上两款旗舰级加速器——NVIDIA V100 GPU 与 Google Cloud TPU v2 Pod，全部实验在 GCP 上完成，使用经过充分优化的开源 TensorFlow 1.12 实现收集数据。

精度策略：这是本次基准最能体现"公平性"的地方——两边都采用针对各自硬件专门设计的低精度方案，而非让一方"裸跑"：

• Cloud TPU 使用bfloat16（专为 ML 设计的 16 位半精度数据类型，保留了与 FP32 相同的指数范围）；
• NVIDIA V100 使用混合精度float16，以最大化 Tensor Cores 的利用率。

同时，GPU 侧通过XLA编译优化计算图，进一步压榨 V100 性能。这套做法的核心思想是：对比的是"经过良好调优的系统真实性能"，而不是"某个框架的默认配置性能"。

关于规模趋势的背景：文档同时指出，最大的 ML 训练任务的规模在过去数年间快速扩张，且该趋势会持续，因此超大规模分布式训练（如 Cloud TPU Pod）的性能评估具有长期价值。

二、基准模型：ResNet-50 v1.5 的架构定义与实现细节

2.1 什么是 ResNet-50 v1.5

ResNet-50 在 ImageNet 上知名度高、被众多平台充分优化，是理想的基准模型。但 ResNet-50 存在多种架构变体与训练流程，其计算特征和最终精度差异很大。本基准选用的是被非正式称为"ResNet-50 v1.5"的变体。

它与 He 等人原始 ResNet 论文（arXiv:1512.03385）描述的架构几乎相同，唯一关键差异在于：每个残差 block 的 stride 2 下采样放在第一个 3x3 卷积上，而不是第一个 1x1 卷积上。该变体源自 "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour"（arXiv:1706.02677）对应的 fb.resnet.torch 实现，输入尺寸沿用原始 ResNet 论文的 224x224。

这一架构差异在仓库源码中有直接对应。查看 models/official/resnet/resnet_model.py 中bottleneck_block的实现：

• 第一个 1x1 卷积使用strides=1（见 resnet_model.py#L541，仅做通道压缩）；
• 中间的 3x3 卷积使用strides=strides，承担下采样（见 resnet_model.py#L563）。

每个 block group 仅第一个 block 使用 projection shortcut 与 stride（见 resnet_model.py#L632），这与 v1.5 的定义完全吻合。

2.2 GPU 侧实现：tf_cnn_benchmarks + FP16 + XLA

GPU 基准使用 tf_cnn_benchmarks 的 ResNet-50 v1.5 训练实现，其要点为：

1. 混合精度 FP16 以最大化 V100 Tensor Cores 利用率；
2. XLA 优化图执行以进一步提升性能；
3. 训练协议采用最标准的 ResNet-50 流程，固定计算量，再对比不同系统完成同样逻辑运算的耗时。

2.3 TPU 侧实现：官方参考模型 + bfloat16 + transpose

Cloud TPU Pod 侧使用标准 Cloud TPU 参考模型实现（即本仓库 models/official/resnet 目录下的 ResNet-50 v1.5），包含面向 TPU 的针对性优化：

• 在更多变量上使用 bfloat16 数值精度；
• 将 NCHW 格式的数据转置为 NHWC 再送入 TPU，以获得更好性能。

这一"转置优化"在源码中体现为transpose_input开关：默认配置'transpose_input': True（见 models/official/resnet/configs/resnet_config.py#L30）。训练输入经ImageNetInput构建，在 models/official/resnet/imagenet_input.py 中通过use_bfloat16参数控制是否将数据转换为 bfloat16 张量（见 imagenet_input.py#L314）。

2.4 为何不采用加速收敛的新协议

文档明确指出：业界新出现的多种加速收敛协议（如训练中渐进放大图像尺寸、更激进的 learning rate 调度）可以更快达到收敛，但本次基准刻意坚持最标准的训练协议——固定计算量，只比较不同系统执行相同逻辑运算的性能，从而保证对比的纯粹性。

三、可复现性设计与训练时长测量方法

3.1 目标精度：5 次运行均达 76% top-1 且无黑名单

基准将 ImageNet top-1 精度目标设定为76.0%，文档认为这接近 ResNet-50 v1.5 在标准训练协议下的可达精度上限。理由很实际：训练 ML 模型时有许多"牺牲精度换吞吐"的手段，但真实业务中最有价值的往往就是最后几个百分点的精度，因此基准选择挑战"以最高可达精度训练知名模型"。

为保证可复现，每种硬件配置独立运行 5 次完整训练，并验证所有运行均在 ImageNet 验证集上达到至少 76.0% 的 top-1 精度，且无黑名单（no blacklists）——即不通过剔除"运气不好"的运行来粉饰结果。

3.2 训练 epoch 数：90 epochs + 1 warm-up epoch

参照 "Training ImageNet in 1 Hour" 论文，每种配置测量 90 个训练 epoch。正式计时前先运行一个warm-up epoch，用于排除一次性启动成本并确保数据缓存填满。

文档还特别解释了为何要排除这些开销：当最大 Cloud TPU Pod 配置下训练时间缩短到分钟级时，初始化和编译开销占比显著（符合 Amdahl 定律）。但 Cloud TPU Pod 客户（如 eBay 这类大规模商品图像识别场景）通常训练比 ImageNet 大得多的数据集，这些开销占比不再显著，因此本次基准选择将其排除。

3.3 计时方法：基于 events/summary 文件

训练时长的定义非常精确：warmup epoch 最后一步记录训练 loss 的时间戳，与整个训练最后一步记录 loss 的时间戳之间的间隔。这个时间差准确捕获了 90 epoch 的训练时间，同时排除 GPU 与 Cloud TPU 两侧的一次性开销和缓存预热延迟。

仓库为此提供了专门脚本 models/official/resnet/benchmark/read_training_time.py，其实现逻辑为：

1. 通过--model_dir定位模型目录下的events.out.tfevents.*事件文件（TPU 模式为events.out.tfevents.*.n-*）；
2. 用tf.train.summary_iterator逐条遍历事件，匹配--event_name指定的标量（默认loss）；
3. 找到--warmup_steps对应 step 的记录作为start_time，记录该事件在事件文件中的最大wall_time作为结束时间；
4. 输出elapsed time（分钟）。

# 核心逻辑：见 read_training_time.py target_step = FLAGS.warmup_steps for e in tf.train.summary_iterator(event_file): ... if v.tag == FLAGS.event_name: if current_step == target_step: start_time = e.wall_time max_wall_time = max(e.wall_time, max_wall_time) elapse_time = max_wall_time - start_time

运行 TPU 侧计时时需额外传入--tpu=True以匹配 TPU 的事件文件命名模式。

四、大 batch 训练的两大关键优化：LARS 与 label smoothing

Cloud TPU 最大配置（v2-128 及以上）的 batch size 达到 16,384 甚至 32,768。为在这种规模下仍能高效训练，开源 ResNet-50 实现加入了两个重要优化：

4.1 LARS 优化器（Layer-wise Adaptive Rate Scaling）

当 batch size 达到 16,384 及以上时，实现从传统的 momentum SGD 切换为 You 等人提出的 LARS 优化器（arXiv:1708.03888）。LARS 按层自适应地缩放学习率，缓解超大 batch 下梯度更新的不稳定问题。

仓库中 models/official/resnet/lars_util.py 的poly_rate_schedule给出了 LARS 模式下的学习率档位策略（多项式衰减，power=2.0）：

init_lars_optimizer构建LARSOptimizer时带有skip_list=['batch_normalization', 'evonorm', 'bias']（见 lars_util.py#L92-L96），即对 BatchNorm 层和 bias 不做 LARS 缩放。在 models/official/resnet/resnet_main.py#L495-L497，启用--enable_lars=True时直接走 LARS 分支并跳过 L2 weight decay 项（LARS 自身内置 weight decay）。

4.2 Label Smoothing（标签平滑）

大 batch 下启用标签平滑，依据 TensorFlow 文档中softmax_cross_entropy的label_smoothing参数实现。文档解释：当整个训练过程的梯度更新总次数减少时，标签平滑变得更重要。在 resnet_main.py#L465-L468，交叉熵损失通过tf.losses.softmax_cross_entropy(..., label_smoothing=params['label_smoothing'])计算。

4.3 小 batch 下的学习率调度（补充源码细节）

不使用 LARS 时（即 batch < 16,384），learning_rate_schedule采用标准调度：学习率按base_learning_rate * (train_batch_size / 256.0)线性缩放（基准学习率 0.1 对应 batch 256，见 resnet_config.py#L25），前 5 个 epoch 线性 warmup，30/60/80 epoch 处依次除以 10，90 epoch 训练结束（见 resnet_main.py#L239-L280）。默认动量 0.9、weight decay 0.0001（见 resnet_config.py#L36-L37）。

五、在 GCP 的 NVIDIA V100 GPU 上复现实验

5.1 ImageNet 数据准备（GPU 版）

1. 在 image-net.org 注册 ImageNet 数据库账号，获取下载训练与评估数据的用户名和访问密钥；
2. 使用本仓库的 tools/datasets/imagenet_to_gcs.py 工具处理数据并上传到 Google Storage Bucket。该工具将原始 JPEG 转换为 TFRecord（训练集切分为 1024 个 shard、验证集 128 个 shard），运行方式示例：

python3 imagenet_to_gcs.py \ --project="TEST_PROJECT" \ --gcs_output_path="gs://TEST_BUCKET/IMAGENET_DIR" \ --raw_data_dir="path/to/imagenet"

5.2 V100 的 VM 规格选择

GCP 允许给不同规格的 VM 挂接 GPU。由于 JPEG 解码、图像预处理等输入流水线全部发生在 VM CPU 上，必须租用足够大的 VM 才能跟上 GPU 的消费速度。实验表明：训练 ResNet-50 v1.5 时，每块 V100 GPU 大约需要 8 个 vCPU 线程才能满载。据此选定如下配置（在最小化总成本的同时最大化性能）：

5.3 创建训练实例

基于针对 TensorFlow 优化的 Google Deep Learning Images 镜像启动实例（镜像家族tf-1-12-cu100），并安装 NVIDIA 驱动：

export IMAGE_FAMILY="tf-1-12-cu100" export ZONE=<Your Zone> export PROJECT=<Your Project> export INSTANCE_NAME=v100-training # 1 GPU gcloud compute instances create $INSTANCE_NAME \ --machine-type=n1-standard-8 \ --maintenance-policy=TERMINATE \ --accelerator=type=nvidia-tesla-v100,count=1 \ --tags=http-server,https-server \ --image-family=$IMAGE_FAMILY \ --image-project=deeplearning-platform-release \ --boot-disk-size=100GB \ --boot-disk-type=pd-ssd \ --local-ssd interface=nvme \ --metadata install-nvidia-driver=True # 4 GPU（挂 2 块 local NVMe SSD） gcloud compute instances create $INSTANCE_NAME \ --machine-type=n1-standard-32 \ --maintenance-policy=TERMINATE \ --accelerator=type=nvidia-tesla-v100,count=4 \ --tags=http-server,https-server \ --image-family=$IMAGE_FAMILY \ --image-project=deeplearning-platform-release \ --boot-disk-size=100GB \ --boot-disk-type=pd-ssd \ --local-ssd interface=nvme \ --local-ssd interface=nvme \ --metadata install-nvidia-driver=True # 8 GPU（挂 4 块 local NVMe SSD） gcloud compute instances create $INSTANCE_NAME \ --machine-type=n1-standard-64 \ --maintenance-policy=TERMINATE \ --accelerator=type=nvidia-tesla-v100,count=8 \ --tags=http-server,https-server \ --image-family=$IMAGE_FAMILY \ --image-project=deeplearning-platform-release \ --boot-disk-size=100GB \ --boot-disk-type=pd-ssd \ --local-ssd interface=nvme \ --local-ssd interface=nvme \ --local-ssd interface=nvme \ --local-ssd interface=nvme \ --metadata install-nvidia-driver=True

5.4 配置本地数据存储（local SSD 与 RAID）

数据放在实例本地 NVMe SSD 上以获得最高 I/O 性能。1 GPU 实例直接使用单块 NVMe 盘；4 GPU 与 8 GPU 实例分别挂载 2 块、4 块 NVMe 盘，需要通过 RAID0 合并成单一逻辑盘：

gcloud compute ssh $INSTANCE_NAME ## 4 和 8 GPU 实例 # 安装 raid 管理工具 sudo apt-get update && sudo apt-get install mdadm --no-install-recommends # 仅 8 GPU（4 块 nvme 盘）执行 sudo mdadm --create /dev/md0 --level=0 --raid-devices=4 \ /dev/nvme0n1 /dev/nvme0n2 /dev/nvme0n3 /dev/nvme0n4 # 仅 4 GPU（2 块 nvme 盘）执行 sudo mdadm --create /dev/md0 --level=0 --raid-devices=2 \ /dev/nvme0n1 /dev/nvme0n2 # 格式化并挂载阵列 sudo mkfs.ext4 -F /dev/md0 sudo mkdir -p /data && sudo mount /dev/md0 /data ## 1 GPU 实例 sudo mkfs.ext4 -F /dev/nvme0n1 sudo mkdir -p /data && sudo mount /dev/nvme0n1 /data

5.5 拷贝数据并安装 TensorFlow 1.12

sudo mkdir -p /data/imagenet && sudo chmod -R 777 /data gcloud storage cp --recursive gs://<your bucket with imagenet>/imagenet/* /data/imagenet/ # 安装针对 CUDA 10.0、cuDNN 7.3、AVX2 编译的 TensorFlow 1.12 定制版 pip install --upgrade --force-reinstall \ https://storage.googleapis.com/tf-performance/tf_binary/tensorflow-1.12.0.a6d8ffa.AVX2.CUDA10-cp27-cp27mu-linux_x86_64.whl

5.6 启动训练

克隆 benchmarks 仓库并固定到文档使用的 commit，用 tmux 保持训练进程不中断。注意--batch_size=312在 tf_cnn_benchmarks 中是每 GPU 的 batch size（8 GPU 时有效总 batch 为 8 x 312 = 2496），--num_epochs=91即 1 个 warm-up epoch + 90 个训练 epoch。训练时只记录 loss 与 learning rate 及其时间戳用于计时，summaries 异步写盘，经验证不影响性能。

git clone https://github.com/tensorflow/benchmarks.git && cd benchmarks git reset --hard 1e7d788042dfc6d5e5cd87410c57d5eccee5c664 tmux new -s bench # 8 GPUs python scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py \ --batch_size=312 \ --model=resnet50_v1.5 \ --optimizer=momentum \ --variable_update=replicated \ --nodistortions \ --gradient_repacking=2 \ --num_gpus=8 \ --num_epochs=91 \ --weight_decay=1e-4 \ --use_fp16 \ --all_reduce_spec=nccl \ --save_summaries_steps=1 \ --summary_verbosity=1 \ --num_warmup_batches=0 \ --data_dir=/data/imagenet/train \ --train_dir=$HOME/test00 \ --compute_lr_on_cpu=True \ --single_l2_loss_op=True \ --loss_type_to_report=base_loss \ --xla_compile=True # 4 GPUs python scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py \ --batch_size=312 \ --model=resnet50_v1.5 \ --optimizer=momentum \ --variable_update=replicated \ --nodistortions \ --gradient_repacking=2 \ --num_gpus=4 \ --num_epochs=91 \ --weight_decay=1e-4 \ --use_fp16 \ --all_reduce_spec=nccl \ --save_summaries_steps=1 \ --summary_verbosity=1 \ --num_warmup_batches=0 \ --data_dir=/data/imagenet/train \ --train_dir=$HOME/test00 \ --compute_lr_on_cpu=True \ --single_l2_loss_op=True \ --loss_type_to_report=base_loss \ --xla_compile=True # 1 GPU python scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py \ --batch_size=312 \ --model=resnet50_v1.5 \ --optimizer=momentum \ --nodistortions \ --num_gpus=1 \ --num_epochs=91 \ --weight_decay=1e-4 \ --data_dir=/data/imagenet/train \ --use_fp16 \ --train_dir=$HOME/test00 \ --save_summaries_steps=1 \ --summary_verbosity=1 \ --num_warmup_batches=0 \ --compute_lr_on_cpu=True \ --single_l2_loss_op=True \ --loss_type_to_report=base_loss \ --xla_compile=True

5.7 评估

训练完成后执行评估（评估用单 GPU 即可，--eval=True，验证集 batch 250、共 200 个 batch）：

# 4 和 8 GPUs 训练后的评估 python scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py \ --batch_size=250 \ --model=resnet50_v1.5 \ --variable_update=replicated \ --num_gpus=1 \ --num_batches=200 \ --use_fp16 \ --data_dir=/data/imagenet/validation \ --train_dir=$HOME/test00 \ --eval=True \ --xla_compile=True # 1 GPU 训练后的评估 python scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py \ --batch_size=250 \ --model=resnet50_v1.5 \ --nodistortions \ --num_gpus=1 \ --num_batches=200 \ --use_fp16 \ --data_dir=/data/imagenet/validation \ --train_dir=$HOME/test00 \ --eval=True \ --xla_compile=True

评估结束应看到类似输出：

Accuracy @ 1 = 0.7649 Accuracy @ 5 = 0.9309 [50000 examples]

5.8 计算训练时间

使用本仓库的 read_training_time.py 读取事件日志。各配置的--warmup_steps与--end_step与 batch 配置一一对应——以 ImageNet 训练集 1,281,167 张图计算，steps_per_epoch = 1281167 / (312 x num_gpus)，warmup_steps 为一整轮 epoch 的步数（8 GPU 约 513 步、4 GPU 约 1026 步、1 GPU 约 4107 步），end_step 约为 91 个 epoch 的总步数：

git clone https://github.com/tensorflow/tpu.git cd tpu/models/official/resnet/benchmark # 8 GPUs python read_training_time.py --model_dir=$HOME/test00/ \ --warmup_steps=513 \ --end_step=46710 \ --event_name=base_loss # 4 GPUs python read_training_time.py --model_dir=$HOME/test00/ \ --warmup_steps=1026 \ --end_step=93419 \ --event_name=base_loss # 1 GPU python read_training_time.py --model_dir=$HOME/test00/ \ --warmup_steps=4107 \ --end_step=373674 \ --event_name=base_loss

（注意：--event_name=base_loss对应训练命令中的--loss_type_to_report=base_loss。）

六、在 GCP 的 Cloud TPU / TPU Pod 上复现实验

6.1 ImageNet 数据准备（TPU 版）

1. 新建 GCS bucket，务必选择Regional 存储类别，且区域与 Cloud TPU 的目标位置一致；
2. 在 image-net.org 注册并获取数据下载凭证；
3. 在 GCE VM 或本地桌面运行本仓库的 tools/datasets/imagenet_to_gcs.py，下载、处理并重新上传数据到 GCS bucket。

6.2 VM 规格：为什么只需 n1-standard-2

GCP 上的多种 Cloud TPU 硬件配置均由主机与 TPU 加速器均衡组合而成，通过网络自动构建并对外提供。与 GPU 场景（预处理在 VM CPU 上完成）不同，TPU 场景下训练数据存放在 GCS，所有输入预处理都发生在 Cloud TPU server 侧，因此协调计算只需要一个很小的 VM。本次所有 Cloud TPU 实验均使用 n1-standard-2。

6.3 Cloud TPU 训练步骤

1. 通过 Google Cloud console 创建 TensorFlow 1.12 版本的 Cloud TPU 或 Cloud TPU Pod slice；
2. 启动 n1-standard-2 的 GCE VM（Ubuntu 16.04 LTS，勾选 "Allow full access to all Cloud APIs"），并在 VM 上安装 TensorFlow 1.12；
3. 克隆仓库并切换到r1.12分支：

git clone https://github.com/tensorflow/tpu cd tpu && git checkout r1.12

4. 将models目录加入 PYTHONPATH 并启动训练（建议在 screen 会话中运行，避免 SSH 断线中断训练）：

export PYTHONPATH="$PYTHONPATH:~/tpu/models" python tpu/models/official/resnet/resnet_main.py \ --tpu=MY_TPU_NAME --tpu_zone=MY_TPU_ZONE --num_cores=TPU_CORES \ --data_dir=gs://IMAGENET_DATA_BUCKET/DIRECTORY \ --model_dir=gs://RESNET_CHECKPOINT_BUCKET/DIRECTORY \ --train_batch_size=BATCH_SIZE --iterations_per_loop=ITERATIONS \ --train_steps=ITERATIONS \ --mode=train --eval_batch_size=1000

各 TPU 系统规模对应的关键参数如下（BATCH_SIZE与ITERATIONS的设计关系：以训练集 1,281,167 张图计算，steps_per_epoch = 1281167 // BATCH_SIZE，ITERATIONS 约等于 91 个 epoch 的总步数，保证 1 个 warm-up + 90 个训练 epoch）：

当 batch size >= 16,384 时，还需追加以下参数以启用 LARS 优化器与标签平滑：

--enable_lars=True --label_smoothing=0.1

这正对应上文第四节分析的源码逻辑：--enable_lars=True时 resnet_main.py 走 LARS 分支（对应 lars_util.py 的 poly 学习率调度），--label_smoothing=0.1传入 softmax 交叉熵损失。

该脚本共运行 91 个 epoch（1 个 warm-up + 90 个训练 epoch）。对每个结果，文档要求完整运行 5 次并报告中位数训练时长；按上表 BATCH_SIZE 与 ITERATIONS 参数运行的所有实验均观察到达到 76% top-1 精度。

5. 训练结束后，按上文"训练时长测量方法"计时。各 TPU 配置的warmup_steps（对应一个训练 epoch 的步数）如下：

示例命令（注意 TPU 侧要加--tpu=True）：

python ~/tpu/models/official/resnet/benchmark/read_training_time.py \ --model_dir=gs://RESNET_CHECKPOINT_BUCKET/DIRECTORY \ --warmup_steps=WARMUP_STEPS \ --tpu=True

6.4 Cloud TPU 评估

评估命令与训练类似，但目前评估仅支持单个 Cloud TPU，因此--num_cores=8：

python ~/tpu/models/official/resnet/resnet_main.py \ --tpu=MY_TPU_NAME --tpu_zone=MY_TPU_ZONE --num_cores=8 \ --data_dir=gs://IMAGENET_DATA_BUCKET/DIRECTORY \ --model_dir=gs://RESNET_CHECKPOINT_BUCKET/DIRECTORY \ --train_batch_size=BATCH_SIZE --iterations_per_loop=ITERATIONS \ --train_steps=ITERATIONS \ --mode=eval --eval_batch_size=1000

评估结束应看到类似输出：

Eval results: {'loss': 2.2301836, 'top_1_accuracy': 0.76658, 'global_step': 28151, 'top_5_accuracy': 0.93422}. Elapsed seconds: 33

该输出格式与 resnet_main.py#L785-L786 的日志语句一致——评估完成后打印Eval results与Elapsed seconds。

七、仓库中的配套参考资源

除上述复现路径外，本仓库还提供了与 ResNet-50 基准相关的配套资源，可进一步深化理解：

• models/official/resnet/resnet_main.py：Cloud TPU 侧 ResNet 训练的完整入口，含学习率调度、LARS 分支、TPU host_call 摘要写入与评估逻辑；
• models/official/resnet/resnet_model.py：ResNet-50 v1.5 网络结构定义，可对照验证 stride 位置；
• models/official/resnet/lars_util.py：LARS 优化器初始化与多项式学习率调度；
• models/official/resnet/configs/resnet_config.py：ResNet 训练默认超参数（train_batch_size=1024、base_learning_rate=0.1、precision=bfloat16 等）；
• models/official/resnet/benchmark/read_training_time.py 与 models/official/resnet/benchmark/README.md：训练计时工具与单 TPU 复现说明；
• tools/datasets/imagenet_to_gcs.py：ImageNet 数据集转换与 GCS 上传工具。

结语

这套基准方法论的核心价值在于"公平"二字：两边都使用各自硬件上最合适的低精度方案（bfloat16 vs FP16 Tensor Cores）、都运行相同的标准训练协议、都以 5 次无黑名单运行确保可复现、都通过统一的 events 时间戳口径测量 90 epoch 的净训练时长。无论你关注的是 V100 GPU 的 XLA + 混合精度优化，还是 Cloud TPU 的 bfloat16、double-transpose 与大 batch LARS 训练，本文给出的命令与参数都可以作为在 GCP 上自行验证、复现乃至拓展对比实验的起点。

• 深度学习
• 后端
• 开发工具