[{"data":1,"prerenderedAt":5130},["ShallowReactive",2],{"learning-material-cmu-15-779-tensorflow-paper-zh":3},{"courseSlug":4,"slug":5,"fileName":6,"title":7,"description":8,"language":9,"sourcePdf":10,"sourceLanguage":11,"body":12,"toc":5084,"bytes":5128,"downloadPath":5129},"cmu-15-779","tensorflow-paper-zh","tensorflow-paper-zh.md","TensorFlow：面向大规模机器学习的系统","TensorFlow 论文中文学习译稿。","zh","\u002Fmaterials\u002Fcmu-15-779\u002Foriginals\u002Ftensorflow-paper-original.pdf","en",{"type":13,"children":14},"root",[15,23,33,38,52,57,63,68,73,79,84,89,94,99,109,115,120,127,132,137,142,153,163,173,178,184,189,199,209,219,224,229,235,245,250,260,265,275,280,285,291,296,311,316,322,333,338,352,357,363,373,493,499,518,558,563,780,816,888,1168,1189,1265,1270,1276,1288,1293,1299,1304,1324,1329,1334,1381,1386,1392,1397,1424,1508,1513,1519,1529,1539,1552,1558,1563,1569,1574,1579,1763,2101,2272,2284,2290,2295,2770,2797,2802,2807,2813,2823,2891,2897,2902,2907,2970,2988,2993,2999,3004,3009,3014,3019,3025,3035,3040,3046,3051,3056,3061,3066,3071,3097,3102,3107,3112,3118,3128,3133,3139,3144,3149,3155,3160,3167,3322,3327,3332,3338,3343,3348,3353,3358,3364,3373,3378,3384,3389,3394,3399,3404,3409,3414,3783,3788,3794,3804,3809,3815,3820,3825,3830,3835,3840,3846,3855,3860,3866,3871,3876,3881,3886,3891,3896,3901,3920,3939,3958,3977,3996,4008,4020,4039,4058,4077,4096,4108,4127,4146,4158,4177,4189,4208,4227,4239,4251,4263,4275,4287,4299,4311,4323,4342,4354,4373,4392,4404,4416,4435,4447,4459,4478,4497,4509,4521,4540,4552,4571,4583,4595,4614,4626,4638,4657,4676,4695,4714,4726,4745,4764,4776,4795,4807,4819,4831,4843,4855,4874,4893,4905,4917,4929,4948,4967,4979,4991,5010,5029,5048,5067,5079],{"type":16,"tag":17,"props":18,"children":20},"element","h1",{"id":19},"tensorflow面向大规模机器学习的系统",[21],{"type":22,"value":7},"text",{"type":16,"tag":24,"props":25,"children":26},"blockquote",{},[27],{"type":16,"tag":28,"props":29,"children":30},"p",{},[31],{"type":22,"value":32},"翻译说明：源 PDF 共 21 页（第 1 页为会议封面\u002F版权页，第 2–15 页为正文，第 16–20 页为参考文献，第 21 页为空白）。本文按原文顺序翻译正文、图表说明、公式、代码、致谢和全部 76 条参考文献；引用编号保持不变。",{"type":16,"tag":28,"props":34,"children":35},{},[36],{"type":22,"value":37},"马丁·阿巴迪、保罗·巴勒姆、简敏·陈、志峰·陈、安迪·戴维斯、杰弗里·迪恩、马蒂厄·德温、桑杰·格玛瓦特、杰弗里·欧文、迈克尔·伊萨德、曼努吉·库德勒、乔什·莱文伯格、拉贾特·蒙加、雪莉·摩尔、德里克·G·默里、贝努瓦·施泰纳、保罗·塔克、维杰·瓦苏代万、皮特·沃登、马丁·维克、袁宇、晓强·郑（Google Brain）",{"type":16,"tag":28,"props":39,"children":40},{},[41,43],{"type":22,"value":42},"论文发表于第 12 届 USENIX 操作系统设计与实现研讨会（OSDI ’16），2016 年 11 月 2–4 日，美国萨凡纳。原文软件地址：",{"type":16,"tag":44,"props":45,"children":49},"a",{"href":46,"rel":47},"https:\u002F\u002Ftensorflow.org%E3%80%82",[48],"nofollow",[50],{"type":22,"value":51},"https:\u002F\u002Ftensorflow.org。",{"type":16,"tag":28,"props":53,"children":54},{},[55],{"type":22,"value":56},"本文收录于第 12 届 USENIX 操作系统设计与实现研讨会论文集；论文集的开放获取由 USENIX 赞助。",{"type":16,"tag":58,"props":59,"children":61},"h2",{"id":60},"摘要",[62],{"type":22,"value":60},{"type":16,"tag":28,"props":64,"children":65},{},[66],{"type":22,"value":67},"TensorFlow 是一个面向大规模和异构环境运行的机器学习系统。TensorFlow 使用数据流图表示计算、共享状态以及修改这些状态的操作。它把数据流图中的节点映射到集群中的多台机器上，并在单台机器内映射到多种计算设备，包括多核 CPU、通用 GPU，以及称为张量处理单元（Tensor Processing Unit，TPU）的专用 ASIC。这种架构给应用开发者带来了灵活性：以往“参数服务器”架构把共享状态的管理固化在系统中，而 TensorFlow 允许开发者尝试新的优化和训练算法。",{"type":16,"tag":28,"props":69,"children":70},{},[71],{"type":22,"value":72},"TensorFlow 支持多种应用，重点是深度神经网络的训练和推理。Google 的多项服务已经在生产环境使用 TensorFlow；我们将其作为开源项目发布后，它也被机器学习研究广泛采用。本文介绍 TensorFlow 的数据流模型，并展示它在多个真实应用中取得的出色性能。",{"type":16,"tag":58,"props":74,"children":76},{"id":75},"_1-引言",[77],{"type":22,"value":78},"1 引言",{"type":16,"tag":28,"props":80,"children":81},{},[82],{"type":22,"value":83},"近年来，机器学习推动了许多领域的发展 [3, 5, 24, 25, 29, 31, 42, 47, 50, 52, 57, 67, 68, 72, 76]。我们将这种成功归因于几个因素：更复杂机器学习模型的发明 [44, 54]；用于解决这些领域问题的大规模数据集 [9, 64]；以及能够在这些数据集上训练模型、并方便地使用大量计算资源的软件平台 [14, 20]。",{"type":16,"tag":28,"props":85,"children":86},{},[87],{"type":22,"value":88},"我们开发 TensorFlow，是为了在大规模数据集上试验新模型、进行训练，并把模型部署到生产环境。这个系统建立在我们使用第一代系统 DistBelief [20] 多年的经验之上，同时对其进行了简化和泛化，使研究人员能够相对容易地探索更广泛的想法。TensorFlow 同时支持大规模训练和推理：它可以高效利用数百台带 GPU 的强大服务器进行快速训练，也可以在多种生产平台上运行训练好的模型，范围从数据中心的大型分布式集群一直到移动设备本地。与此同时，它保持了足够的灵活性，能够支持新机器学习模型和系统级优化的实验。",{"type":16,"tag":28,"props":90,"children":91},{},[92],{"type":22,"value":93},"TensorFlow 使用统一的数据流图表示算法中的计算以及算法所操作的状态。我们借鉴了数据流系统的高级编程模型 [2, 21, 34] 和参数服务器的底层效率 [14, 20, 49]。传统数据流系统中的图顶点表示在不可变数据上执行的函数式计算，而 TensorFlow 允许顶点表示拥有或更新可变状态的计算。边在节点之间传递张量（多维数组），TensorFlow 会透明地插入分布式子计算之间所需的通信。把计算与状态管理统一到同一种编程模型中，使程序员能够尝试不同的并行化方案，例如把计算卸载到保存共享状态的服务器上，从而减少网络流量。我们还构建了多种协调协议，并在同步复制方面取得了令人鼓舞的结果；这些结果与“可扩展学习必须使用异步复制”的传统看法相矛盾 [10, 18]。",{"type":16,"tag":28,"props":95,"children":96},{},[97],{"type":22,"value":98},"过去一年中，Google 有 150 多个团队使用了 TensorFlow，我们也将其发布为开源项目。¹ 通过庞大的用户社区，我们积累了不同机器学习应用的经验。本文把神经网络训练视为一个具有挑战性的系统问题，并从中选择两个有代表性的应用：图像分类和语言建模。这两个应用分别对计算吞吐量和模型总大小构成压力。我们用它们来展示 TensorFlow 的可扩展性，并评估当前实现的效率和可扩展能力。",{"type":16,"tag":28,"props":100,"children":101},{},[102,104],{"type":22,"value":103},"¹ 软件地址：",{"type":16,"tag":44,"props":105,"children":107},{"href":46,"rel":106},[48],[108],{"type":22,"value":51},{"type":16,"tag":58,"props":110,"children":112},{"id":111},"_2-背景与动机",[113],{"type":22,"value":114},"2 背景与动机",{"type":16,"tag":28,"props":116,"children":117},{},[118],{"type":22,"value":119},"我们首先描述之前系统的局限（§2.1），然后概述开发 TensorFlow 时采用的设计原则（§2.2）。",{"type":16,"tag":121,"props":122,"children":124},"h3",{"id":123},"_21-之前的系统distbelief",[125],{"type":22,"value":126},"2.1 之前的系统：DistBelief",{"type":16,"tag":28,"props":128,"children":129},{},[130],{"type":22,"value":131},"TensorFlow 是 DistBelief 的后继者。DistBelief 是 Google 自 2011 年起用于训练神经网络的分布式系统 [20]。DistBelief 使用参数服务器架构；下面我们批评这种架构在 DistBelief 中表现出的局限。不过，其他基于参数服务器的系统也以不同方式解决了这些局限 [11, 14, 49]；我们将在 §2.3 讨论这些系统。",{"type":16,"tag":28,"props":133,"children":134},{},[135],{"type":22,"value":136},"在参数服务器架构中，一个作业由两组互不相交的进程组成：无状态的 worker 进程执行训练模型时的大部分计算；有状态的参数服务器进程维护模型参数的当前版本。DistBelief 的编程模型与 Caffe [38] 类似：用户把神经网络定义为一个以损失函数结束的有向无环层图。一个层是数学运算符的组合。例如，全连接层把输入乘以权重矩阵，加上偏置向量，再对结果应用非线性函数（例如 sigmoid）。损失函数是一个标量函数，用于度量预测值（对于给定输入数据点）与真实标签之间的差异。在全连接层中，权重矩阵和偏置向量是参数，学习算法会更新它们，以最小化损失函数。DistBelief 利用 DAG 结构以及对层语义的了解，通过反向传播 [63] 计算模型中每个参数的梯度。由于许多算法中的参数更新具有交换性，且只要求较弱的一致性 [61]，worker 进程可以独立计算更新，然后把“增量”更新写回参数服务器，由参数服务器将更新与当前状态合并。",{"type":16,"tag":28,"props":138,"children":139},{},[140],{"type":22,"value":141},"尽管 DistBelief 让许多 Google 产品能够使用深度神经网络，并成为多个机器学习研究项目的基础，但我们很快感到它存在局限。它基于 Python 的脚本接口用于组合预定义层，对于需求简单的用户已经足够；然而，更高级的用户还需要三类灵活性：",{"type":16,"tag":28,"props":143,"children":144},{},[145,151],{"type":16,"tag":146,"props":147,"children":148},"strong",{},[149],{"type":22,"value":150},"定义新层。",{"type":22,"value":152}," 为了提高效率，我们把 DistBelief 的层实现为 C++ 类。使用另一种并不熟悉的语言来实现层，会阻碍机器学习研究人员试验新的层结构，例如 sampled softmax 分类器 [37] 和注意力模块 [53]。",{"type":16,"tag":28,"props":154,"children":155},{},[156,161],{"type":16,"tag":146,"props":157,"children":158},{},[159],{"type":22,"value":160},"改进训练算法。",{"type":22,"value":162}," 许多神经网络使用随机梯度下降（SGD）训练：算法迭代地沿着使损失函数下降最快的方向移动网络参数。SGD 的若干改进通过改变更新规则来加速收敛 [23, 66]。研究人员经常希望试验新的优化方法，但在 DistBelief 中这需要修改参数服务器实现。此外，参数服务器的 get()\u002Fput() 接口并不适合所有优化方法：有时必须原子地更新一组相关参数；很多情况下，把计算卸载到参数服务器上会更高效，因为这样可以减少网络流量。",{"type":16,"tag":28,"props":164,"children":165},{},[166,171],{"type":16,"tag":146,"props":167,"children":168},{},[169],{"type":22,"value":170},"定义新的训练算法。",{"type":22,"value":172}," DistBelief 的 worker 遵循固定执行模式：读取一批输入数据和当前参数值，计算损失函数（对网络做前向传播），计算各个参数的梯度（反向传播），再把梯度写回参数服务器。这个模式适用于简单的前馈神经网络，却无法处理更高级的模型，例如包含循环的循环神经网络 [39]；需要交替训练两个相关网络的对抗网络 [26]；以及损失函数由另一个系统中的智能体（如电子游戏模拟器）计算的强化学习模型 [54]。此外，还有许多不符合神经网络训练模式的机器学习算法——例如期望最大化、决策树训练和隐狄利克雷分配——它们同样可以从一个通用且优化良好的分布式运行时中受益。",{"type":16,"tag":28,"props":174,"children":175},{},[176],{"type":22,"value":177},"我们还把 DistBelief 设计成只面向一种平台：大规模的多核服务器分布式集群。当 GPU 加速对高效执行卷积核变得至关重要时 [44]，我们为 DistBelief 增加了 GPU 支持；但是 DistBelief 仍然是一个重量级系统，面向在海量数据集上训练深度神经网络，很难扩展到其他环境。许多用户希望先在带 GPU 的工作站上本地打磨模型，然后用同一份代码扩展到更大的数据集上训练。模型在集群上训练完成后，下一步通常是投入生产：可能是把模型集成到在线服务中，也可能是部署到移动设备进行离线执行。这些任务在计算结构上有共同点，但我们的同事发现，有必要使用或创建满足不同平台性能和资源要求的独立系统。TensorFlow 为所有这些环境提供了统一的编程模型和运行时系统。",{"type":16,"tag":121,"props":179,"children":181},{"id":180},"_22-设计原则",[182],{"type":22,"value":183},"2.2 设计原则",{"type":16,"tag":28,"props":185,"children":186},{},[187],{"type":22,"value":188},"我们设计 TensorFlow 时，希望它比 DistBelief 灵活得多，同时保留满足 Google 生产机器学习工作负载的能力。TensorFlow 提供了简单的、基于数据流的编程抽象，使用户可以把应用部署到分布式集群、本地工作站、移动设备和专用加速器上。一个高级脚本接口（图 1）封装了数据流图的构建，用户可以试验不同的模型结构和优化算法，而无需修改核心系统。本小节简要介绍 TensorFlow 的核心设计原则。",{"type":16,"tag":28,"props":190,"children":191},{},[192,197],{"type":16,"tag":146,"props":193,"children":194},{},[195],{"type":22,"value":196},"由基本运算符构成的数据流图。",{"type":22,"value":198}," TensorFlow 和 DistBelief 都用数据流表示模型，但最显著的差异在于：DistBelief 模型由少量复杂的“层”组成，而对应的 TensorFlow 模型把单个数学运算符（例如矩阵乘法、卷积等）作为数据流图中的节点。这种方式让用户更容易通过高级脚本接口组合出新层。许多优化算法要求每一层都定义梯度；用简单运算符构建层，可以自动对模型求导（§4.1）。除了函数式运算符外，我们还把可变状态及更新状态的操作表示为数据流图节点，从而可以试验不同的更新规则。",{"type":16,"tag":28,"props":200,"children":201},{},[202,207],{"type":16,"tag":146,"props":203,"children":204},{},[205],{"type":22,"value":206},"延迟执行。",{"type":22,"value":208}," 一个典型的 TensorFlow 应用有两个不同阶段：第一阶段把程序（例如要训练的神经网络及其更新规则）定义成符号数据流图，其中包含输入数据的占位符和表示状态的变量；第二阶段在一组可用设备上执行程序的优化版本。把执行延迟到整个程序都可用后，TensorFlow 可以利用关于计算的全局信息优化执行。例如，TensorFlow 利用图的依赖关系向 GPU 发出一连串内核，在等待中间结果之前继续发射，从而实现较高的 GPU 利用率。这个设计选择也意味着，我们必须把动态控制流等更复杂特性（§3.4）放入数据流图中，使使用这些特性的模型同样受益于这些优化。",{"type":16,"tag":28,"props":210,"children":211},{},[212,217],{"type":16,"tag":146,"props":213,"children":214},{},[215],{"type":22,"value":216},"异构加速器的统一抽象。",{"type":22,"value":218}," 除多核 CPU、GPU 等通用设备外，深度学习专用加速器也能显著提升性能并降低功耗。在 Google，我们的同事专门为机器学习构建了张量处理单元（TPU）；与当时其他先进技术相比，TPU 的每瓦性能提高了一个数量级 [40]。为了在 TensorFlow 中支持这些加速器，我们定义了统一的设备抽象。设备至少必须实现以下方法：（i）发出内核执行请求；（ii）为输入和输出分配内存；（iii）在主机内存与设备之间传输缓冲区。每个运算符（例如矩阵乘法）可以为不同设备提供多个专门实现。因此，同一程序可以根据训练、服务和离线推理的需要，轻松地面向 GPU、TPU 或移动 CPU。",{"type":16,"tag":28,"props":220,"children":221},{},[222],{"type":22,"value":223},"TensorFlow 使用基本类型值组成的张量作为所有设备都能理解的通用交换格式。在最低层，TensorFlow 中的所有张量都是稠密的；稀疏张量可以用稠密张量表示（§3.1）。这一决定让系统底层的内存分配和序列化实现保持简单，从而减少框架开销。张量还支持其他内存管理和通信优化，例如 RDMA 以及 GPU 到 GPU 的直接传输。",{"type":16,"tag":28,"props":225,"children":226},{},[227],{"type":22,"value":228},"这些原则的主要结果是：TensorFlow 中不存在所谓的参数服务器。在集群上，我们把 TensorFlow 部署为一组 task（能够通过网络通信的进程）；每个 task 都导出相同的图执行 API，并包含一个或多个设备。通常，一部分 task 承担其他系统中参数服务器的角色 [11, 14, 20, 49]，因此称为 PS task；其余 task 称为 worker task。不过，由于 PS task 能够运行任意 TensorFlow 图，它比传统参数服务器更灵活：用户可以用定义模型时使用的同一个脚本接口对它进行编程。这种灵活性是 TensorFlow 与当时系统之间的关键差异；本文后面将讨论这种灵活性带来的应用。",{"type":16,"tag":121,"props":230,"children":232},{"id":231},"_23-相关工作",[233],{"type":22,"value":234},"2.3 相关工作",{"type":16,"tag":28,"props":236,"children":237},{},[238,243],{"type":16,"tag":146,"props":239,"children":240},{},[241],{"type":22,"value":242},"单机框架。",{"type":22,"value":244}," 许多机器学习研究人员在单台（通常带 GPU 的）计算机上开展工作 [43, 44]，有多个单机框架支持这种场景。Caffe [38] 是一个高性能框架，用于在多核 CPU 和 GPU 上训练以声明方式指定的神经网络。如 §2.1 所述，它的编程模型与 DistBelief 相似，因此可以很容易地用已有层组合模型，但添加新层或新优化器相对困难。Theano [2] 允许程序员把模型表示为由基本运算符组成的数据流图，并生成训练该模型的高效编译代码。它的编程模型与 TensorFlow 最接近，在单机环境中也提供了类似的灵活性。",{"type":16,"tag":28,"props":246,"children":247},{},[248],{"type":22,"value":249},"与 Caffe、Theano 和 TensorFlow 不同，Torch [17] 为科学计算和机器学习提供了强大的命令式编程模型。它允许细粒度地控制执行顺序和内存使用，使高级用户可以优化程序性能。这种灵活性对研究很有用，但 Torch 缺少数据流图作为一种可移植表示所带来的优势，因而无法自然地贯穿小规模实验、生产训练和部署。",{"type":16,"tag":28,"props":251,"children":252},{},[253,258],{"type":16,"tag":146,"props":254,"children":255},{},[256],{"type":22,"value":257},"批处理数据流系统。",{"type":22,"value":259}," 从 MapReduce [21] 开始，批处理数据流系统被应用于大量机器学习算法 [70]；较新的系统则侧重于提高表达能力和性能。DryadLINQ [74] 增加了高级查询语言，支持比 MapReduce 更复杂的算法。Spark [75] 在 DryadLINQ 的基础上增加了把已经计算出的数据集缓存到内存中的能力，因此当输入数据能放入内存时，更适合迭代式机器学习算法（例如 k-means 聚类和逻辑回归）。Dandelion 为 DryadLINQ 增加了针对 GPU [62] 和 FPGA [16] 的代码生成能力。",{"type":16,"tag":28,"props":261,"children":262},{},[263],{"type":22,"value":264},"批处理数据流系统的主要局限是：它要求输入数据不可变，并且所有子计算都必须是确定性的，这样系统才能在集群机器发生故障时重新执行子计算。对于很多传统工作负载，这个特性很有益；但它让更新机器学习模型变得昂贵。例如，Spark 上的深度神经网络训练系统 SparkNet 每次向五个 worker 广播权重并收集更新需要 20 秒 [55]。因此，这类系统中的每一步模型更新都必须处理更大的批次，从而减慢收敛 [8]。我们在 §6.3 中展示，TensorFlow 可以在更大的集群上训练更大的模型，步时间最低可达 2 秒。",{"type":16,"tag":28,"props":266,"children":267},{},[268,273],{"type":16,"tag":146,"props":269,"children":270},{},[271],{"type":22,"value":272},"参数服务器。",{"type":22,"value":274}," 如 §2.1 所述，参数服务器架构使用一组服务器管理共享状态，多个并行 worker 对其进行更新。这种架构源自可扩展主题模型的研究 [65]；DistBelief 说明它可以用于深度神经网络训练。Project Adam [14] 进一步使用该架构高效训练卷积神经网络；Li 等人的“Parameter Server”[49] 在一致性模型、容错和弹性扩展方面进行了创新。尽管早期有人怀疑参数服务器与 GPU 加速不兼容 [14]，Cui 等人最近表明，专门面向 GPU 的参数服务器可以在小型集群上获得加速 [18]。",{"type":16,"tag":28,"props":276,"children":277},{},[278],{"type":22,"value":279},"MXNet [11] 也许是设计上与 TensorFlow 最接近的系统。它使用数据流图表示每个 worker 上的计算，并使用参数服务器扩展到多台机器。MXNet 参数服务器导出键值存储接口，支持聚合 worker 中多个设备发来的更新，并使用任意用户提供的函数把传入更新与当前值合并。MXNet 的键值存储接口 [22] 目前不允许在单个值内进行稀疏梯度更新，而这对于大模型分布式训练至关重要（§4.2）；增加该功能需要修改核心系统。",{"type":16,"tag":28,"props":281,"children":282},{},[283],{"type":22,"value":284},"参数服务器架构满足了我们的许多要求；只要投入足够的工程工作，就可以把本文描述的大部分功能加入参数服务器。不过，在设计 TensorFlow 时，我们寻找的是一种高级编程模型，让用户能够定制系统各个部分中运行的代码，从而降低试验新优化算法和模型结构的成本。下一节将更详细地介绍 TensorFlow 程序的构件。",{"type":16,"tag":58,"props":286,"children":288},{"id":287},"_3-tensorflow-执行模型",[289],{"type":22,"value":290},"3 TensorFlow 执行模型",{"type":16,"tag":28,"props":292,"children":293},{},[294],{"type":22,"value":295},"TensorFlow 使用单个数据流图表示机器学习算法中的全部计算和状态，包括单个数学运算、参数及参数更新规则，以及输入预处理（图 2）。数据流图显式表达子计算之间的通信，因此可以很容易地并行执行相互独立的计算，并把计算划分到多个设备上。TensorFlow 与批处理数据流系统（§2.3）有两点不同：",{"type":16,"tag":297,"props":298,"children":299},"ul",{},[300,306],{"type":16,"tag":301,"props":302,"children":303},"li",{},[304],{"type":22,"value":305},"模型支持在整个图的重叠子图上进行多次并发执行。",{"type":16,"tag":301,"props":307,"children":308},{},[309],{"type":22,"value":310},"单个顶点可以包含可变状态，并可在图的不同执行之间共享。",{"type":16,"tag":28,"props":312,"children":313},{},[314],{"type":22,"value":315},"参数服务器架构 [14, 20, 49] 的关键观察是：训练超大模型时，可变状态至关重要，因为它可以对超大参数进行原地更新，并尽快把更新传播到并行训练步骤。带可变状态的数据流让 TensorFlow 能够模拟参数服务器的功能，同时提供额外灵活性：可以在保存共享模型参数的机器上执行任意数据流子图。因此，用户能够试验不同的优化算法、一致性方案和并行化策略。",{"type":16,"tag":121,"props":317,"children":319},{"id":318},"图-1使用-tensorflow-python-api-编写的图像分类器",[320],{"type":22,"value":321},"图 1：使用 TensorFlow Python API 编写的图像分类器",{"type":16,"tag":28,"props":323,"children":324},{},[325],{"type":16,"tag":326,"props":327,"children":332},"img",{"alt":328,"src":329,"width":330,"height":331},"TensorFlow Python API 图像分类器（原文图 1）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-01.webp",1975,1012,[],{"type":16,"tag":28,"props":334,"children":335},{},[336],{"type":22,"value":337},"该程序是 MNIST 手写数字分类问题 [48] 的简单解决方案，输入为 784 像素图像，输出为 10 个类别。",{"type":16,"tag":339,"props":340,"children":346},"pre",{"className":341,"code":342,"language":343,"meta":344,"style":345},"language-python","# 1. 构造表示模型的图。\nx = tf.placeholder(tf.float32, [BATCH_SIZE, 784])                     # 输入占位符。\ny = tf.placeholder(tf.float32, [BATCH_SIZE, 10])                      # 标签占位符。\n\nW_1 = tf.Variable(tf.random_uniform([784, 100]))                      # 784x100 权重矩阵。\nb_1 = tf.Variable(tf.zeros([100]))                                    # 100 元素偏置向量。\nlayer_1 = tf.nn.relu(tf.matmul(x, W_1) + b_2)                         # 隐藏层输出。\n\nW_2 = tf.Variable(tf.random_uniform([100, 10]))                       # 100x10 权重矩阵。\nb_2 = tf.Variable(tf.zeros([10]))                                     # 10 元素偏置向量。\nlayer_2 = tf.matmul(layer_1, W_2) + b_2                               # 线性层输出。\n\n# 2. 添加表示优化算法的节点。\nloss = tf.nn.softmax_cross_entropy_with_logits(layer_2, y)\ntrain_op = tf.train.AdagradOptimizer(0.01).minimize(loss)\n\n# 3. 在输入数据批次上执行图。\nwith tf.Session() as sess:                                            # 连接到 TensorFlow 运行时。\n  sess.run(tf.initialize_all_variables())                             # 随机初始化权重。\n  for step in range(NUM_STEPS):                                       # 迭代 NUM_STEPS 次训练。\n    x_data, y_data = ...                                              # 加载一批输入数据。\n    sess.run(train_op, {x: x_data, y: y_data})                        # 执行一次训练步骤。\n","python","","undefined",[347],{"type":16,"tag":348,"props":349,"children":350},"code",{"__ignoreMap":344},[351],{"type":22,"value":342},{"type":16,"tag":28,"props":353,"children":354},{},[355],{"type":22,"value":356},"图 2 给出了一个典型训练应用的数据流图，其中有多个并发执行并通过共享变量和队列交互的子图。核心训练子图依赖一组模型参数以及来自队列的输入批次。训练子图的多个并发步骤根据不同输入批次更新模型，从而实现数据并行训练。为了填充输入队列，并发的预处理步骤会变换单条输入记录（例如解码图像并施加随机失真）；独立的 I\u002FO 子图从分布式文件系统中读取记录。检查点子图会定期运行，以提供容错能力（§4.3）。",{"type":16,"tag":58,"props":358,"children":360},{"id":359},"图-2训练流水线的数据流图",[361],{"type":22,"value":362},"图 2：训练流水线的数据流图",{"type":16,"tag":28,"props":364,"children":365},{},[366],{"type":16,"tag":326,"props":367,"children":372},{"alt":368,"src":369,"width":370,"height":371},"训练流水线的数据流图（原文图 2）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-02.webp",1946,413,[],{"type":16,"tag":28,"props":374,"children":375},{},[376,378,384,386,392,393,399,400,406,407,413,414,420,422,428,429,435,436,442,443,449,450,456,457,463,464,470,471,477,478,484,485,491],{"type":22,"value":377},"该图包含读取输入数据、预处理、训练和检查点状态等子图。图中的 ",{"type":16,"tag":348,"props":379,"children":381},{"className":380},[],[382],{"type":22,"value":383},"Input data",{"type":22,"value":385},"、",{"type":16,"tag":348,"props":387,"children":389},{"className":388},[],[390],{"type":22,"value":391},"Reader",{"type":22,"value":385},{"type":16,"tag":348,"props":394,"children":396},{"className":395},[],[397],{"type":22,"value":398},"Preprocessing",{"type":22,"value":385},{"type":16,"tag":348,"props":401,"children":403},{"className":402},[],[404],{"type":22,"value":405},"Training",{"type":22,"value":385},{"type":16,"tag":348,"props":408,"children":410},{"className":409},[],[411],{"type":22,"value":412},"Periodic checkpoint",{"type":22,"value":385},{"type":16,"tag":348,"props":415,"children":417},{"className":416},[],[418],{"type":22,"value":419},"Dist. FS",{"type":22,"value":421}," 等标签分别表示输入数据、读取器、预处理、训练、周期性检查点和分布式文件系统；",{"type":16,"tag":348,"props":423,"children":425},{"className":424},[],[426],{"type":22,"value":427},"Queue",{"type":22,"value":385},{"type":16,"tag":348,"props":430,"children":432},{"className":431},[],[433],{"type":22,"value":434},"Parameters",{"type":22,"value":385},{"type":16,"tag":348,"props":437,"children":439},{"className":438},[],[440],{"type":22,"value":441},"Read params",{"type":22,"value":385},{"type":16,"tag":348,"props":444,"children":446},{"className":445},[],[447],{"type":22,"value":448},"Apply grads",{"type":22,"value":385},{"type":16,"tag":348,"props":451,"children":453},{"className":452},[],[454],{"type":22,"value":455},"Fwd",{"type":22,"value":385},{"type":16,"tag":348,"props":458,"children":460},{"className":459},[],[461],{"type":22,"value":462},"Back",{"type":22,"value":385},{"type":16,"tag":348,"props":465,"children":467},{"className":466},[],[468],{"type":22,"value":469},"Mod",{"type":22,"value":385},{"type":16,"tag":348,"props":472,"children":474},{"className":473},[],[475],{"type":22,"value":476},"Part",{"type":22,"value":385},{"type":16,"tag":348,"props":479,"children":481},{"className":480},[],[482],{"type":22,"value":483},"Stitch",{"type":22,"value":385},{"type":16,"tag":348,"props":486,"children":488},{"className":487},[],[489],{"type":22,"value":490},"Sum",{"type":22,"value":492}," 等为相应操作或张量。",{"type":16,"tag":121,"props":494,"children":496},{"id":495},"_31-数据流图元素",[497],{"type":22,"value":498},"3.1 数据流图元素",{"type":16,"tag":28,"props":500,"children":501},{},[502,504,509,511,516],{"type":22,"value":503},"在 TensorFlow 图中，每个顶点表示一个本地计算单元，每条边表示顶点的输出或输入。我们把顶点处的计算称为",{"type":16,"tag":146,"props":505,"children":506},{},[507],{"type":22,"value":508},"操作",{"type":22,"value":510},"，沿边流动的值称为",{"type":16,"tag":146,"props":512,"children":513},{},[514],{"type":22,"value":515},"张量",{"type":22,"value":517},"。本小节介绍常见的操作和张量类型。",{"type":16,"tag":28,"props":519,"children":520},{},[521,526,528,534,535,541,543,549,551,556],{"type":16,"tag":146,"props":522,"children":523},{},[524],{"type":22,"value":525},"张量。",{"type":22,"value":527}," 在 TensorFlow 中，所有数据都建模为张量（n 维数组），元素采用少数几种基本类型之一，例如 ",{"type":16,"tag":348,"props":529,"children":531},{"className":530},[],[532],{"type":22,"value":533},"int32",{"type":22,"value":385},{"type":16,"tag":348,"props":536,"children":538},{"className":537},[],[539],{"type":22,"value":540},"float32",{"type":22,"value":542}," 或 ",{"type":16,"tag":348,"props":544,"children":546},{"className":545},[],[547],{"type":22,"value":548},"string",{"type":22,"value":550},"（其中 ",{"type":16,"tag":348,"props":552,"children":554},{"className":553},[],[555],{"type":22,"value":548},{"type":22,"value":557}," 可以表示任意二进制数据）。张量自然地表示许多机器学习算法中常见数学运算的输入和结果：例如，矩阵乘法接收两个二维张量并生成一个二维张量；批量二维卷积接收两个四维张量并生成另一个四维张量。",{"type":16,"tag":28,"props":559,"children":560},{},[561],{"type":22,"value":562},"在最低层，所有 TensorFlow 张量都是稠密的，原因见 §2.2。TensorFlow 提供两种表示稀疏数据的替代方式：要么把数据编码成稠密张量中的变长字符串元素，要么使用稠密张量的元组。例如，一个有 m 个非零元素的 n 维稀疏张量，可以用坐标列表格式表示为一个 m×n 的坐标矩阵和一个长度为 m 的值向量。张量的形状可以在一个或多个维度上变化，因此能够表示元素数量不同的稀疏张量。",{"type":16,"tag":28,"props":564,"children":565},{},[566,571,573,676,678,756,758,764,765,771,772,778],{"type":16,"tag":146,"props":567,"children":568},{},[569],{"type":22,"value":570},"操作。",{"type":22,"value":572}," 一个操作接收 ",{"type":16,"tag":574,"props":575,"children":578},"span",{"className":576},[577],"katex",[579,622],{"type":16,"tag":574,"props":580,"children":583},{"className":581},[582],"katex-mathml",[584],{"type":16,"tag":585,"props":586,"children":588},"math",{"xmlns":587},"http:\u002F\u002Fwww.w3.org\u002F1998\u002FMath\u002FMathML",[589],{"type":16,"tag":590,"props":591,"children":592},"semantics",{},[593,615],{"type":16,"tag":594,"props":595,"children":596},"mrow",{},[597,603,609],{"type":16,"tag":598,"props":599,"children":600},"mi",{},[601],{"type":22,"value":602},"m",{"type":16,"tag":604,"props":605,"children":606},"mo",{},[607],{"type":22,"value":608},"≥",{"type":16,"tag":610,"props":611,"children":612},"mn",{},[613],{"type":22,"value":614},"0",{"type":16,"tag":616,"props":617,"children":619},"annotation",{"encoding":618},"application\u002Fx-tex",[620],{"type":22,"value":621},"m \\ge 0",{"type":16,"tag":574,"props":623,"children":627},{"className":624,"ariaHidden":626},[625],"katex-html","true",[628,662],{"type":16,"tag":574,"props":629,"children":632},{"className":630},[631],"base",[633,639,646,652,658],{"type":16,"tag":574,"props":634,"children":638},{"className":635,"style":637},[636],"strut","height:0.7719em;vertical-align:-0.136em;",[],{"type":16,"tag":574,"props":640,"children":644},{"className":641},[642,643],"mord","mathnormal",[645],{"type":22,"value":602},{"type":16,"tag":574,"props":647,"children":651},{"className":648,"style":650},[649],"mspace","margin-right:0.2778em;",[],{"type":16,"tag":574,"props":653,"children":656},{"className":654},[655],"mrel",[657],{"type":22,"value":608},{"type":16,"tag":574,"props":659,"children":661},{"className":660,"style":650},[649],[],{"type":16,"tag":574,"props":663,"children":665},{"className":664},[631],[666,671],{"type":16,"tag":574,"props":667,"children":670},{"className":668,"style":669},[636],"height:0.6444em;",[],{"type":16,"tag":574,"props":672,"children":674},{"className":673},[642],[675],{"type":22,"value":614},{"type":22,"value":677}," 个张量作为输入，并产生 ",{"type":16,"tag":574,"props":679,"children":681},{"className":680},[577],[682,713],{"type":16,"tag":574,"props":683,"children":685},{"className":684},[582],[686],{"type":16,"tag":585,"props":687,"children":688},{"xmlns":587},[689],{"type":16,"tag":590,"props":690,"children":691},{},[692,708],{"type":16,"tag":594,"props":693,"children":694},{},[695,700,704],{"type":16,"tag":598,"props":696,"children":697},{},[698],{"type":22,"value":699},"n",{"type":16,"tag":604,"props":701,"children":702},{},[703],{"type":22,"value":608},{"type":16,"tag":610,"props":705,"children":706},{},[707],{"type":22,"value":614},{"type":16,"tag":616,"props":709,"children":710},{"encoding":618},[711],{"type":22,"value":712},"n \\ge 0",{"type":16,"tag":574,"props":714,"children":716},{"className":715,"ariaHidden":626},[625],[717,743],{"type":16,"tag":574,"props":718,"children":720},{"className":719},[631],[721,725,730,734,739],{"type":16,"tag":574,"props":722,"children":724},{"className":723,"style":637},[636],[],{"type":16,"tag":574,"props":726,"children":728},{"className":727},[642,643],[729],{"type":22,"value":699},{"type":16,"tag":574,"props":731,"children":733},{"className":732,"style":650},[649],[],{"type":16,"tag":574,"props":735,"children":737},{"className":736},[655],[738],{"type":22,"value":608},{"type":16,"tag":574,"props":740,"children":742},{"className":741,"style":650},[649],[],{"type":16,"tag":574,"props":744,"children":746},{"className":745},[631],[747,751],{"type":16,"tag":574,"props":748,"children":750},{"className":749,"style":669},[636],[],{"type":16,"tag":574,"props":752,"children":754},{"className":753},[642],[755],{"type":22,"value":614},{"type":22,"value":757}," 个张量作为输出。操作有一个命名的“类型”（例如 ",{"type":16,"tag":348,"props":759,"children":761},{"className":760},[],[762],{"type":22,"value":763},"Const",{"type":22,"value":385},{"type":16,"tag":348,"props":766,"children":768},{"className":767},[],[769],{"type":22,"value":770},"MatMul",{"type":22,"value":542},{"type":16,"tag":348,"props":773,"children":775},{"className":774},[],[776],{"type":22,"value":777},"Assign",{"type":22,"value":779},"），还可以有零个或多个在编译时确定行为的属性。操作可以在编译时具有多态性和可变参数个数：其属性决定输入和输出的类型以及数量。",{"type":16,"tag":28,"props":781,"children":782},{},[783,785,790,792,798,800,806,808,814],{"type":22,"value":784},"例如，最简单的操作 ",{"type":16,"tag":348,"props":786,"children":788},{"className":787},[],[789],{"type":22,"value":763},{"type":22,"value":791}," 没有输入且只有一个输出；它的值是一个编译时属性。",{"type":16,"tag":348,"props":793,"children":795},{"className":794},[],[796],{"type":22,"value":797},"AddN",{"type":22,"value":799}," 对多个元素类型相同的张量求和，它有一个类型属性 ",{"type":16,"tag":348,"props":801,"children":803},{"className":802},[],[804],{"type":22,"value":805},"T",{"type":22,"value":807}," 和一个整数属性 ",{"type":16,"tag":348,"props":809,"children":811},{"className":810},[],[812],{"type":22,"value":813},"N",{"type":22,"value":815},"，共同定义其类型签名。",{"type":16,"tag":28,"props":817,"children":818},{},[819,824,826,832,834,839,841,847,849,855,857,863,865,871,873,878,880,886],{"type":16,"tag":146,"props":820,"children":821},{},[822],{"type":22,"value":823},"有状态操作：变量。",{"type":22,"value":825}," 每次执行操作时，它都可以读取或写入可变状态。",{"type":16,"tag":348,"props":827,"children":829},{"className":828},[],[830],{"type":22,"value":831},"Variable",{"type":22,"value":833}," 操作拥有一个可变缓冲区，可以在训练模型时存储共享参数。",{"type":16,"tag":348,"props":835,"children":837},{"className":836},[],[838],{"type":22,"value":831},{"type":22,"value":840}," 没有输入，并产生一个引用句柄；这个句柄是一种带类型的能力，用来读取和写入缓冲区。",{"type":16,"tag":348,"props":842,"children":844},{"className":843},[],[845],{"type":22,"value":846},"Read",{"type":22,"value":848}," 操作接收引用句柄 ",{"type":16,"tag":348,"props":850,"children":852},{"className":851},[],[853],{"type":22,"value":854},"r",{"type":22,"value":856},"，并把变量的值 ",{"type":16,"tag":348,"props":858,"children":860},{"className":859},[],[861],{"type":22,"value":862},"State[r]",{"type":22,"value":864}," 作为稠密张量输出。其他操作会修改底层缓冲区。例如，",{"type":16,"tag":348,"props":866,"children":868},{"className":867},[],[869],{"type":22,"value":870},"AssignAdd",{"type":22,"value":872}," 接收引用句柄 ",{"type":16,"tag":348,"props":874,"children":876},{"className":875},[],[877],{"type":22,"value":854},{"type":22,"value":879}," 和张量值 ",{"type":16,"tag":348,"props":881,"children":883},{"className":882},[],[884],{"type":22,"value":885},"x",{"type":22,"value":887},"，执行时进行更新：",{"type":16,"tag":574,"props":889,"children":892},{"className":890},[891],"katex-display",[893],{"type":16,"tag":574,"props":894,"children":896},{"className":895},[577],[897,994],{"type":16,"tag":574,"props":898,"children":900},{"className":899},[582],[901],{"type":16,"tag":585,"props":902,"children":904},{"xmlns":587,"display":903},"block",[905],{"type":16,"tag":590,"props":906,"children":907},{},[908,989],{"type":16,"tag":594,"props":909,"children":910},{},[911,935,941,945,950,955,959,963,967,971,975,980,984],{"type":16,"tag":912,"props":913,"children":914},"msup",{},[915,929],{"type":16,"tag":594,"props":916,"children":917},{},[918,924],{"type":16,"tag":598,"props":919,"children":921},{"mathvariant":920},"normal",[922],{"type":22,"value":923},"State",{"type":16,"tag":604,"props":925,"children":926},{},[927],{"type":22,"value":928},"⁡",{"type":16,"tag":604,"props":930,"children":932},{"mathvariant":920,"lspace":931,"rspace":931},"0em",[933],{"type":22,"value":934},"′",{"type":16,"tag":604,"props":936,"children":938},{"stretchy":937},"false",[939],{"type":22,"value":940},"[",{"type":16,"tag":598,"props":942,"children":943},{},[944],{"type":22,"value":854},{"type":16,"tag":604,"props":946,"children":947},{"stretchy":937},[948],{"type":22,"value":949},"]",{"type":16,"tag":604,"props":951,"children":952},{},[953],{"type":22,"value":954},"←",{"type":16,"tag":598,"props":956,"children":957},{"mathvariant":920},[958],{"type":22,"value":923},{"type":16,"tag":604,"props":960,"children":961},{},[962],{"type":22,"value":928},{"type":16,"tag":604,"props":964,"children":965},{"stretchy":937},[966],{"type":22,"value":940},{"type":16,"tag":598,"props":968,"children":969},{},[970],{"type":22,"value":854},{"type":16,"tag":604,"props":972,"children":973},{"stretchy":937},[974],{"type":22,"value":949},{"type":16,"tag":604,"props":976,"children":977},{},[978],{"type":22,"value":979},"+",{"type":16,"tag":598,"props":981,"children":982},{},[983],{"type":22,"value":885},{"type":16,"tag":598,"props":985,"children":986},{"mathvariant":920},[987],{"type":22,"value":988},".",{"type":16,"tag":616,"props":990,"children":991},{"encoding":618},[992],{"type":22,"value":993},"\\operatorname{State}'[r] \\leftarrow \\operatorname{State}[r] + x.",{"type":16,"tag":574,"props":995,"children":997},{"className":996,"ariaHidden":626},[625],[998,1101,1149],{"type":16,"tag":574,"props":999,"children":1001},{"className":1000},[631],[1002,1007,1070,1076,1082,1088,1092,1097],{"type":16,"tag":574,"props":1003,"children":1006},{"className":1004,"style":1005},[636],"height:1.0751em;vertical-align:-0.25em;",[],{"type":16,"tag":574,"props":1008,"children":1011},{"className":1009},[1010],"mop",[1012,1022],{"type":16,"tag":574,"props":1013,"children":1015},{"className":1014},[1010],[1016],{"type":16,"tag":574,"props":1017,"children":1020},{"className":1018},[642,1019],"mathrm",[1021],{"type":22,"value":923},{"type":16,"tag":574,"props":1023,"children":1026},{"className":1024},[1025],"msupsub",[1027],{"type":16,"tag":574,"props":1028,"children":1031},{"className":1029},[1030],"vlist-t",[1032],{"type":16,"tag":574,"props":1033,"children":1036},{"className":1034},[1035],"vlist-r",[1037],{"type":16,"tag":574,"props":1038,"children":1042},{"className":1039,"style":1041},[1040],"vlist","height:0.8251em;",[1043],{"type":16,"tag":574,"props":1044,"children":1046},{"style":1045},"top:-3.1362em;margin-right:0.05em;",[1047,1053],{"type":16,"tag":574,"props":1048,"children":1052},{"className":1049,"style":1051},[1050],"pstrut","height:2.7em;",[],{"type":16,"tag":574,"props":1054,"children":1060},{"className":1055},[1056,1057,1058,1059],"sizing","reset-size6","size3","mtight",[1061],{"type":16,"tag":574,"props":1062,"children":1064},{"className":1063},[642,1059],[1065],{"type":16,"tag":574,"props":1066,"children":1068},{"className":1067},[642,1059],[1069],{"type":22,"value":934},{"type":16,"tag":574,"props":1071,"children":1074},{"className":1072},[1073],"mopen",[1075],{"type":22,"value":940},{"type":16,"tag":574,"props":1077,"children":1080},{"className":1078,"style":1079},[642,643],"margin-right:0.0278em;",[1081],{"type":22,"value":854},{"type":16,"tag":574,"props":1083,"children":1086},{"className":1084},[1085],"mclose",[1087],{"type":22,"value":949},{"type":16,"tag":574,"props":1089,"children":1091},{"className":1090,"style":650},[649],[],{"type":16,"tag":574,"props":1093,"children":1095},{"className":1094},[655],[1096],{"type":22,"value":954},{"type":16,"tag":574,"props":1098,"children":1100},{"className":1099,"style":650},[649],[],{"type":16,"tag":574,"props":1102,"children":1104},{"className":1103},[631],[1105,1110,1119,1124,1129,1134,1139,1145],{"type":16,"tag":574,"props":1106,"children":1109},{"className":1107,"style":1108},[636],"height:1em;vertical-align:-0.25em;",[],{"type":16,"tag":574,"props":1111,"children":1113},{"className":1112},[1010],[1114],{"type":16,"tag":574,"props":1115,"children":1117},{"className":1116},[642,1019],[1118],{"type":22,"value":923},{"type":16,"tag":574,"props":1120,"children":1122},{"className":1121},[1073],[1123],{"type":22,"value":940},{"type":16,"tag":574,"props":1125,"children":1127},{"className":1126,"style":1079},[642,643],[1128],{"type":22,"value":854},{"type":16,"tag":574,"props":1130,"children":1132},{"className":1131},[1085],[1133],{"type":22,"value":949},{"type":16,"tag":574,"props":1135,"children":1138},{"className":1136,"style":1137},[649],"margin-right:0.2222em;",[],{"type":16,"tag":574,"props":1140,"children":1143},{"className":1141},[1142],"mbin",[1144],{"type":22,"value":979},{"type":16,"tag":574,"props":1146,"children":1148},{"className":1147,"style":1137},[649],[],{"type":16,"tag":574,"props":1150,"children":1152},{"className":1151},[631],[1153,1158,1163],{"type":16,"tag":574,"props":1154,"children":1157},{"className":1155,"style":1156},[636],"height:0.4306em;",[],{"type":16,"tag":574,"props":1159,"children":1161},{"className":1160},[642,643],[1162],{"type":22,"value":885},{"type":16,"tag":574,"props":1164,"children":1166},{"className":1165},[642],[1167],{"type":22,"value":988},{"type":16,"tag":28,"props":1169,"children":1170},{},[1171,1173,1179,1181,1187],{"type":22,"value":1172},"后续的 ",{"type":16,"tag":348,"props":1174,"children":1176},{"className":1175},[],[1177],{"type":22,"value":1178},"Read(r)",{"type":22,"value":1180}," 操作将产生值 ",{"type":16,"tag":348,"props":1182,"children":1184},{"className":1183},[],[1185],{"type":22,"value":1186},"State'[r]",{"type":22,"value":1188},"。",{"type":16,"tag":28,"props":1190,"children":1191},{},[1192,1197,1199,1205,1207,1212,1214,1219,1221,1227,1229,1235,1237,1242,1244,1249,1251,1256,1258,1263],{"type":16,"tag":146,"props":1193,"children":1194},{},[1195],{"type":22,"value":1196},"有状态操作：队列。",{"type":22,"value":1198}," TensorFlow 包含多种队列实现，支持更高级的协调形式。最简单的队列是 ",{"type":16,"tag":348,"props":1200,"children":1202},{"className":1201},[],[1203],{"type":22,"value":1204},"FIFOQueue",{"type":22,"value":1206},"：它拥有一个内部张量队列，并按照先进先出顺序允许并发访问。其他队列类型按随机顺序或优先级顺序出队，从而保证以适当方式采样输入数据。与 ",{"type":16,"tag":348,"props":1208,"children":1210},{"className":1209},[],[1211],{"type":22,"value":831},{"type":22,"value":1213}," 类似，",{"type":16,"tag":348,"props":1215,"children":1217},{"className":1216},[],[1218],{"type":22,"value":1204},{"type":22,"value":1220}," 操作产生一个引用句柄；这个句柄可以被标准队列操作（例如 ",{"type":16,"tag":348,"props":1222,"children":1224},{"className":1223},[],[1225],{"type":22,"value":1226},"Enqueue",{"type":22,"value":1228}," 和 ",{"type":16,"tag":348,"props":1230,"children":1232},{"className":1231},[],[1233],{"type":22,"value":1234},"Dequeue",{"type":22,"value":1236},"）消费。",{"type":16,"tag":348,"props":1238,"children":1240},{"className":1239},[],[1241],{"type":22,"value":1226},{"type":22,"value":1243}," 把输入推入队列尾部，",{"type":16,"tag":348,"props":1245,"children":1247},{"className":1246},[],[1248],{"type":22,"value":1234},{"type":22,"value":1250}," 弹出队列头部元素并输出。当给定队列已满时，",{"type":16,"tag":348,"props":1252,"children":1254},{"className":1253},[],[1255],{"type":22,"value":1226},{"type":22,"value":1257}," 会阻塞；当队列为空时，",{"type":16,"tag":348,"props":1259,"children":1261},{"className":1260},[],[1262],{"type":22,"value":1234},{"type":22,"value":1264}," 会阻塞。",{"type":16,"tag":28,"props":1266,"children":1267},{},[1268],{"type":22,"value":1269},"在输入预处理流水线中使用队列时，这种阻塞提供了背压；它还支持同步（§4.4）。队列与动态控制流（§3.4）结合后，也可以在子图之间实现一种流式计算。",{"type":16,"tag":121,"props":1271,"children":1273},{"id":1272},"_32-部分执行与并发执行",[1274],{"type":22,"value":1275},"3.2 部分执行与并发执行",{"type":16,"tag":28,"props":1277,"children":1278},{},[1279,1281,1286],{"type":22,"value":1280},"TensorFlow 使用数据流图表示一个应用中所有可能的计算。执行图的 API 允许客户端以声明方式指定应执行的子图。客户端选择一条或多条边，把输入张量送入数据流；同时选择一条或多条边，从数据流中取出输出张量。运行时随后裁剪图，只保留必要的操作。API 的每次调用称为一个",{"type":16,"tag":146,"props":1282,"children":1283},{},[1284],{"type":22,"value":1285},"step",{"type":22,"value":1287},"，TensorFlow 支持在同一图上并发执行多个 step。有状态操作允许不同 step 在需要时共享数据并进行同步。",{"type":16,"tag":28,"props":1289,"children":1290},{},[1291],{"type":22,"value":1292},"部分执行和并发执行是 TensorFlow 灵活性的主要来源。通过在用户级代码中加入可变状态和利用队列进行协调，可以指定多种模型结构；高级用户无需修改 TensorFlow 运行时内部实现即可进行试验。默认情况下，TensorFlow 子图的并发执行彼此异步。这种异步性使实现具有弱一致性要求的机器学习算法变得直接 [61]，其中包括许多神经网络训练算法 [20]。如后文所述，TensorFlow 也提供了训练期间同步 worker 所需的原语（§4.4），并在一些学习任务上取得了有希望的结果（§6.3）。",{"type":16,"tag":121,"props":1294,"children":1296},{"id":1295},"_33-分布式执行",[1297],{"type":22,"value":1298},"3.3 分布式执行",{"type":16,"tag":28,"props":1300,"children":1301},{},[1302],{"type":22,"value":1303},"数据流使分布式执行变得简单，因为它显式表达了子计算之间的通信。同一个 TensorFlow 程序可以部署到 GPU 集群上进行训练、TPU 集群上提供服务，也可以部署到手机上进行移动推理。",{"type":16,"tag":28,"props":1305,"children":1306},{},[1307,1309,1315,1316,1322],{"type":22,"value":1308},"每个操作驻留在特定设备上，例如某个 task 中的 CPU 或 GPU。设备负责为分配给它的每个操作执行一个内核。TensorFlow 允许为单个操作注册多个内核，为特定设备或数据类型提供专门实现（详见 §5）。对于许多操作（例如逐元素运算 ",{"type":16,"tag":348,"props":1310,"children":1312},{"className":1311},[],[1313],{"type":22,"value":1314},"Add",{"type":22,"value":385},{"type":16,"tag":348,"props":1317,"children":1319},{"className":1318},[],[1320],{"type":22,"value":1321},"Sub",{"type":22,"value":1323}," 等），我们可以使用不同编译器为 CPU 和 GPU 编译同一个内核实现。",{"type":16,"tag":28,"props":1325,"children":1326},{},[1327],{"type":22,"value":1328},"TensorFlow 运行时会把操作放置到设备上，同时遵守图中的隐式或显式约束。放置算法为每个操作计算可行设备集合，计算必须放置在同一设备上的操作集合，并为每个共置组选择一个满足约束的设备。每个有状态操作及其状态必须位于同一设备上，这是算法必须遵守的隐式共置约束。此外，用户可以指定部分设备偏好，例如“某个 task 中的任意设备”或“任意 task 中的 GPU”，运行时会遵循这些约束。典型训练应用会使用客户端编程结构增加约束，例如把参数分布到一组“PS” task 上（§4.2）。",{"type":16,"tag":28,"props":1330,"children":1331},{},[1332],{"type":22,"value":1333},"因此，TensorFlow 允许以很大的灵活性把数据流图中的操作映射到设备上。简单启发式算法对普通用户可以提供足够性能；而专家用户则可以手动放置操作，在多个 task 之间以及每个 task 内的多个设备之间平衡计算、内存和网络需求。一个开放问题是：如何让 TensorFlow 自动确定给定设备集合上的近似最优放置，从而让用户无需处理这一问题。即使没有这种自动化，把放置指令与模型定义的其他部分分离也可能有价值，例如训练完模型后可以很容易地修改放置位置。",{"type":16,"tag":28,"props":1335,"children":1336},{},[1337,1339,1345,1346,1352,1354,1359,1361,1366,1368,1373,1374,1379],{"type":22,"value":1338},"图中的操作完成放置、并针对一个 step 计算出部分子图（§3.2）后，TensorFlow 会把操作划分为每个设备一个子图。设备 d 的子图包含所有分配给 d 的操作，并用额外的 ",{"type":16,"tag":348,"props":1340,"children":1342},{"className":1341},[],[1343],{"type":22,"value":1344},"Send",{"type":22,"value":1228},{"type":16,"tag":348,"props":1347,"children":1349},{"className":1348},[],[1350],{"type":22,"value":1351},"Recv",{"type":22,"value":1353}," 操作替换跨设备边。",{"type":16,"tag":348,"props":1355,"children":1357},{"className":1356},[],[1358],{"type":22,"value":1344},{"type":22,"value":1360}," 在张量可用时立即把其唯一输入传输到指定设备，并使用 rendezvous key 命名该值。",{"type":16,"tag":348,"props":1362,"children":1364},{"className":1363},[],[1365],{"type":22,"value":1351},{"type":22,"value":1367}," 有一个输出，在本地指定 rendezvous key 对应的值可用之前阻塞；值到达后，它才产生输出。",{"type":16,"tag":348,"props":1369,"children":1371},{"className":1370},[],[1372],{"type":22,"value":1344},{"type":22,"value":1228},{"type":16,"tag":348,"props":1375,"children":1377},{"className":1376},[],[1378],{"type":22,"value":1351},{"type":22,"value":1380}," 针对若干设备类型对有专门实现；第 5 节将介绍其中一些。",{"type":16,"tag":28,"props":1382,"children":1383},{},[1384],{"type":22,"value":1385},"我们针对低延迟、重复执行大型子图优化了 TensorFlow。一个 step 的图被裁剪、放置并分区后，其子图会缓存在相应设备上。客户端 session 维护 step 定义到缓存子图的映射，因此在大型图上启动一次分布式 step，只需向每个参与的 task 发送一条小消息。这种模型偏好静态、可复用的图，但通过动态控制流仍然能够支持动态计算，下一小节将对此进行说明。",{"type":16,"tag":121,"props":1387,"children":1389},{"id":1388},"_34-动态控制流",[1390],{"type":22,"value":1391},"3.4 动态控制流",{"type":16,"tag":28,"props":1393,"children":1394},{},[1395],{"type":22,"value":1396},"TensorFlow 支持包含条件和迭代控制流的高级机器学习算法。例如，循环神经网络（RNN）[39]，包括 LSTM [32]，可以根据序列数据生成预测。Google 的神经机器翻译系统使用 TensorFlow 训练深层 LSTM，在多个翻译任务上达到最先进性能 [73]。RNN 的核心是一个递推关系：序列元素 i 的输出是某种状态的函数，而该状态沿序列累积（图 3）。动态控制流使得模型能够遍历长度可变的序列，而无需把计算展开到最长序列的长度。",{"type":16,"tag":28,"props":1398,"children":1399},{},[1400,1402,1408,1409,1415,1416,1422],{"type":22,"value":1401},"如 §2.2 所述，TensorFlow 通过数据流图延迟执行，把更大的工作块卸载到加速器。因此，为了实现 RNN 和其他高级算法，我们把条件（if 语句）和迭代（while 循环）编程结构本身加入数据流图。我们利用这些原语构建 ",{"type":16,"tag":348,"props":1403,"children":1405},{"className":1404},[],[1406],{"type":22,"value":1407},"map()",{"type":22,"value":385},{"type":16,"tag":348,"props":1410,"children":1412},{"className":1411},[],[1413],{"type":22,"value":1414},"fold()",{"type":22,"value":1228},{"type":16,"tag":348,"props":1417,"children":1419},{"className":1418},[],[1420],{"type":22,"value":1421},"scan()",{"type":22,"value":1423}," 等高阶结构 [2]。",{"type":16,"tag":28,"props":1425,"children":1426},{},[1427,1429,1435,1436,1442,1444,1449,1451,1456,1458,1463,1465,1470,1472,1477,1479,1484,1486,1492,1493,1499,1500,1506],{"type":22,"value":1428},"为此，我们借用了经典动态数据流架构中的 ",{"type":16,"tag":348,"props":1430,"children":1432},{"className":1431},[],[1433],{"type":22,"value":1434},"Switch",{"type":22,"value":1228},{"type":16,"tag":348,"props":1437,"children":1439},{"className":1438},[],[1440],{"type":22,"value":1441},"Merge",{"type":22,"value":1443}," 原语 [4]。",{"type":16,"tag":348,"props":1445,"children":1447},{"className":1446},[],[1448],{"type":22,"value":1434},{"type":22,"value":1450}," 是一个分路器：它接收一个数据输入和一个控制输入，并用控制输入选择两个输出中的哪一个产生值。未被选择的 ",{"type":16,"tag":348,"props":1452,"children":1454},{"className":1453},[],[1455],{"type":22,"value":1434},{"type":22,"value":1457}," 输出会收到一个特殊的 dead 值，该值递归地沿图传播，直到到达 ",{"type":16,"tag":348,"props":1459,"children":1461},{"className":1460},[],[1462],{"type":22,"value":1441},{"type":22,"value":1464}," 操作。",{"type":16,"tag":348,"props":1466,"children":1468},{"className":1467},[],[1469],{"type":22,"value":1441},{"type":22,"value":1471}," 是一个多路复用器：它把至多一个非 dead 输入转发到输出；如果两个输入都是 dead，则产生 dead 输出。条件运算符使用 ",{"type":16,"tag":348,"props":1473,"children":1475},{"className":1474},[],[1476],{"type":22,"value":1434},{"type":22,"value":1478},"，根据布尔张量的运行时值执行两个分支之一，再使用 ",{"type":16,"tag":348,"props":1480,"children":1482},{"className":1481},[],[1483],{"type":22,"value":1441},{"type":22,"value":1485}," 合并分支输出。while 循环更加复杂，它使用 ",{"type":16,"tag":348,"props":1487,"children":1489},{"className":1488},[],[1490],{"type":22,"value":1491},"Enter",{"type":22,"value":385},{"type":16,"tag":348,"props":1494,"children":1496},{"className":1495},[],[1497],{"type":22,"value":1498},"Exit",{"type":22,"value":1228},{"type":16,"tag":348,"props":1501,"children":1503},{"className":1502},[],[1504],{"type":22,"value":1505},"NextIteration",{"type":22,"value":1507}," 操作保证循环格式良好 [56]。",{"type":16,"tag":28,"props":1509,"children":1510},{},[1511],{"type":22,"value":1512},"迭代的执行可以重叠，TensorFlow 还可以把条件分支和循环体划分到多个设备和进程上。分区步骤增加逻辑，用于协调每台设备上每次迭代的开始和结束，并决定循环终止条件。如 §4.1 所述，TensorFlow 也支持对控制流结构自动求导。自动求导会把计算梯度的子图加入数据流图；TensorFlow 可以把这些子图划分到潜在的分布式设备上，并行计算梯度。",{"type":16,"tag":121,"props":1514,"children":1516},{"id":1515},"图-3抽象-rnn-的伪代码34",[1517],{"type":22,"value":1518},"图 3：抽象 RNN 的伪代码（§3.4）",{"type":16,"tag":28,"props":1520,"children":1521},{},[1522],{"type":16,"tag":326,"props":1523,"children":1528},{"alt":1524,"src":1525,"width":1526,"height":1527},"抽象 RNN 伪代码（原文图 3）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-03.webp",938,324,[],{"type":16,"tag":339,"props":1530,"children":1534},{"className":1531,"code":1533,"language":22,"meta":344},[1532],"language-text","input = ...        # 张量序列\nstate = 0          # 初始状态\nw = ...            # 可训练权重\nfor i in range(len(input)):\n    state, out[i] = f(state, w, input[i])\n",[1535],{"type":16,"tag":348,"props":1536,"children":1537},{"__ignoreMap":344},[1538],{"type":22,"value":1533},{"type":16,"tag":28,"props":1540,"children":1541},{},[1542,1544,1550],{"type":22,"value":1543},"函数 ",{"type":16,"tag":348,"props":1545,"children":1547},{"className":1546},[],[1548],{"type":22,"value":1549},"f",{"type":22,"value":1551}," 通常由可微运算组成，例如矩阵乘法和卷积 [32]。TensorFlow 在数据流图中实现这一循环。",{"type":16,"tag":58,"props":1553,"children":1555},{"id":1554},"_4-可扩展性案例",[1556],{"type":22,"value":1557},"4 可扩展性案例",{"type":16,"tag":28,"props":1559,"children":1560},{},[1561],{"type":22,"value":1562},"通过为 TensorFlow 中的所有计算选择统一表示，我们让用户能够试验 DistBelief 运行时中原本硬编码的功能。本节讨论我们使用数据流原语和“用户级”代码构建的四种扩展。",{"type":16,"tag":121,"props":1564,"children":1566},{"id":1565},"_41-求导与优化",[1567],{"type":22,"value":1568},"4.1 求导与优化",{"type":16,"tag":28,"props":1570,"children":1571},{},[1572],{"type":22,"value":1573},"许多学习算法使用某种 SGD 变体训练一组参数：先计算损失函数相对于这些参数的梯度，再根据梯度更新参数。TensorFlow 包含一个用户级库，可以对损失函数的符号表达式求导，并生成表示梯度的新符号表达式。例如，给定由多层组合而成的神经网络和一个损失函数，该库会自动推导出反向传播代码。",{"type":16,"tag":28,"props":1575,"children":1576},{},[1577],{"type":22,"value":1578},"求导算法执行广度优先搜索，识别从目标操作（例如损失函数）到参数集合的所有反向路径，并把每条路径贡献的部分梯度相加。我们的用户经常为某些操作专门定制梯度，并实现了批归一化 [33] 和梯度裁剪 [60] 等优化，以加速训练并提高鲁棒性。我们扩展了该算法，使其能够对条件和迭代子计算求导（§3.4）：具体做法是在图中添加节点，记录前向传播中的控制流决策，并在反向传播中反向重放这些决策。对长序列上的迭代计算求导，可能导致大量中间状态累积在内存中；针对这类计算，我们开发了管理有限 GPU 内存的技术。",{"type":16,"tag":28,"props":1580,"children":1581},{},[1582,1584,1629,1631,1714,1716,1761],{"type":22,"value":1583},"TensorFlow 用户还可以试验多种优化算法，这些算法在每个训练步骤中计算参数的新值。在参数服务器中实现 SGD 很简单：对于参数 ",{"type":16,"tag":574,"props":1585,"children":1587},{"className":1586},[577],[1588,1610],{"type":16,"tag":574,"props":1589,"children":1591},{"className":1590},[582],[1592],{"type":16,"tag":585,"props":1593,"children":1594},{"xmlns":587},[1595],{"type":16,"tag":590,"props":1596,"children":1597},{},[1598,1606],{"type":16,"tag":594,"props":1599,"children":1600},{},[1601],{"type":16,"tag":598,"props":1602,"children":1603},{},[1604],{"type":22,"value":1605},"W",{"type":16,"tag":616,"props":1607,"children":1608},{"encoding":618},[1609],{"type":22,"value":1605},{"type":16,"tag":574,"props":1611,"children":1613},{"className":1612,"ariaHidden":626},[625],[1614],{"type":16,"tag":574,"props":1615,"children":1617},{"className":1616},[631],[1618,1623],{"type":16,"tag":574,"props":1619,"children":1622},{"className":1620,"style":1621},[636],"height:0.6833em;",[],{"type":16,"tag":574,"props":1624,"children":1627},{"className":1625,"style":1626},[642,643],"margin-right:0.1389em;",[1628],{"type":22,"value":1605},{"type":22,"value":1630},"、梯度 ",{"type":16,"tag":574,"props":1632,"children":1634},{"className":1633},[577],[1635,1676],{"type":16,"tag":574,"props":1636,"children":1638},{"className":1637},[582],[1639],{"type":16,"tag":585,"props":1640,"children":1641},{"xmlns":587},[1642],{"type":16,"tag":590,"props":1643,"children":1644},{},[1645,1671],{"type":16,"tag":594,"props":1646,"children":1647},{},[1648,1653,1658,1663,1667],{"type":16,"tag":598,"props":1649,"children":1650},{"mathvariant":920},[1651],{"type":22,"value":1652},"∂",{"type":16,"tag":598,"props":1654,"children":1655},{},[1656],{"type":22,"value":1657},"L",{"type":16,"tag":598,"props":1659,"children":1660},{"mathvariant":920},[1661],{"type":22,"value":1662},"\u002F",{"type":16,"tag":598,"props":1664,"children":1665},{"mathvariant":920},[1666],{"type":22,"value":1652},{"type":16,"tag":598,"props":1668,"children":1669},{},[1670],{"type":22,"value":1605},{"type":16,"tag":616,"props":1672,"children":1673},{"encoding":618},[1674],{"type":22,"value":1675},"\\partial L\u002F\\partial W",{"type":16,"tag":574,"props":1677,"children":1679},{"className":1678,"ariaHidden":626},[625],[1680],{"type":16,"tag":574,"props":1681,"children":1683},{"className":1682},[631],[1684,1688,1694,1699,1704,1709],{"type":16,"tag":574,"props":1685,"children":1687},{"className":1686,"style":1108},[636],[],{"type":16,"tag":574,"props":1689,"children":1692},{"className":1690,"style":1691},[642],"margin-right:0.0556em;",[1693],{"type":22,"value":1652},{"type":16,"tag":574,"props":1695,"children":1697},{"className":1696},[642,643],[1698],{"type":22,"value":1657},{"type":16,"tag":574,"props":1700,"children":1702},{"className":1701},[642],[1703],{"type":22,"value":1662},{"type":16,"tag":574,"props":1705,"children":1707},{"className":1706,"style":1691},[642],[1708],{"type":22,"value":1652},{"type":16,"tag":574,"props":1710,"children":1712},{"className":1711,"style":1626},[642,643],[1713],{"type":22,"value":1605},{"type":22,"value":1715}," 和学习率 ",{"type":16,"tag":574,"props":1717,"children":1719},{"className":1718},[577],[1720,1743],{"type":16,"tag":574,"props":1721,"children":1723},{"className":1722},[582],[1724],{"type":16,"tag":585,"props":1725,"children":1726},{"xmlns":587},[1727],{"type":16,"tag":590,"props":1728,"children":1729},{},[1730,1738],{"type":16,"tag":594,"props":1731,"children":1732},{},[1733],{"type":16,"tag":598,"props":1734,"children":1735},{},[1736],{"type":22,"value":1737},"α",{"type":16,"tag":616,"props":1739,"children":1740},{"encoding":618},[1741],{"type":22,"value":1742},"\\alpha",{"type":16,"tag":574,"props":1744,"children":1746},{"className":1745,"ariaHidden":626},[625],[1747],{"type":16,"tag":574,"props":1748,"children":1750},{"className":1749},[631],[1751,1755],{"type":16,"tag":574,"props":1752,"children":1754},{"className":1753,"style":1156},[636],[],{"type":16,"tag":574,"props":1756,"children":1759},{"className":1757,"style":1758},[642,643],"margin-right:0.0037em;",[1760],{"type":22,"value":1737},{"type":22,"value":1762},"，更新规则为",{"type":16,"tag":574,"props":1764,"children":1766},{"className":1765},[891],[1767],{"type":16,"tag":574,"props":1768,"children":1770},{"className":1769},[577],[1771,1852],{"type":16,"tag":574,"props":1772,"children":1774},{"className":1773},[582],[1775],{"type":16,"tag":585,"props":1776,"children":1777},{"xmlns":587,"display":903},[1778],{"type":16,"tag":590,"props":1779,"children":1780},{},[1781,1847],{"type":16,"tag":594,"props":1782,"children":1783},{},[1784,1795,1799,1803,1808,1812,1817,1843],{"type":16,"tag":912,"props":1785,"children":1786},{},[1787,1791],{"type":16,"tag":598,"props":1788,"children":1789},{},[1790],{"type":22,"value":1605},{"type":16,"tag":604,"props":1792,"children":1793},{"mathvariant":920,"lspace":931,"rspace":931},[1794],{"type":22,"value":934},{"type":16,"tag":604,"props":1796,"children":1797},{},[1798],{"type":22,"value":954},{"type":16,"tag":598,"props":1800,"children":1801},{},[1802],{"type":22,"value":1605},{"type":16,"tag":604,"props":1804,"children":1805},{},[1806],{"type":22,"value":1807},"−",{"type":16,"tag":598,"props":1809,"children":1810},{},[1811],{"type":22,"value":1737},{"type":16,"tag":604,"props":1813,"children":1814},{},[1815],{"type":22,"value":1816},"×",{"type":16,"tag":1818,"props":1819,"children":1820},"mfrac",{},[1821,1832],{"type":16,"tag":594,"props":1822,"children":1823},{},[1824,1828],{"type":16,"tag":598,"props":1825,"children":1826},{"mathvariant":920},[1827],{"type":22,"value":1652},{"type":16,"tag":598,"props":1829,"children":1830},{},[1831],{"type":22,"value":1657},{"type":16,"tag":594,"props":1833,"children":1834},{},[1835,1839],{"type":16,"tag":598,"props":1836,"children":1837},{"mathvariant":920},[1838],{"type":22,"value":1652},{"type":16,"tag":598,"props":1840,"children":1841},{},[1842],{"type":22,"value":1605},{"type":16,"tag":598,"props":1844,"children":1845},{"mathvariant":920},[1846],{"type":22,"value":988},{"type":16,"tag":616,"props":1848,"children":1849},{"encoding":618},[1850],{"type":22,"value":1851},"W' \\leftarrow W - \\alpha \\times \\frac{\\partial L}{\\partial W}.",{"type":16,"tag":574,"props":1853,"children":1855},{"className":1854,"ariaHidden":626},[625],[1856,1924,1951,1978],{"type":16,"tag":574,"props":1857,"children":1859},{"className":1858},[631],[1860,1865,1911,1915,1920],{"type":16,"tag":574,"props":1861,"children":1864},{"className":1862,"style":1863},[636],"height:0.8019em;",[],{"type":16,"tag":574,"props":1866,"children":1868},{"className":1867},[642],[1869,1874],{"type":16,"tag":574,"props":1870,"children":1872},{"className":1871,"style":1626},[642,643],[1873],{"type":22,"value":1605},{"type":16,"tag":574,"props":1875,"children":1877},{"className":1876},[1025],[1878],{"type":16,"tag":574,"props":1879,"children":1881},{"className":1880},[1030],[1882],{"type":16,"tag":574,"props":1883,"children":1885},{"className":1884},[1035],[1886],{"type":16,"tag":574,"props":1887,"children":1889},{"className":1888,"style":1863},[1040],[1890],{"type":16,"tag":574,"props":1891,"children":1893},{"style":1892},"top:-3.113em;margin-right:0.05em;",[1894,1898],{"type":16,"tag":574,"props":1895,"children":1897},{"className":1896,"style":1051},[1050],[],{"type":16,"tag":574,"props":1899,"children":1901},{"className":1900},[1056,1057,1058,1059],[1902],{"type":16,"tag":574,"props":1903,"children":1905},{"className":1904},[642,1059],[1906],{"type":16,"tag":574,"props":1907,"children":1909},{"className":1908},[642,1059],[1910],{"type":22,"value":934},{"type":16,"tag":574,"props":1912,"children":1914},{"className":1913,"style":650},[649],[],{"type":16,"tag":574,"props":1916,"children":1918},{"className":1917},[655],[1919],{"type":22,"value":954},{"type":16,"tag":574,"props":1921,"children":1923},{"className":1922,"style":650},[649],[],{"type":16,"tag":574,"props":1925,"children":1927},{"className":1926},[631],[1928,1933,1938,1942,1947],{"type":16,"tag":574,"props":1929,"children":1932},{"className":1930,"style":1931},[636],"height:0.7667em;vertical-align:-0.0833em;",[],{"type":16,"tag":574,"props":1934,"children":1936},{"className":1935,"style":1626},[642,643],[1937],{"type":22,"value":1605},{"type":16,"tag":574,"props":1939,"children":1941},{"className":1940,"style":1137},[649],[],{"type":16,"tag":574,"props":1943,"children":1945},{"className":1944},[1142],[1946],{"type":22,"value":1807},{"type":16,"tag":574,"props":1948,"children":1950},{"className":1949,"style":1137},[649],[],{"type":16,"tag":574,"props":1952,"children":1954},{"className":1953},[631],[1955,1960,1965,1969,1974],{"type":16,"tag":574,"props":1956,"children":1959},{"className":1957,"style":1958},[636],"height:0.6667em;vertical-align:-0.0833em;",[],{"type":16,"tag":574,"props":1961,"children":1963},{"className":1962,"style":1758},[642,643],[1964],{"type":22,"value":1737},{"type":16,"tag":574,"props":1966,"children":1968},{"className":1967,"style":1137},[649],[],{"type":16,"tag":574,"props":1970,"children":1972},{"className":1971},[1142],[1973],{"type":22,"value":1816},{"type":16,"tag":574,"props":1975,"children":1977},{"className":1976,"style":1137},[649],[],{"type":16,"tag":574,"props":1979,"children":1981},{"className":1980},[631],[1982,1987,2096],{"type":16,"tag":574,"props":1983,"children":1986},{"className":1984,"style":1985},[636],"height:2.0574em;vertical-align:-0.686em;",[],{"type":16,"tag":574,"props":1988,"children":1990},{"className":1989},[642],[1991,1996,2092],{"type":16,"tag":574,"props":1992,"children":1995},{"className":1993},[1073,1994],"nulldelimiter",[],{"type":16,"tag":574,"props":1997,"children":1999},{"className":1998},[1818],[2000],{"type":16,"tag":574,"props":2001,"children":2004},{"className":2002},[1030,2003],"vlist-t2",[2005,2080],{"type":16,"tag":574,"props":2006,"children":2008},{"className":2007},[1035],[2009,2073],{"type":16,"tag":574,"props":2010,"children":2013},{"className":2011,"style":2012},[1040],"height:1.3714em;",[2014,2037,2051],{"type":16,"tag":574,"props":2015,"children":2017},{"style":2016},"top:-2.314em;",[2018,2023],{"type":16,"tag":574,"props":2019,"children":2022},{"className":2020,"style":2021},[1050],"height:3em;",[],{"type":16,"tag":574,"props":2024,"children":2026},{"className":2025},[642],[2027,2032],{"type":16,"tag":574,"props":2028,"children":2030},{"className":2029,"style":1691},[642],[2031],{"type":22,"value":1652},{"type":16,"tag":574,"props":2033,"children":2035},{"className":2034,"style":1626},[642,643],[2036],{"type":22,"value":1605},{"type":16,"tag":574,"props":2038,"children":2040},{"style":2039},"top:-3.23em;",[2041,2045],{"type":16,"tag":574,"props":2042,"children":2044},{"className":2043,"style":2021},[1050],[],{"type":16,"tag":574,"props":2046,"children":2050},{"className":2047,"style":2049},[2048],"frac-line","border-bottom-width:0.04em;",[],{"type":16,"tag":574,"props":2052,"children":2054},{"style":2053},"top:-3.677em;",[2055,2059],{"type":16,"tag":574,"props":2056,"children":2058},{"className":2057,"style":2021},[1050],[],{"type":16,"tag":574,"props":2060,"children":2062},{"className":2061},[642],[2063,2068],{"type":16,"tag":574,"props":2064,"children":2066},{"className":2065,"style":1691},[642],[2067],{"type":22,"value":1652},{"type":16,"tag":574,"props":2069,"children":2071},{"className":2070},[642,643],[2072],{"type":22,"value":1657},{"type":16,"tag":574,"props":2074,"children":2077},{"className":2075},[2076],"vlist-s",[2078],{"type":22,"value":2079},"​",{"type":16,"tag":574,"props":2081,"children":2083},{"className":2082},[1035],[2084],{"type":16,"tag":574,"props":2085,"children":2088},{"className":2086,"style":2087},[1040],"height:0.686em;",[2089],{"type":16,"tag":574,"props":2090,"children":2091},{},[],{"type":16,"tag":574,"props":2093,"children":2095},{"className":2094},[1085,1994],[],{"type":16,"tag":574,"props":2097,"children":2099},{"className":2098},[642],[2100],{"type":22,"value":988},{"type":16,"tag":28,"props":2102,"children":2103},{},[2104,2106,2112,2114,2227,2229,2271],{"type":22,"value":2105},"参数服务器可以使用 ",{"type":16,"tag":348,"props":2107,"children":2109},{"className":2108},[],[2110],{"type":22,"value":2111},"-=",{"type":22,"value":2113}," 作为写操作，并在每个训练步骤后把 ",{"type":16,"tag":574,"props":2115,"children":2117},{"className":2116},[577],[2118,2164],{"type":16,"tag":574,"props":2119,"children":2121},{"className":2120},[582],[2122],{"type":16,"tag":585,"props":2123,"children":2124},{"xmlns":587},[2125],{"type":16,"tag":590,"props":2126,"children":2127},{},[2128,2159],{"type":16,"tag":594,"props":2129,"children":2130},{},[2131,2135,2139,2143,2147,2151,2155],{"type":16,"tag":598,"props":2132,"children":2133},{},[2134],{"type":22,"value":1737},{"type":16,"tag":604,"props":2136,"children":2137},{},[2138],{"type":22,"value":1816},{"type":16,"tag":598,"props":2140,"children":2141},{"mathvariant":920},[2142],{"type":22,"value":1652},{"type":16,"tag":598,"props":2144,"children":2145},{},[2146],{"type":22,"value":1657},{"type":16,"tag":598,"props":2148,"children":2149},{"mathvariant":920},[2150],{"type":22,"value":1662},{"type":16,"tag":598,"props":2152,"children":2153},{"mathvariant":920},[2154],{"type":22,"value":1652},{"type":16,"tag":598,"props":2156,"children":2157},{},[2158],{"type":22,"value":1605},{"type":16,"tag":616,"props":2160,"children":2161},{"encoding":618},[2162],{"type":22,"value":2163},"\\alpha \\times \\partial L\u002F\\partial W",{"type":16,"tag":574,"props":2165,"children":2167},{"className":2166,"ariaHidden":626},[625],[2168,2194],{"type":16,"tag":574,"props":2169,"children":2171},{"className":2170},[631],[2172,2176,2181,2185,2190],{"type":16,"tag":574,"props":2173,"children":2175},{"className":2174,"style":1958},[636],[],{"type":16,"tag":574,"props":2177,"children":2179},{"className":2178,"style":1758},[642,643],[2180],{"type":22,"value":1737},{"type":16,"tag":574,"props":2182,"children":2184},{"className":2183,"style":1137},[649],[],{"type":16,"tag":574,"props":2186,"children":2188},{"className":2187},[1142],[2189],{"type":22,"value":1816},{"type":16,"tag":574,"props":2191,"children":2193},{"className":2192,"style":1137},[649],[],{"type":16,"tag":574,"props":2195,"children":2197},{"className":2196},[631],[2198,2202,2207,2212,2217,2222],{"type":16,"tag":574,"props":2199,"children":2201},{"className":2200,"style":1108},[636],[],{"type":16,"tag":574,"props":2203,"children":2205},{"className":2204,"style":1691},[642],[2206],{"type":22,"value":1652},{"type":16,"tag":574,"props":2208,"children":2210},{"className":2209},[642,643],[2211],{"type":22,"value":1657},{"type":16,"tag":574,"props":2213,"children":2215},{"className":2214},[642],[2216],{"type":22,"value":1662},{"type":16,"tag":574,"props":2218,"children":2220},{"className":2219,"style":1691},[642],[2221],{"type":22,"value":1652},{"type":16,"tag":574,"props":2223,"children":2225},{"className":2224,"style":1626},[642,643],[2226],{"type":22,"value":1605},{"type":22,"value":2228}," 写入每个 ",{"type":16,"tag":574,"props":2230,"children":2232},{"className":2231},[577],[2233,2254],{"type":16,"tag":574,"props":2234,"children":2236},{"className":2235},[582],[2237],{"type":16,"tag":585,"props":2238,"children":2239},{"xmlns":587},[2240],{"type":16,"tag":590,"props":2241,"children":2242},{},[2243,2250],{"type":16,"tag":594,"props":2244,"children":2245},{},[2246],{"type":16,"tag":598,"props":2247,"children":2248},{},[2249],{"type":22,"value":1605},{"type":16,"tag":616,"props":2251,"children":2252},{"encoding":618},[2253],{"type":22,"value":1605},{"type":16,"tag":574,"props":2255,"children":2257},{"className":2256,"ariaHidden":626},[625],[2258],{"type":16,"tag":574,"props":2259,"children":2261},{"className":2260},[631],[2262,2266],{"type":16,"tag":574,"props":2263,"children":2265},{"className":2264,"style":1621},[636],[],{"type":16,"tag":574,"props":2267,"children":2269},{"className":2268,"style":1626},[642,643],[2270],{"type":22,"value":1605},{"type":22,"value":1188},{"type":16,"tag":28,"props":2273,"children":2274},{},[2275,2277,2282],{"type":22,"value":2276},"但许多更高级的优化方案很难表示为一次写操作。例如，Momentum 算法根据参数在多个迭代中的梯度为每个参数累积一个“速度”，再根据该累积量计算参数更新；人们还提出了该算法的许多改进 [66]。在 DistBelief [20] 中实现 Momentum，需要修改参数服务器实现，改变参数数据的表示方式，并在写操作中执行复杂逻辑；这对许多用户来说很有挑战。优化算法是一个活跃的研究领域，研究人员已经在 TensorFlow 上实现了 Momentum、AdaGrad、AdaDelta、RMSProp、Adam 和 L-BFGS 等算法。这些算法可以通过 ",{"type":16,"tag":348,"props":2278,"children":2280},{"className":2279},[],[2281],{"type":22,"value":831},{"type":22,"value":2283}," 操作和基本数学运算在 TensorFlow 中构建，而无需修改底层系统，因此当新算法出现时，可以很容易地进行试验。",{"type":16,"tag":121,"props":2285,"children":2287},{"id":2286},"_42-训练超大模型",[2288],{"type":22,"value":2289},"4.2 训练超大模型",{"type":16,"tag":28,"props":2291,"children":2292},{},[2293],{"type":22,"value":2294},"为了在文本语料库中的单词等高维数据上训练模型，通常使用分布式表示：一个训练样本被表示为多个神经元上的活动模式，并通过反向传播学习这种表示 [30]。例如，在语言模型中，一个训练样本可能是一个稀疏向量，词表中对应单词 ID 的位置为非零值；每个单词的分布式表示是一个低维向量 [6]。“宽而深学习”从类别特征的交叉积变换中创建分布式表示；基于 TensorFlow 的实现被用于 Google Play 应用商店推荐系统 [12]。",{"type":16,"tag":28,"props":2296,"children":2297},{},[2298,2300,2344,2346,2424,2426,2468,2470,2512,2514,2592,2594,2670,2672,2768],{"type":22,"value":2299},"推理过程把一批 ",{"type":16,"tag":574,"props":2301,"children":2303},{"className":2302},[577],[2304,2326],{"type":16,"tag":574,"props":2305,"children":2307},{"className":2306},[582],[2308],{"type":16,"tag":585,"props":2309,"children":2310},{"xmlns":587},[2311],{"type":16,"tag":590,"props":2312,"children":2313},{},[2314,2322],{"type":16,"tag":594,"props":2315,"children":2316},{},[2317],{"type":16,"tag":598,"props":2318,"children":2319},{},[2320],{"type":22,"value":2321},"b",{"type":16,"tag":616,"props":2323,"children":2324},{"encoding":618},[2325],{"type":22,"value":2321},{"type":16,"tag":574,"props":2327,"children":2329},{"className":2328,"ariaHidden":626},[625],[2330],{"type":16,"tag":574,"props":2331,"children":2333},{"className":2332},[631],[2334,2339],{"type":16,"tag":574,"props":2335,"children":2338},{"className":2336,"style":2337},[636],"height:0.6944em;",[],{"type":16,"tag":574,"props":2340,"children":2342},{"className":2341},[642,643],[2343],{"type":22,"value":2321},{"type":22,"value":2345}," 个稀疏向量与 ",{"type":16,"tag":574,"props":2347,"children":2349},{"className":2348},[577],[2350,2381],{"type":16,"tag":574,"props":2351,"children":2353},{"className":2352},[582],[2354],{"type":16,"tag":585,"props":2355,"children":2356},{"xmlns":587},[2357],{"type":16,"tag":590,"props":2358,"children":2359},{},[2360,2376],{"type":16,"tag":594,"props":2361,"children":2362},{},[2363,2367,2371],{"type":16,"tag":598,"props":2364,"children":2365},{},[2366],{"type":22,"value":699},{"type":16,"tag":604,"props":2368,"children":2369},{},[2370],{"type":22,"value":1816},{"type":16,"tag":598,"props":2372,"children":2373},{},[2374],{"type":22,"value":2375},"d",{"type":16,"tag":616,"props":2377,"children":2378},{"encoding":618},[2379],{"type":22,"value":2380},"n \\times d",{"type":16,"tag":574,"props":2382,"children":2384},{"className":2383,"ariaHidden":626},[625],[2385,2411],{"type":16,"tag":574,"props":2386,"children":2388},{"className":2387},[631],[2389,2393,2398,2402,2407],{"type":16,"tag":574,"props":2390,"children":2392},{"className":2391,"style":1958},[636],[],{"type":16,"tag":574,"props":2394,"children":2396},{"className":2395},[642,643],[2397],{"type":22,"value":699},{"type":16,"tag":574,"props":2399,"children":2401},{"className":2400,"style":1137},[649],[],{"type":16,"tag":574,"props":2403,"children":2405},{"className":2404},[1142],[2406],{"type":22,"value":1816},{"type":16,"tag":574,"props":2408,"children":2410},{"className":2409,"style":1137},[649],[],{"type":16,"tag":574,"props":2412,"children":2414},{"className":2413},[631],[2415,2419],{"type":16,"tag":574,"props":2416,"children":2418},{"className":2417,"style":2337},[636],[],{"type":16,"tag":574,"props":2420,"children":2422},{"className":2421},[642,643],[2423],{"type":22,"value":2375},{"type":22,"value":2425}," 嵌入矩阵相乘，其中 ",{"type":16,"tag":574,"props":2427,"children":2429},{"className":2428},[577],[2430,2451],{"type":16,"tag":574,"props":2431,"children":2433},{"className":2432},[582],[2434],{"type":16,"tag":585,"props":2435,"children":2436},{"xmlns":587},[2437],{"type":16,"tag":590,"props":2438,"children":2439},{},[2440,2447],{"type":16,"tag":594,"props":2441,"children":2442},{},[2443],{"type":16,"tag":598,"props":2444,"children":2445},{},[2446],{"type":22,"value":699},{"type":16,"tag":616,"props":2448,"children":2449},{"encoding":618},[2450],{"type":22,"value":699},{"type":16,"tag":574,"props":2452,"children":2454},{"className":2453,"ariaHidden":626},[625],[2455],{"type":16,"tag":574,"props":2456,"children":2458},{"className":2457},[631],[2459,2463],{"type":16,"tag":574,"props":2460,"children":2462},{"className":2461,"style":1156},[636],[],{"type":16,"tag":574,"props":2464,"children":2466},{"className":2465},[642,643],[2467],{"type":22,"value":699},{"type":22,"value":2469}," 是词表中的单词数、",{"type":16,"tag":574,"props":2471,"children":2473},{"className":2472},[577],[2474,2495],{"type":16,"tag":574,"props":2475,"children":2477},{"className":2476},[582],[2478],{"type":16,"tag":585,"props":2479,"children":2480},{"xmlns":587},[2481],{"type":16,"tag":590,"props":2482,"children":2483},{},[2484,2491],{"type":16,"tag":594,"props":2485,"children":2486},{},[2487],{"type":16,"tag":598,"props":2488,"children":2489},{},[2490],{"type":22,"value":2375},{"type":16,"tag":616,"props":2492,"children":2493},{"encoding":618},[2494],{"type":22,"value":2375},{"type":16,"tag":574,"props":2496,"children":2498},{"className":2497,"ariaHidden":626},[625],[2499],{"type":16,"tag":574,"props":2500,"children":2502},{"className":2501},[631],[2503,2507],{"type":16,"tag":574,"props":2504,"children":2506},{"className":2505,"style":2337},[636],[],{"type":16,"tag":574,"props":2508,"children":2510},{"className":2509},[642,643],[2511],{"type":22,"value":2375},{"type":22,"value":2513}," 是期望维度，结果是一个更小的 ",{"type":16,"tag":574,"props":2515,"children":2517},{"className":2516},[577],[2518,2548],{"type":16,"tag":574,"props":2519,"children":2521},{"className":2520},[582],[2522],{"type":16,"tag":585,"props":2523,"children":2524},{"xmlns":587},[2525],{"type":16,"tag":590,"props":2526,"children":2527},{},[2528,2543],{"type":16,"tag":594,"props":2529,"children":2530},{},[2531,2535,2539],{"type":16,"tag":598,"props":2532,"children":2533},{},[2534],{"type":22,"value":2321},{"type":16,"tag":604,"props":2536,"children":2537},{},[2538],{"type":22,"value":1816},{"type":16,"tag":598,"props":2540,"children":2541},{},[2542],{"type":22,"value":2375},{"type":16,"tag":616,"props":2544,"children":2545},{"encoding":618},[2546],{"type":22,"value":2547},"b \\times d",{"type":16,"tag":574,"props":2549,"children":2551},{"className":2550,"ariaHidden":626},[625],[2552,2579],{"type":16,"tag":574,"props":2553,"children":2555},{"className":2554},[631],[2556,2561,2566,2570,2575],{"type":16,"tag":574,"props":2557,"children":2560},{"className":2558,"style":2559},[636],"height:0.7778em;vertical-align:-0.0833em;",[],{"type":16,"tag":574,"props":2562,"children":2564},{"className":2563},[642,643],[2565],{"type":22,"value":2321},{"type":16,"tag":574,"props":2567,"children":2569},{"className":2568,"style":1137},[649],[],{"type":16,"tag":574,"props":2571,"children":2573},{"className":2572},[1142],[2574],{"type":22,"value":1816},{"type":16,"tag":574,"props":2576,"children":2578},{"className":2577,"style":1137},[649],[],{"type":16,"tag":574,"props":2580,"children":2582},{"className":2581},[631],[2583,2587],{"type":16,"tag":574,"props":2584,"children":2586},{"className":2585,"style":2337},[636],[],{"type":16,"tag":574,"props":2588,"children":2590},{"className":2589},[642,643],[2591],{"type":22,"value":2375},{"type":22,"value":2593}," 稠密矩阵表示。训练时，大多数优化算法只会修改稀疏乘法所读取的嵌入矩阵行。在 TensorFlow 中，处理稀疏数据的模型可能有 ",{"type":16,"tag":574,"props":2595,"children":2597},{"className":2596},[577],[2598,2627],{"type":16,"tag":574,"props":2599,"children":2601},{"className":2600},[582],[2602],{"type":16,"tag":585,"props":2603,"children":2604},{"xmlns":587},[2605],{"type":16,"tag":590,"props":2606,"children":2607},{},[2608,2623],{"type":16,"tag":594,"props":2609,"children":2610},{},[2611,2615,2619],{"type":16,"tag":598,"props":2612,"children":2613},{},[2614],{"type":22,"value":699},{"type":16,"tag":604,"props":2616,"children":2617},{},[2618],{"type":22,"value":1816},{"type":16,"tag":598,"props":2620,"children":2621},{},[2622],{"type":22,"value":2375},{"type":16,"tag":616,"props":2624,"children":2625},{"encoding":618},[2626],{"type":22,"value":2380},{"type":16,"tag":574,"props":2628,"children":2630},{"className":2629,"ariaHidden":626},[625],[2631,2657],{"type":16,"tag":574,"props":2632,"children":2634},{"className":2633},[631],[2635,2639,2644,2648,2653],{"type":16,"tag":574,"props":2636,"children":2638},{"className":2637,"style":1958},[636],[],{"type":16,"tag":574,"props":2640,"children":2642},{"className":2641},[642,643],[2643],{"type":22,"value":699},{"type":16,"tag":574,"props":2645,"children":2647},{"className":2646,"style":1137},[649],[],{"type":16,"tag":574,"props":2649,"children":2651},{"className":2650},[1142],[2652],{"type":22,"value":1816},{"type":16,"tag":574,"props":2654,"children":2656},{"className":2655,"style":1137},[649],[],{"type":16,"tag":574,"props":2658,"children":2660},{"className":2659},[631],[2661,2665],{"type":16,"tag":574,"props":2662,"children":2664},{"className":2663,"style":2337},[636],[],{"type":16,"tag":574,"props":2666,"children":2668},{"className":2667},[642,643],[2669],{"type":22,"value":2375},{"type":22,"value":2671}," GB 级参数：例如，大型语言模型可能使用含 80 万个单词的词表，并包含超过 ",{"type":16,"tag":574,"props":2673,"children":2675},{"className":2674},[577],[2676,2707],{"type":16,"tag":574,"props":2677,"children":2679},{"className":2678},[582],[2680],{"type":16,"tag":585,"props":2681,"children":2682},{"xmlns":587},[2683],{"type":16,"tag":590,"props":2684,"children":2685},{},[2686,2702],{"type":16,"tag":594,"props":2687,"children":2688},{},[2689],{"type":16,"tag":912,"props":2690,"children":2691},{},[2692,2697],{"type":16,"tag":610,"props":2693,"children":2694},{},[2695],{"type":22,"value":2696},"10",{"type":16,"tag":610,"props":2698,"children":2699},{},[2700],{"type":22,"value":2701},"9",{"type":16,"tag":616,"props":2703,"children":2704},{"encoding":618},[2705],{"type":22,"value":2706},"10^9",{"type":16,"tag":574,"props":2708,"children":2710},{"className":2709,"ariaHidden":626},[625],[2711],{"type":16,"tag":574,"props":2712,"children":2714},{"className":2713},[631],[2715,2720,2726],{"type":16,"tag":574,"props":2716,"children":2719},{"className":2717,"style":2718},[636],"height:0.8141em;",[],{"type":16,"tag":574,"props":2721,"children":2723},{"className":2722},[642],[2724],{"type":22,"value":2725},"1",{"type":16,"tag":574,"props":2727,"children":2729},{"className":2728},[642],[2730,2735],{"type":16,"tag":574,"props":2731,"children":2733},{"className":2732},[642],[2734],{"type":22,"value":614},{"type":16,"tag":574,"props":2736,"children":2738},{"className":2737},[1025],[2739],{"type":16,"tag":574,"props":2740,"children":2742},{"className":2741},[1030],[2743],{"type":16,"tag":574,"props":2744,"children":2746},{"className":2745},[1035],[2747],{"type":16,"tag":574,"props":2748,"children":2750},{"className":2749,"style":2718},[1040],[2751],{"type":16,"tag":574,"props":2752,"children":2754},{"style":2753},"top:-3.063em;margin-right:0.05em;",[2755,2759],{"type":16,"tag":574,"props":2756,"children":2758},{"className":2757,"style":1051},[1050],[],{"type":16,"tag":574,"props":2760,"children":2762},{"className":2761},[1056,1057,1058,1059],[2763],{"type":16,"tag":574,"props":2764,"children":2766},{"className":2765},[642,1059],[2767],{"type":22,"value":2701},{"type":22,"value":2769}," 个参数 [41]；我们还处理过参数占用数 TB 的文档模型 [19]。这类模型太大，既无法每次使用时复制到 worker，甚至无法存放在单台主机的 RAM 中。",{"type":16,"tag":28,"props":2771,"children":2772},{},[2773,2775,2781,2783,2788,2790,2795],{"type":22,"value":2774},"我们把稀疏嵌入层实现为基本操作的组合。图 4 展示了一个简化图：嵌入层被划分到两个参数服务器 task。该子图的核心操作是 ",{"type":16,"tag":348,"props":2776,"children":2778},{"className":2777},[],[2779],{"type":22,"value":2780},"Gather",{"type":22,"value":2782},"，它从张量中提取一组稀疏行；TensorFlow 会把这一操作与其操作的变量共置。动态分区（",{"type":16,"tag":348,"props":2784,"children":2786},{"className":2785},[],[2787],{"type":22,"value":476},{"type":22,"value":2789},"）操作把输入索引划分成大小可变的张量，每个张量包含发往一个分片的索引；动态合并拼接（",{"type":16,"tag":348,"props":2791,"children":2793},{"className":2792},[],[2794],{"type":22,"value":483},{"type":22,"value":2796},"）操作把各分片的部分结果重新组装成一个结果张量。这些操作分别有对应的梯度，因此支持自动求导（§4.1）；最终得到的一组稀疏更新操作只作用于最初从各分片提取的那些值。",{"type":16,"tag":28,"props":2798,"children":2799},{},[2800],{"type":22,"value":2801},"用户通常不会手动构造类似图 4 的图。TensorFlow 提供了表示分片参数的抽象库，并根据期望的分布程度构建由基本操作组成的适当图。",{"type":16,"tag":28,"props":2803,"children":2804},{},[2805],{"type":22,"value":2806},"虽然参数服务器也可以实现稀疏读取和更新 [49]，但 TensorFlow 增加了把任意计算卸载到保存共享参数的设备上的灵活性。例如，分类模型通常使用 softmax 分类器，把最终输出乘以一个有 c 列的权重矩阵，其中 c 是可能类别数；语言模型中 c 就是词表大小，可能非常大。我们的用户试验了多种加速 softmax 计算的方案。第一种与 Project Adam [14] 中的优化类似：把权重分片到多个 task，并把乘法和梯度计算与分片共置。使用 sampled softmax 可以更高效地训练 [37]：它根据样本的真实类别和一组随机采样的错误类别执行稀疏乘法。我们在 §6.4 比较了这两种方案的性能。",{"type":16,"tag":121,"props":2808,"children":2810},{"id":2809},"图-4采用双向分片嵌入矩阵的嵌入层稀疏更新数据流",[2811],{"type":22,"value":2812},"图 4：采用双向分片嵌入矩阵的嵌入层稀疏更新数据流",{"type":16,"tag":28,"props":2814,"children":2815},{},[2816],{"type":16,"tag":326,"props":2817,"children":2822},{"alt":2818,"src":2819,"width":2820,"height":2821},"双向分片嵌入矩阵的稀疏更新数据流（原文图 4）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-04.webp",771,404,[],{"type":16,"tag":28,"props":2824,"children":2825},{},[2826,2828,2834,2835,2841,2843,2848,2850,2855,2856,2861,2862,2867,2868,2873,2875,2881,2883,2889],{"type":22,"value":2827},"图中 ",{"type":16,"tag":348,"props":2829,"children":2831},{"className":2830},[],[2832],{"type":22,"value":2833},"Shard 0",{"type":22,"value":385},{"type":16,"tag":348,"props":2836,"children":2838},{"className":2837},[],[2839],{"type":22,"value":2840},"Shard 1",{"type":22,"value":2842}," 表示两个分片，",{"type":16,"tag":348,"props":2844,"children":2846},{"className":2845},[],[2847],{"type":22,"value":2780},{"type":22,"value":2849}," 表示提取行，",{"type":16,"tag":348,"props":2851,"children":2853},{"className":2852},[],[2854],{"type":22,"value":469},{"type":22,"value":385},{"type":16,"tag":348,"props":2857,"children":2859},{"className":2858},[],[2860],{"type":22,"value":476},{"type":22,"value":385},{"type":16,"tag":348,"props":2863,"children":2865},{"className":2864},[],[2866],{"type":22,"value":483},{"type":22,"value":385},{"type":16,"tag":348,"props":2869,"children":2871},{"className":2870},[],[2872],{"type":22,"value":490},{"type":22,"value":2874}," 为相应基本操作；",{"type":16,"tag":348,"props":2876,"children":2878},{"className":2877},[],[2879],{"type":22,"value":2880},"True branch",{"type":22,"value":2882}," 与 ",{"type":16,"tag":348,"props":2884,"children":2886},{"className":2885},[],[2887],{"type":22,"value":2888},"False branch",{"type":22,"value":2890}," 表示条件分支。",{"type":16,"tag":121,"props":2892,"children":2894},{"id":2893},"_43-容错",[2895],{"type":22,"value":2896},"4.3 容错",{"type":16,"tag":28,"props":2898,"children":2899},{},[2900],{"type":22,"value":2901},"即使使用大量机器，训练一个模型也可能需要数小时或数天 [14, 20]。我们经常需要使用非专用资源训练模型，例如使用 Borg 集群管理器 [71]；Borg 不保证在整个训练期间都能提供同一批资源。因此，一个运行时间很长的 TensorFlow 作业很可能遭遇故障或抢占，我们需要某种容错机制。",{"type":16,"tag":28,"props":2903,"children":2904},{},[2905],{"type":22,"value":2906},"task 不太可能频繁失败到需要让单个操作具备容错能力，因此 Spark 的 RDD [75] 那样的机制会带来很大开销，却几乎没有收益。也没有必要让参数状态的每次写入都持久化，因为我们可以根据输入数据重新计算任何更新，而且许多学习算法并不要求强一致性 [61]。",{"type":16,"tag":28,"props":2908,"children":2909},{},[2910,2912,2918,2920,2926,2928,2933,2935,2940,2942,2947,2949,2954,2956,2961,2963,2968],{"type":22,"value":2911},"我们在用户层实现了基于检查点的容错，使用图中的两个操作（图 2）：",{"type":16,"tag":348,"props":2913,"children":2915},{"className":2914},[],[2916],{"type":22,"value":2917},"Save",{"type":22,"value":2919}," 把一个或多个张量写入检查点文件，",{"type":16,"tag":348,"props":2921,"children":2923},{"className":2922},[],[2924],{"type":22,"value":2925},"Restore",{"type":22,"value":2927}," 从检查点文件读取一个或多个张量。典型配置是：把一个 task 中的每个 ",{"type":16,"tag":348,"props":2929,"children":2931},{"className":2930},[],[2932],{"type":22,"value":831},{"type":22,"value":2934}," 连接到同一个 ",{"type":16,"tag":348,"props":2936,"children":2938},{"className":2937},[],[2939],{"type":22,"value":2917},{"type":22,"value":2941}," 操作；每个 task 使用一个 ",{"type":16,"tag":348,"props":2943,"children":2945},{"className":2944},[],[2946],{"type":22,"value":2917},{"type":22,"value":2948},"，以最大化对分布式文件系统的 I\u002FO 带宽。",{"type":16,"tag":348,"props":2950,"children":2952},{"className":2951},[],[2953],{"type":22,"value":2925},{"type":22,"value":2955}," 操作从文件读取命名张量，标准的 ",{"type":16,"tag":348,"props":2957,"children":2959},{"className":2958},[],[2960],{"type":22,"value":777},{"type":22,"value":2962}," 操作再把恢复值存入相应变量。训练期间，典型客户端定期运行所有 ",{"type":16,"tag":348,"props":2964,"children":2966},{"className":2965},[],[2967],{"type":22,"value":2917},{"type":22,"value":2969}," 操作，生成新的检查点；客户端启动时，则尝试恢复最新检查点。",{"type":16,"tag":28,"props":2971,"children":2972},{},[2973,2975,2980,2981,2986],{"type":22,"value":2974},"TensorFlow 包含一个客户端库，用于构造所需的图结构并在需要时调用 ",{"type":16,"tag":348,"props":2976,"children":2978},{"className":2977},[],[2979],{"type":22,"value":2917},{"type":22,"value":1228},{"type":16,"tag":348,"props":2982,"children":2984},{"className":2983},[],[2985],{"type":22,"value":2925},{"type":22,"value":2987},"。这种行为可以定制：用户可以对模型中的变量子集应用不同策略，也可以自定义检查点保留方案。例如，许多用户会保留自定义评估指标得分最高的检查点。该实现还可以复用到模型微调和无监督预训练 [45, 47] 中；这两者都是迁移学习形式，即把在一个任务上训练的模型参数作为另一个任务的起点（例如，先训练识别一般图像，再训练识别不同犬种）。把检查点和参数管理作为图中的可编程操作，使用户能够实现这类方案以及我们尚未预见的其他方案。",{"type":16,"tag":28,"props":2989,"children":2990},{},[2991],{"type":22,"value":2992},"检查点库不尝试生成一致的检查点：如果训练与检查点操作并发执行，检查点可能包含训练步骤中的零个、全部或部分更新。这种行为与异步 SGD 的宽松保证兼容 [20]。一致检查点需要额外同步，确保更新操作不会干扰检查点；如果需要，可以使用下一小节的方案，在同步更新步骤之后保存检查点。",{"type":16,"tag":121,"props":2994,"children":2996},{"id":2995},"_44-同步副本协调",[2997],{"type":22,"value":2998},"4.4 同步副本协调",{"type":16,"tag":28,"props":3000,"children":3001},{},[3002],{"type":22,"value":3003},"SGD 对异步性具有鲁棒性 [61]，许多系统使用异步参数更新训练深度神经网络 [14, 20]。人们认为异步训练具有可扩展性，因为即使存在落后 worker（straggler），也能维持较高吞吐量。提高吞吐量的代价是：训练步骤使用过时的参数值。最近的一些工作重新考察了“同步训练不可扩展”这一假设 [10, 18]。由于 GPU 让训练所需机器数量从数千台降至数百台 [47]，在同一平台上，同步训练达到目标质量的时间可能比异步训练更短。",{"type":16,"tag":28,"props":3005,"children":3006},{},[3007],{"type":22,"value":3008},"尽管我们最初为异步训练设计 TensorFlow，但也开始试验同步方法。TensorFlow 图允许用户改变训练期间读取和写入参数的方式；我们实现了三种替代方案。在异步方案中（图 5(a)），每个 worker 在每个 step 开始时读取参数当前值，并在结束时把梯度应用到（可能已经不同的）当前值上。这种方式保持较高利用率，但每个 step 使用过时参数值，因而单个 step 的效果较差。",{"type":16,"tag":28,"props":3010,"children":3011},{},[3012],{"type":22,"value":3013},"我们使用队列（§3.1）实现同步版本来协调执行：阻塞队列充当屏障，确保所有 worker 读取相同的参数值；每个变量对应一个队列，累积所有 worker 的梯度更新，再原子地应用这些更新。简单同步版本（图 5(b)）会先累积所有 worker 的更新再应用，但慢 worker 会限制总体吞吐量。",{"type":16,"tag":28,"props":3015,"children":3016},{},[3017],{"type":22,"value":3018},"为减轻落后 worker 的影响，我们实现了备用 worker（图 5(c)，见 [10]），其思想类似于 MapReduce 的备用任务 [21]。MapReduce 在检测到落后任务后才反应式地启动备用任务；我们的备用 worker 主动运行，聚合器接收 n 个更新中的前 m 个。我们利用了 SGD 每一步都会随机采样训练数据这一事实：每个 worker 处理不同的随机批次，因此丢弃某一个批次不会造成问题。§6.3 展示了备用 worker 如何把吞吐量提高最多 10%。",{"type":16,"tag":121,"props":3020,"children":3022},{"id":3021},"图-5并行-sgd-的三种同步方案",[3023],{"type":22,"value":3024},"图 5：并行 SGD 的三种同步方案",{"type":16,"tag":28,"props":3026,"children":3027},{},[3028],{"type":16,"tag":326,"props":3029,"children":3034},{"alt":3030,"src":3031,"width":3032,"height":3033},"并行 SGD 的三种同步方案（原文图 5）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-05.webp",1933,450,[],{"type":16,"tag":28,"props":3036,"children":3037},{},[3038],{"type":22,"value":3039},"（a）异步复制；（b）同步复制；（c）带备用 worker 的同步复制。每种颜色代表不同的起始参数值；白色方格表示参数更新。在（c）中，虚线矩形表示其结果会被丢弃的备用 worker。",{"type":16,"tag":58,"props":3041,"children":3043},{"id":3042},"_5-实现",[3044],{"type":22,"value":3045},"5 实现",{"type":16,"tag":28,"props":3047,"children":3048},{},[3049],{"type":22,"value":3050},"TensorFlow 运行时是一个跨平台库。图 6 展示了其架构：C API 把不同语言的用户级代码与核心运行时分开。",{"type":16,"tag":28,"props":3052,"children":3053},{},[3054],{"type":22,"value":3055},"核心 TensorFlow 库用 C++ 实现，以兼顾可移植性和性能。它运行在 Linux、Mac OS X、Windows、Android 和 iOS 等操作系统上，支持 x86 和多种基于 ARM 的 CPU 架构，以及 NVIDIA 的 Kepler、Maxwell 和 Pascal GPU 微架构。该实现是开源的，我们已经接收了多个外部贡献，使 TensorFlow 能够运行在其他架构上。",{"type":16,"tag":28,"props":3057,"children":3058},{},[3059],{"type":22,"value":3060},"分布式 master 把用户请求转换为一组 task 上的执行。给定一个图和 step 定义，它会裁剪（§3.2）并划分（§3.3）该图，为每个参与的设备生成子图，并缓存这些子图以便后续 step 复用。由于 master 能看到一个 step 的整体计算，它可以应用公共子表达式消除和常量折叠等标准优化；裁剪是一种死代码消除。然后，master 协调一组 task 上优化子图的执行。",{"type":16,"tag":28,"props":3062,"children":3063},{},[3064],{"type":22,"value":3065},"每个 task 中的数据流执行器处理 master 发来的请求，并调度组成局部子图的内核执行。我们针对低开销执行大型图优化了数据流执行器。当前实现每秒可以执行 10,000 个子图（§6.2），从而支持大量副本以快速执行细粒度训练步骤。数据流执行器把内核派发到本地设备，并在可能时并行运行内核，例如使用多个 CPU 核心或多个 GPU stream。",{"type":16,"tag":28,"props":3067,"children":3068},{},[3069],{"type":22,"value":3070},"运行时包含 200 多个标准操作，包括数学、数组操作、控制流和状态管理操作。许多操作内核使用 Eigen::Tensor [36] 实现；它使用 C++ 模板为多核 CPU 和 GPU 生成高效并行代码。不过，在有更高效内核实现的场合，我们也广泛使用 cuDNN [13] 等库。我们还实现了量化，使移动设备和数据中心高吞吐应用等环境能够更快地进行推理；并使用 gemmlowp 低精度矩阵库 [35] 加速量化计算。",{"type":16,"tag":28,"props":3072,"children":3073},{},[3074,3076,3081,3082,3087,3089,3095],{"type":22,"value":3075},"我们针对每一种源设备类型和目标设备类型组合，专门实现 ",{"type":16,"tag":348,"props":3077,"children":3079},{"className":3078},[],[3080],{"type":22,"value":1344},{"type":22,"value":1228},{"type":16,"tag":348,"props":3083,"children":3085},{"className":3084},[],[3086],{"type":22,"value":1351},{"type":22,"value":3088}," 操作。本地 CPU 与 GPU 设备之间的传输使用 ",{"type":16,"tag":348,"props":3090,"children":3092},{"className":3091},[],[3093],{"type":22,"value":3094},"cudaMemcpyAsync()",{"type":22,"value":3096}," API，使计算和数据传输重叠；两个本地 GPU 之间的传输使用 DMA，减轻主机压力。task 之间的传输使用多种协议，包括基于 TCP 的 gRPC，以及基于融合以太网的 RDMA。我们还在研究使用集合通信操作优化 GPU 到 GPU 的通信 [59]。",{"type":16,"tag":28,"props":3098,"children":3099},{},[3100],{"type":22,"value":3101},"第 4 节描述的功能完全构建在 C API 之上的用户级代码中。用户通常组合标准操作，构建更高级的抽象，例如神经网络层、优化算法（§4.1）和分片嵌入计算（§4.2）。TensorFlow 支持多种客户端语言；由于内部用户最熟悉 Python 和 C++，我们优先支持这两种语言。某个功能变得稳定后，我们通常会把它移植到 C++，使所有客户端语言都能访问优化后的实现。",{"type":16,"tag":28,"props":3103,"children":3104},{},[3105],{"type":22,"value":3106},"如果某个子计算难以或低效地表示为操作组合，用户可以注册额外内核，用 C++ 提供高效实现。我们发现，为性能关键操作手工实现融合内核很有价值，例如 ReLU 和 Sigmoid 激活函数及其对应梯度。我们目前正在研究基于编译的自动内核融合方法。",{"type":16,"tag":28,"props":3108,"children":3109},{},[3110],{"type":22,"value":3111},"除核心运行时外，我们的同事还构建了多个帮助 TensorFlow 用户的工具。这些工具包括生产环境推理服务基础设施 [27]；用于跟踪训练运行进度的可视化仪表板；帮助用户理解模型连接关系的图可视化器；以及能够跨多个设备和 task 跟踪计算执行的分布式分析器。我们在扩展白皮书 [1] 中描述了这些工具。",{"type":16,"tag":121,"props":3113,"children":3115},{"id":3114},"图-6分层-tensorflow-架构",[3116],{"type":22,"value":3117},"图 6：分层 TensorFlow 架构",{"type":16,"tag":28,"props":3119,"children":3120},{},[3121],{"type":16,"tag":326,"props":3122,"children":3127},{"alt":3123,"src":3124,"width":3125,"height":3126},"TensorFlow 的分层架构（原文图 6）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-06.webp",721,637,[],{"type":16,"tag":28,"props":3129,"children":3130},{},[3131],{"type":22,"value":3132},"从上到下的主要组件包括训练库、推理库、Python\u002FC++ 客户端、C API、分布式 master、数据流执行器、基本操作及其内核实现、RPC\u002FRDMA 与 CPU\u002FGPU 设备、网络层和设备层。",{"type":16,"tag":58,"props":3134,"children":3136},{"id":3135},"_6-评测",[3137],{"type":22,"value":3138},"6 评测",{"type":16,"tag":28,"props":3140,"children":3141},{},[3142],{"type":22,"value":3143},"本节在若干合成工作负载和真实工作负载上评估 TensorFlow 性能。除非另有说明，所有实验都在共享生产集群上运行；图中绘制中位数，误差条表示第 10 和第 90 百分位。",{"type":16,"tag":28,"props":3145,"children":3146},{},[3147],{"type":22,"value":3148},"本文关注系统性能指标，而不是达到准确率所需时间等学习目标。TensorFlow 是一个允许机器学习实践者和研究人员试验新技术的系统；本评测展示了：（i）系统开销很小；（ii）系统可以利用大量计算来加速真实应用。同步复制等技术有时可以让模型用更少的总步骤收敛，但对这类改进的分析留给其他论文。",{"type":16,"tag":121,"props":3150,"children":3152},{"id":3151},"_61-单机基准",[3153],{"type":22,"value":3154},"6.1 单机基准",{"type":16,"tag":28,"props":3156,"children":3157},{},[3158],{"type":22,"value":3159},"虽然 TensorFlow 是“面向大规模”机器学习的系统，但可扩展性不能掩盖小规模下的糟糕性能 [51]。表 1 汇报了 Chintala 对 TensorFlow 及三个单机框架的卷积模型基准测试结果 [15]。所有框架都使用六核 3.5 GHz Intel Core i7-5930K CPU 和 NVIDIA Titan X GPU。",{"type":16,"tag":3161,"props":3162,"children":3164},"h4",{"id":3163},"表-1使用不同库单-gpu-训练四种卷积模型的步时间毫秒",[3165],{"type":22,"value":3166},"表 1：使用不同库、单 GPU 训练四种卷积模型的步时间（毫秒）",{"type":16,"tag":3168,"props":3169,"children":3170},"table",{},[3171,3206],{"type":16,"tag":3172,"props":3173,"children":3174},"thead",{},[3175],{"type":16,"tag":3176,"props":3177,"children":3178},"tr",{},[3179,3185,3191,3196,3201],{"type":16,"tag":3180,"props":3181,"children":3182},"th",{},[3183],{"type":22,"value":3184},"库",{"type":16,"tag":3180,"props":3186,"children":3188},{"align":3187},"right",[3189],{"type":22,"value":3190},"AlexNet",{"type":16,"tag":3180,"props":3192,"children":3193},{"align":3187},[3194],{"type":22,"value":3195},"Overfeat",{"type":16,"tag":3180,"props":3197,"children":3198},{"align":3187},[3199],{"type":22,"value":3200},"OxfordNet",{"type":16,"tag":3180,"props":3202,"children":3203},{"align":3187},[3204],{"type":22,"value":3205},"GoogleNet",{"type":16,"tag":3207,"props":3208,"children":3209},"tbody",{},[3210,3239,3267,3295],{"type":16,"tag":3176,"props":3211,"children":3212},{},[3213,3219,3224,3229,3234],{"type":16,"tag":3214,"props":3215,"children":3216},"td",{},[3217],{"type":22,"value":3218},"Caffe [38]",{"type":16,"tag":3214,"props":3220,"children":3221},{"align":3187},[3222],{"type":22,"value":3223},"324",{"type":16,"tag":3214,"props":3225,"children":3226},{"align":3187},[3227],{"type":22,"value":3228},"823",{"type":16,"tag":3214,"props":3230,"children":3231},{"align":3187},[3232],{"type":22,"value":3233},"1068",{"type":16,"tag":3214,"props":3235,"children":3236},{"align":3187},[3237],{"type":22,"value":3238},"1935",{"type":16,"tag":3176,"props":3240,"children":3241},{},[3242,3247,3252,3257,3262],{"type":16,"tag":3214,"props":3243,"children":3244},{},[3245],{"type":22,"value":3246},"Neon [58]",{"type":16,"tag":3214,"props":3248,"children":3249},{"align":3187},[3250],{"type":22,"value":3251},"87",{"type":16,"tag":3214,"props":3253,"children":3254},{"align":3187},[3255],{"type":22,"value":3256},"211",{"type":16,"tag":3214,"props":3258,"children":3259},{"align":3187},[3260],{"type":22,"value":3261},"320",{"type":16,"tag":3214,"props":3263,"children":3264},{"align":3187},[3265],{"type":22,"value":3266},"270",{"type":16,"tag":3176,"props":3268,"children":3269},{},[3270,3275,3280,3285,3290],{"type":16,"tag":3214,"props":3271,"children":3272},{},[3273],{"type":22,"value":3274},"Torch [17]",{"type":16,"tag":3214,"props":3276,"children":3277},{"align":3187},[3278],{"type":22,"value":3279},"81",{"type":16,"tag":3214,"props":3281,"children":3282},{"align":3187},[3283],{"type":22,"value":3284},"268",{"type":16,"tag":3214,"props":3286,"children":3287},{"align":3187},[3288],{"type":22,"value":3289},"529",{"type":16,"tag":3214,"props":3291,"children":3292},{"align":3187},[3293],{"type":22,"value":3294},"470",{"type":16,"tag":3176,"props":3296,"children":3297},{},[3298,3303,3307,3312,3317],{"type":16,"tag":3214,"props":3299,"children":3300},{},[3301],{"type":22,"value":3302},"TensorFlow",{"type":16,"tag":3214,"props":3304,"children":3305},{"align":3187},[3306],{"type":22,"value":3279},{"type":16,"tag":3214,"props":3308,"children":3309},{"align":3187},[3310],{"type":22,"value":3311},"279",{"type":16,"tag":3214,"props":3313,"children":3314},{"align":3187},[3315],{"type":22,"value":3316},"540",{"type":16,"tag":3214,"props":3318,"children":3319},{"align":3187},[3320],{"type":22,"value":3321},"445",{"type":16,"tag":28,"props":3323,"children":3324},{},[3325],{"type":22,"value":3326},"所有结果均使用 32 位浮点数训练；每个模型的最快时间在原表中以粗体标出。",{"type":16,"tag":28,"props":3328,"children":3329},{},[3330],{"type":22,"value":3331},"表 1 表明，TensorFlow 的步时间比 Caffe [38] 更短，性能与最新版本 Torch [17] 相差不超过 6%。我们把 TensorFlow 与 Torch 的相近性能归因于两者使用相同版本的 cuDNN 库 [13]；该库实现了训练关键路径上的卷积和池化操作。Caffe 使用这些操作的开源实现，代码更简单，但效率低于 cuDNN。Neon 库 [58] 在其中三个模型上优于 TensorFlow，这是因为它使用汇编语言实现的手工优化卷积内核 [46]。原则上，我们也可以在 TensorFlow 中采用相同方法，但目前尚未这样做。",{"type":16,"tag":121,"props":3333,"children":3335},{"id":3334},"_62-同步副本微基准",[3336],{"type":22,"value":3337},"6.2 同步副本微基准",{"type":16,"tag":28,"props":3339,"children":3340},{},[3341],{"type":22,"value":3342},"我们的协调实现（§4.4）是使用更多机器进行扩展时的主要限制因素。图 7 展示了不同模型大小和不同同步 worker 数量下，TensorFlow 每秒执行的空训练步骤数。在一个空训练步骤中，worker 从 16 个 PS task 获取共享模型参数，执行简单计算，再向参数发送更新。",{"type":16,"tag":28,"props":3344,"children":3345},{},[3346],{"type":22,"value":3347},"图 7 中的 Scalar 曲线显示了同步训练步骤理论上能够达到的最佳性能，因为它只从每个 PS task 获取一个 4 字节值。单 worker 时，中位数步时间为 1.8 ms；100 个 worker 时增加到 8.8 ms。这些时间衡量了同步机制的开销，也包含在共享集群上运行时预期会出现的一些噪声。",{"type":16,"tag":28,"props":3349,"children":3350},{},[3351],{"type":22,"value":3352},"Dense 曲线显示 worker 获取整个模型时空步骤的性能。我们分别使用大小为 100 MB 和 1 GB 的模型进行实验，并把参数均匀分片到 16 个 PS task。对于 100 MB 模型，中位数步时间从单 worker 的 147 ms 增加到 100 worker 的 613 ms；对于 1 GB 模型，则从单 worker 的 1.01 s 增加到 100 worker 的 7.16 s。",{"type":16,"tag":28,"props":3354,"children":3355},{},[3356],{"type":22,"value":3357},"对于大型模型，典型训练步骤只访问参数子集；Sparse 曲线展示了 §4.2 中嵌入查找操作的吞吐量。每个 worker 从包含 1 GB 或 16 GB 数据的大型嵌入矩阵中随机选择 32 个条目。正如预期，步时间不随嵌入矩阵大小变化，TensorFlow 的步时间范围为 5–20 ms。",{"type":16,"tag":121,"props":3359,"children":3361},{"id":3360},"图-7空模型同步复制的基线吞吐量",[3362],{"type":22,"value":3363},"图 7：空模型同步复制的基线吞吐量",{"type":16,"tag":28,"props":3365,"children":3366},{},[3367],{"type":16,"tag":326,"props":3368,"children":3372},{"alt":3369,"src":3370,"width":1526,"height":3371},"空模型同步复制的基线吞吐量（原文图 7）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-07.webp",609,[],{"type":16,"tag":28,"props":3374,"children":3375},{},[3376],{"type":22,"value":3377},"稀疏访问使 TensorFlow 能够处理更大的模型，例如嵌入矩阵（§4.2）。横轴为 worker 数量，纵轴为 batches\u002Fsecond；曲线分别表示 Scalar、Sparse 1GB、Sparse 16GB、Dense 100M 和 Dense 1GB。",{"type":16,"tag":121,"props":3379,"children":3381},{"id":3380},"_63-图像分类",[3382],{"type":22,"value":3383},"6.3 图像分类",{"type":16,"tag":28,"props":3385,"children":3386},{},[3387],{"type":22,"value":3388},"深度神经网络在图像中的目标识别等计算机视觉任务上取得了突破性性能 [44]；这些任务也是 TensorFlow 在 Google 的主要应用。训练一个高准确率网络需要大量计算，我们使用 TensorFlow 把计算扩展到由 GPU 服务器组成的集群上。在这些实验中，我们重点研究 Google 的 Inception-v3 模型。该模型在 ILSVRC 2012 图像分类挑战赛中达到了 78.8% 的准确率 [69]；同样的技术也适用于在 TensorFlow 上实现的其他深度卷积模型，例如 ResNet [28]。我们使用多个副本研究 Inception-v3 的训练可扩展性。TensorFlow 配置为 7 个 PS task，并在两个不同集群上改变 worker task 数量。",{"type":16,"tag":28,"props":3390,"children":3391},{},[3392],{"type":22,"value":3393},"第一个实验比较 TensorFlow 和 MXNet（一个使用参数服务器架构的同期系统）在使用异步 SGD 训练 Inception 时的性能。实验使用 Google Compute Engine 虚拟机；虚拟机运行在配备 NVIDIA K80 GPU 的 Intel Xeon E5 服务器上，配置为 8 个 vCPU、16 Gbps 网络带宽，每台虚拟机一个 GPU。两个系统都使用运行在独立、无 GPU 虚拟机上的 7 个 PS task。图 8(a) 显示 TensorFlow 的性能略优于 MXNet。正如预期，结果主要由单 GPU 性能决定；两个系统都使用 cuDNN 5.1，因此拥有相同的优化 GPU 内核。",{"type":16,"tag":28,"props":3395,"children":3396},{},[3397],{"type":22,"value":3398},"我们使用更大的内部集群（配备 NVIDIA K40 GPU，并通过共享数据中心网络连接）研究协调机制（§4.4）对训练性能的影响。理想情况下，如果同步训练高效，Inception-v3 这样的模型会用更少步骤训练，并且比异步训练达到更高准确率 [10]。当 worker 数量增加到 200 时，训练吞吐量提高到每秒 2,300 张图像，但收益逐渐递减（图 8(b)）。worker 越多，step 时间越长，因为 PS task 的网络接口以及更新聚合都会产生更多竞争。正如预期，在所有配置下，同步 step 都比异步 step 长，因为所有 worker 必须等待最慢 worker 赶上后才能开始下一步。",{"type":16,"tag":28,"props":3400,"children":3401},{},[3402],{"type":22,"value":3403},"在 worker 数量相同的情况下，中位数同步 step 比异步 step 大约长 10%；但超过第 90 百分位后，同步性能会急剧下降，因为落后 worker 对尾延迟的影响很大。",{"type":16,"tag":28,"props":3405,"children":3406},{},[3407],{"type":22,"value":3408},"为了降低尾延迟，我们加入备用 worker，使得某个 step 在 n 个 task 中的前 m 个产生梯度后就完成。图 8(c) 展示了在 50 个 worker 的 Inception 训练作业中加入备用 worker 的效果。增加备用 worker（包括第 4 个）会降低中位数 step 时间，因为落后 worker 影响 step 的概率变小。加入第 5 个备用 worker 后性能略有下降，因为第 51 个 worker（其结果会被丢弃的第一个 worker）更可能不是落后 worker，从而为 PS task 产生更多输入流量。",{"type":16,"tag":28,"props":3410,"children":3411},{},[3412],{"type":22,"value":3413},"图 8(c) 还绘制了归一化加速比，其定义为",{"type":16,"tag":574,"props":3415,"children":3417},{"className":3416},[891],[3418],{"type":16,"tag":574,"props":3419,"children":3421},{"className":3420},[577],[3422,3516],{"type":16,"tag":574,"props":3423,"children":3425},{"className":3424},[582],[3426],{"type":16,"tag":585,"props":3427,"children":3428},{"xmlns":587,"display":903},[3429],{"type":16,"tag":590,"props":3430,"children":3431},{},[3432,3511],{"type":16,"tag":594,"props":3433,"children":3434},{},[3435,3479,3483,3506],{"type":16,"tag":1818,"props":3436,"children":3437},{},[3438,3460],{"type":16,"tag":594,"props":3439,"children":3440},{},[3441,3446,3451,3455],{"type":16,"tag":598,"props":3442,"children":3443},{},[3444],{"type":22,"value":3445},"t",{"type":16,"tag":604,"props":3447,"children":3448},{"stretchy":937},[3449],{"type":22,"value":3450},"(",{"type":16,"tag":598,"props":3452,"children":3453},{},[3454],{"type":22,"value":2321},{"type":16,"tag":604,"props":3456,"children":3457},{"stretchy":937},[3458],{"type":22,"value":3459},")",{"type":16,"tag":594,"props":3461,"children":3462},{},[3463,3467,3471,3475],{"type":16,"tag":598,"props":3464,"children":3465},{},[3466],{"type":22,"value":3445},{"type":16,"tag":604,"props":3468,"children":3469},{"stretchy":937},[3470],{"type":22,"value":3450},{"type":16,"tag":610,"props":3472,"children":3473},{},[3474],{"type":22,"value":614},{"type":16,"tag":604,"props":3476,"children":3477},{"stretchy":937},[3478],{"type":22,"value":3459},{"type":16,"tag":604,"props":3480,"children":3481},{},[3482],{"type":22,"value":1816},{"type":16,"tag":1818,"props":3484,"children":3485},{},[3486,3491],{"type":16,"tag":610,"props":3487,"children":3488},{},[3489],{"type":22,"value":3490},"50",{"type":16,"tag":594,"props":3492,"children":3493},{},[3494,3498,3502],{"type":16,"tag":610,"props":3495,"children":3496},{},[3497],{"type":22,"value":3490},{"type":16,"tag":604,"props":3499,"children":3500},{},[3501],{"type":22,"value":979},{"type":16,"tag":598,"props":3503,"children":3504},{},[3505],{"type":22,"value":2321},{"type":16,"tag":604,"props":3507,"children":3508},{"separator":626},[3509],{"type":22,"value":3510},",",{"type":16,"tag":616,"props":3512,"children":3513},{"encoding":618},[3514],{"type":22,"value":3515},"\\frac{t(b)}{t(0)} \\times \\frac{50}{50+b},",{"type":16,"tag":574,"props":3517,"children":3519},{"className":3518,"ariaHidden":626},[625],[3520,3661],{"type":16,"tag":574,"props":3521,"children":3523},{"className":3522},[631],[3524,3529,3648,3652,3657],{"type":16,"tag":574,"props":3525,"children":3528},{"className":3526,"style":3527},[636],"height:2.363em;vertical-align:-0.936em;",[],{"type":16,"tag":574,"props":3530,"children":3532},{"className":3531},[642],[3533,3537,3644],{"type":16,"tag":574,"props":3534,"children":3536},{"className":3535},[1073,1994],[],{"type":16,"tag":574,"props":3538,"children":3540},{"className":3539},[1818],[3541],{"type":16,"tag":574,"props":3542,"children":3544},{"className":3543},[1030,2003],[3545,3632],{"type":16,"tag":574,"props":3546,"children":3548},{"className":3547},[1035],[3549,3627],{"type":16,"tag":574,"props":3550,"children":3553},{"className":3551,"style":3552},[1040],"height:1.427em;",[3554,3585,3596],{"type":16,"tag":574,"props":3555,"children":3556},{"style":2016},[3557,3561],{"type":16,"tag":574,"props":3558,"children":3560},{"className":3559,"style":2021},[1050],[],{"type":16,"tag":574,"props":3562,"children":3564},{"className":3563},[642],[3565,3570,3575,3580],{"type":16,"tag":574,"props":3566,"children":3568},{"className":3567},[642,643],[3569],{"type":22,"value":3445},{"type":16,"tag":574,"props":3571,"children":3573},{"className":3572},[1073],[3574],{"type":22,"value":3450},{"type":16,"tag":574,"props":3576,"children":3578},{"className":3577},[642],[3579],{"type":22,"value":614},{"type":16,"tag":574,"props":3581,"children":3583},{"className":3582},[1085],[3584],{"type":22,"value":3459},{"type":16,"tag":574,"props":3586,"children":3587},{"style":2039},[3588,3592],{"type":16,"tag":574,"props":3589,"children":3591},{"className":3590,"style":2021},[1050],[],{"type":16,"tag":574,"props":3593,"children":3595},{"className":3594,"style":2049},[2048],[],{"type":16,"tag":574,"props":3597,"children":3598},{"style":2053},[3599,3603],{"type":16,"tag":574,"props":3600,"children":3602},{"className":3601,"style":2021},[1050],[],{"type":16,"tag":574,"props":3604,"children":3606},{"className":3605},[642],[3607,3612,3617,3622],{"type":16,"tag":574,"props":3608,"children":3610},{"className":3609},[642,643],[3611],{"type":22,"value":3445},{"type":16,"tag":574,"props":3613,"children":3615},{"className":3614},[1073],[3616],{"type":22,"value":3450},{"type":16,"tag":574,"props":3618,"children":3620},{"className":3619},[642,643],[3621],{"type":22,"value":2321},{"type":16,"tag":574,"props":3623,"children":3625},{"className":3624},[1085],[3626],{"type":22,"value":3459},{"type":16,"tag":574,"props":3628,"children":3630},{"className":3629},[2076],[3631],{"type":22,"value":2079},{"type":16,"tag":574,"props":3633,"children":3635},{"className":3634},[1035],[3636],{"type":16,"tag":574,"props":3637,"children":3640},{"className":3638,"style":3639},[1040],"height:0.936em;",[3641],{"type":16,"tag":574,"props":3642,"children":3643},{},[],{"type":16,"tag":574,"props":3645,"children":3647},{"className":3646},[1085,1994],[],{"type":16,"tag":574,"props":3649,"children":3651},{"className":3650,"style":1137},[649],[],{"type":16,"tag":574,"props":3653,"children":3655},{"className":3654},[1142],[3656],{"type":22,"value":1816},{"type":16,"tag":574,"props":3658,"children":3660},{"className":3659,"style":1137},[649],[],{"type":16,"tag":574,"props":3662,"children":3664},{"className":3663},[631],[3665,3670,3777],{"type":16,"tag":574,"props":3666,"children":3669},{"className":3667,"style":3668},[636],"height:2.0908em;vertical-align:-0.7693em;",[],{"type":16,"tag":574,"props":3671,"children":3673},{"className":3672},[642],[3674,3678,3773],{"type":16,"tag":574,"props":3675,"children":3677},{"className":3676},[1073,1994],[],{"type":16,"tag":574,"props":3679,"children":3681},{"className":3680},[1818],[3682],{"type":16,"tag":574,"props":3683,"children":3685},{"className":3684},[1030,2003],[3686,3761],{"type":16,"tag":574,"props":3687,"children":3689},{"className":3688},[1035],[3690,3756],{"type":16,"tag":574,"props":3691,"children":3694},{"className":3692,"style":3693},[1040],"height:1.3214em;",[3695,3729,3740],{"type":16,"tag":574,"props":3696,"children":3697},{"style":2016},[3698,3702],{"type":16,"tag":574,"props":3699,"children":3701},{"className":3700,"style":2021},[1050],[],{"type":16,"tag":574,"props":3703,"children":3705},{"className":3704},[642],[3706,3711,3715,3720,3724],{"type":16,"tag":574,"props":3707,"children":3709},{"className":3708},[642],[3710],{"type":22,"value":3490},{"type":16,"tag":574,"props":3712,"children":3714},{"className":3713,"style":1137},[649],[],{"type":16,"tag":574,"props":3716,"children":3718},{"className":3717},[1142],[3719],{"type":22,"value":979},{"type":16,"tag":574,"props":3721,"children":3723},{"className":3722,"style":1137},[649],[],{"type":16,"tag":574,"props":3725,"children":3727},{"className":3726},[642,643],[3728],{"type":22,"value":2321},{"type":16,"tag":574,"props":3730,"children":3731},{"style":2039},[3732,3736],{"type":16,"tag":574,"props":3733,"children":3735},{"className":3734,"style":2021},[1050],[],{"type":16,"tag":574,"props":3737,"children":3739},{"className":3738,"style":2049},[2048],[],{"type":16,"tag":574,"props":3741,"children":3742},{"style":2053},[3743,3747],{"type":16,"tag":574,"props":3744,"children":3746},{"className":3745,"style":2021},[1050],[],{"type":16,"tag":574,"props":3748,"children":3750},{"className":3749},[642],[3751],{"type":16,"tag":574,"props":3752,"children":3754},{"className":3753},[642],[3755],{"type":22,"value":3490},{"type":16,"tag":574,"props":3757,"children":3759},{"className":3758},[2076],[3760],{"type":22,"value":2079},{"type":16,"tag":574,"props":3762,"children":3764},{"className":3763},[1035],[3765],{"type":16,"tag":574,"props":3766,"children":3769},{"className":3767,"style":3768},[1040],"height:0.7693em;",[3770],{"type":16,"tag":574,"props":3771,"children":3772},{},[],{"type":16,"tag":574,"props":3774,"children":3776},{"className":3775},[1085,1994],[],{"type":16,"tag":574,"props":3778,"children":3781},{"className":3779},[3780],"mpunct",[3782],{"type":22,"value":3510},{"type":16,"tag":28,"props":3784,"children":3785},{},[3786],{"type":22,"value":3787},"其中 t(b) 是加入 b 个备用 worker 时的中位数 step 时间；该指标根据额外资源消耗的比例折算加速比。加入 4 个备用 worker 可获得最短总 step 时间（1.93 s）；加入 3 个备用 worker 则取得最高归一化加速比（9.5%），因此到达同样质量所消耗的 GPU 时间更少。",{"type":16,"tag":121,"props":3789,"children":3791},{"id":3790},"图-8inception-v3-训练性能评测结果63",[3792],{"type":22,"value":3793},"图 8：Inception-v3 训练性能评测结果（§6.3）",{"type":16,"tag":28,"props":3795,"children":3796},{},[3797],{"type":16,"tag":326,"props":3798,"children":3803},{"alt":3799,"src":3800,"width":3801,"height":3802},"Inception-v3 训练性能评测（原文图 8）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-08.webp",1938,496,[],{"type":16,"tag":28,"props":3805,"children":3806},{},[3807],{"type":22,"value":3808},"（a）TensorFlow 的异步训练吞吐量略高于 MXNet；（b）异步和同步训练的吞吐量最多可扩展到 200 个 worker；（c）向 50-worker 训练作业加入备用 worker 可以降低总 step 时间，即使按资源消耗归一化后仍能提升性能。",{"type":16,"tag":121,"props":3810,"children":3812},{"id":3811},"_64-语言建模",[3813],{"type":22,"value":3814},"6.4 语言建模",{"type":16,"tag":28,"props":3816,"children":3817},{},[3818],{"type":22,"value":3819},"给定一个单词序列，语言模型预测最可能出现的下一个单词 [6]。因此，语言模型是预测文本、语音识别和机器翻译应用的重要组成部分。本实验研究 TensorFlow 如何训练循环神经网络（LSTM-512-512 [41]），以对 One Billion Word Benchmark 文本 [9] 建模。",{"type":16,"tag":28,"props":3821,"children":3822},{},[3823],{"type":22,"value":3824},"词表大小 |V| 限制了训练性能，因为最后一层必须把输出状态解码成 |V| 个类别的概率 [37]。相应参数可能很大（输出状态维度为 d 时，大小为 |V|×d），因此我们使用 §4.2 中处理大模型的技术。为了实验较小配置，我们使用最常见的 40,000 个单词组成的受限词表，而不是完整的 800,000 个单词词表 [9]。",{"type":16,"tag":28,"props":3826,"children":3827},{},[3828],{"type":22,"value":3829},"图 9 展示了不同 PS task 数量和 worker task 数量下的训练吞吐量（以每秒处理的单词数计），以及两种 softmax 实现。",{"type":16,"tag":28,"props":3831,"children":3832},{},[3833],{"type":22,"value":3834},"完整 softmax（图 9(a)）把每个输出乘以一个 512×40,000 的权重矩阵，该矩阵被分片到 PS task 上。增加 PS task 会提高吞吐量，因为 TensorFlow 可以利用分布式模型并行 [20, 43]，并在 PS task 上执行乘法和梯度计算，就像 Project Adam [14] 一样。从 1 个 PS task 增加到 2 个的效果，比把 worker 从 4 增加到 32，或从 32 增加到 256 更明显。最终吞吐量会饱和，因为 LSTM 计算成为训练 step 的主导部分。",{"type":16,"tag":28,"props":3836,"children":3837},{},[3838],{"type":22,"value":3839},"采样 softmax（图 9(b)）减少了 PS task 上的数据传输和计算量 [37]。它不使用稠密权重矩阵，而是把输出乘以一个随机稀疏矩阵；该矩阵包含真实类别和随机采样错误类别的权重。我们为每个批次采样 512 个类别，使 softmax 的数据传输和计算量减少 78 倍。",{"type":16,"tag":121,"props":3841,"children":3843},{"id":3842},"图-9语言模型训练中的-softmax-吞吐量",[3844],{"type":22,"value":3845},"图 9：语言模型训练中的 softmax 吞吐量",{"type":16,"tag":28,"props":3847,"children":3848},{},[3849],{"type":16,"tag":326,"props":3850,"children":3854},{"alt":3851,"src":3852,"width":3853,"height":3802},"语言模型训练中的 softmax 吞吐量（原文图 9）","\u002Fimages\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow\u002Ffigure-09.webp",942,[],{"type":16,"tag":28,"props":3856,"children":3857},{},[3858],{"type":22,"value":3859},"增加 PS task 数量可以并行化 softmax 计算，从而提高吞吐量。采样 softmax 通过减少计算量进一步提高吞吐量。（a）完整 softmax；（b）采样 softmax。纵轴为每秒处理单词数，曲线对应 4、32、256 个 worker；横轴为 PS task 数量。",{"type":16,"tag":58,"props":3861,"children":3863},{"id":3862},"_7-结论",[3864],{"type":22,"value":3865},"7 结论",{"type":16,"tag":28,"props":3867,"children":3868},{},[3869],{"type":22,"value":3870},"本文介绍了 TensorFlow 系统及其编程模型。TensorFlow 的数据流表示包含了已有参数服务器系统的能力，并提供一组统一抽象，使用户能够利用大规模异构系统，既完成生产任务，也能试验新方法。我们展示了 TensorFlow 编程模型如何促进试验（§4），并证明由此得到的实现具备性能和可扩展性（§6）。",{"type":16,"tag":28,"props":3872,"children":3873},{},[3874],{"type":22,"value":3875},"我们对 TensorFlow 的初步经验令人鼓舞。Google 的许多团队已经将 TensorFlow 部署到生产环境，TensorFlow 也帮助研究同事在机器学习方面取得新进展。自从我们把 TensorFlow 作为开源软件发布以来，已有超过 14,000 人 fork 源代码仓库，二进制发行版下载量超过一百万次，数十个使用 TensorFlow 的机器学习模型已经发表。",{"type":16,"tag":28,"props":3877,"children":3878},{},[3879],{"type":22,"value":3880},"TensorFlow 仍在不断发展。它灵活的数据流表示让高级用户能够达到出色性能，但我们还没有确定适用于所有用户的默认策略。对自动优化的进一步研究应当弥合这一差距。在系统层面，我们正在积极开发自动放置、内核融合、内存管理和调度算法。当前的可变状态和容错实现足以支持具有弱一致性要求的应用，但我们预计某些 TensorFlow 应用会需要更强的一致性，并正在研究如何在用户层构建这些策略。最后，一些用户已经开始感到静态数据流图存在限制，尤其是在深度强化学习等算法中 [54]。因此，我们面临一个有趣的问题：即使计算结构是动态展开的，如何仍然提供一个能够透明、高效地使用分布式资源的系统。",{"type":16,"tag":58,"props":3882,"children":3884},{"id":3883},"致谢",[3885],{"type":22,"value":3883},{"type":16,"tag":28,"props":3887,"children":3888},{},[3889],{"type":22,"value":3890},"我们衷心感谢 Google 同事以及更广泛机器学习社区成员的贡献。特别感谢 Google Brain 团队其他成员以及 DistBelief 和 TensorFlow 众多用户给予的反馈。我们也感谢匿名 OSDI 审稿人和 shepherd KyoungSoo Park 提出的建议，这些建议大幅改进了本文的呈现。",{"type":16,"tag":58,"props":3892,"children":3894},{"id":3893},"参考文献",[3895],{"type":22,"value":3893},{"type":16,"tag":28,"props":3897,"children":3898},{},[3899],{"type":22,"value":3900},"作者姓名、会议\u002F期刊名称、年份、页码和网址保留原文格式；论文题名附中文翻译，引用编号与原文一致。",{"type":16,"tag":28,"props":3902,"children":3903},{},[3904,3906,3911,3913],{"type":22,"value":3905},"[1] M. Abadi 等：",{"type":16,"tag":146,"props":3907,"children":3908},{},[3909],{"type":22,"value":3910},"TensorFlow：异构分布式系统上的大规模机器学习",{"type":22,"value":3912},"（TensorFlow: Large-scale machine learning on heterogeneous distributed systems）。arXiv 预印本 1603.04467，2016。",{"type":16,"tag":44,"props":3914,"children":3917},{"href":3915,"rel":3916},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1603.04467%E3%80%82%E8%BD%AF%E4%BB%B6%E5%9C%B0%E5%9D%80%EF%BC%9Ahttps:\u002F\u002Ftensorflow.org%E3%80%82",[48],[3918],{"type":22,"value":3919},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1603.04467。软件地址：https:\u002F\u002Ftensorflow.org。",{"type":16,"tag":28,"props":3921,"children":3922},{},[3923,3925,3930,3932],{"type":22,"value":3924},"[2] R. Al-Rfou 等：",{"type":16,"tag":146,"props":3926,"children":3927},{},[3928],{"type":22,"value":3929},"Theano：用于快速计算数学表达式的 Python 框架",{"type":22,"value":3931},"（Theano: A Python framework for fast computation of mathematical expressions）。arXiv 预印本 1605.02688，2016。",{"type":16,"tag":44,"props":3933,"children":3936},{"href":3934,"rel":3935},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1605.02688%E3%80%82",[48],[3937],{"type":22,"value":3938},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1605.02688。",{"type":16,"tag":28,"props":3940,"children":3941},{},[3942,3944,3949,3951],{"type":22,"value":3943},"[3] A. Angelova、A. Krizhevsky、V. Vanhoucke：",{"type":16,"tag":146,"props":3945,"children":3946},{},[3947],{"type":22,"value":3948},"使用大视野深度网络进行行人检测",{"type":22,"value":3950},"（Pedestrian detection with a large-field-of-view deep network）。ICRA 论文集，第 704–711 页，IEEE，2015。",{"type":16,"tag":44,"props":3952,"children":3955},{"href":3953,"rel":3954},"http:\u002F\u002Fwww.vision.caltech.edu\u002Fanelia\u002Fpublications\u002FAngelova15LFOV.pdf%E3%80%82",[48],[3956],{"type":22,"value":3957},"www.vision.caltech.edu\u002Fanelia\u002Fpublications\u002FAngelova15LFOV.pdf。",{"type":16,"tag":28,"props":3959,"children":3960},{},[3961,3963,3968,3970],{"type":22,"value":3962},"[4] Arvind、D. E. Culler：",{"type":16,"tag":146,"props":3964,"children":3965},{},[3966],{"type":22,"value":3967},"数据流架构",{"type":22,"value":3969},"（Dataflow architectures）。《Annual Review of Computer Science》第 1 卷，225–253 页，Annual Reviews Inc.，1986。",{"type":16,"tag":44,"props":3971,"children":3974},{"href":3972,"rel":3973},"http:\u002F\u002Fwww.dtic.mil\u002Fcgi-bin\u002FGetTRDoc?Location=U2&doc=GetTRDoc.pdf&AD=ADA166235%E3%80%82",[48],[3975],{"type":22,"value":3976},"www.dtic.mil\u002Fcgi-bin\u002FGetTRDoc?Location=U2&doc=GetTRDoc.pdf&AD=ADA166235。",{"type":16,"tag":28,"props":3978,"children":3979},{},[3980,3982,3987,3989],{"type":22,"value":3981},"[5] J. Ba、V. Mnih、D. Kavukcuoglu：",{"type":16,"tag":146,"props":3983,"children":3984},{},[3985],{"type":22,"value":3986},"利用视觉注意力识别多个目标",{"type":22,"value":3988},"（Multiple object recognition with visual attention）。arXiv 预印本 1412.7755，2014。",{"type":16,"tag":44,"props":3990,"children":3993},{"href":3991,"rel":3992},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1412.7755%E3%80%82",[48],[3994],{"type":22,"value":3995},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1412.7755。",{"type":16,"tag":28,"props":3997,"children":3998},{},[3999,4001,4006],{"type":22,"value":4000},"[6] Y. Bengio、R. Ducharme、P. Vincent、C. Jauvin：",{"type":16,"tag":146,"props":4002,"children":4003},{},[4004],{"type":22,"value":4005},"神经概率语言模型",{"type":22,"value":4007},"（A neural probabilistic language model）。《Journal of Machine Learning Research》3:1137–1155，2003。jmlr.org\u002Fpapers\u002Fvolume3\u002Fbengio03a\u002Fbengio03a.pdf。",{"type":16,"tag":28,"props":4009,"children":4010},{},[4011,4013,4018],{"type":22,"value":4012},"[7] T. Brants、A. Franz：",{"type":16,"tag":146,"props":4014,"children":4015},{},[4016],{"type":22,"value":4017},"Web 1T 五元语法第 1 版",{"type":22,"value":4019},"（Web 1T 5-gram version 1），2006。catalog.ldc.upenn.edu\u002FLDC2006T13。",{"type":16,"tag":28,"props":4021,"children":4022},{},[4023,4025,4030,4032],{"type":22,"value":4024},"[8] R. H. Byrd、G. M. Chin、J. Nocedal、Y. Wu：",{"type":16,"tag":146,"props":4026,"children":4027},{},[4028],{"type":22,"value":4029},"机器学习优化方法中的样本规模选择",{"type":22,"value":4031},"（Sample size selection in optimization methods for machine learning）。《Mathematical Programming》134(1):127–155，2012。",{"type":16,"tag":44,"props":4033,"children":4036},{"href":4034,"rel":4035},"https:\u002F\u002Fdoi.org\u002F10.1007\u002Fs10107-012-0572-5%E3%80%82",[48],[4037],{"type":22,"value":4038},"https:\u002F\u002Fdoi.org\u002F10.1007\u002Fs10107-012-0572-5。",{"type":16,"tag":28,"props":4040,"children":4041},{},[4042,4044,4049,4051],{"type":22,"value":4043},"[9] C. Chelba、T. Mikolov、M. Schuster、Q. Ge、T. Brants、P. Koehn：",{"type":16,"tag":146,"props":4045,"children":4046},{},[4047],{"type":22,"value":4048},"用于衡量统计语言模型进展的十亿词基准",{"type":22,"value":4050},"（One billion word benchmark for measuring progress in statistical language modeling）。arXiv 预印本 1312.3005，2013。",{"type":16,"tag":44,"props":4052,"children":4055},{"href":4053,"rel":4054},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1312.3005%E3%80%82",[48],[4056],{"type":22,"value":4057},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1312.3005。",{"type":16,"tag":28,"props":4059,"children":4060},{},[4061,4063,4068,4070],{"type":22,"value":4062},"[10] J. Chen、R. Monga、S. Bengio、R. Jozefowicz：",{"type":16,"tag":146,"props":4064,"children":4065},{},[4066],{"type":22,"value":4067},"重新审视分布式同步 SGD",{"type":22,"value":4069},"（Revisiting distributed synchronous SGD）。ICLR Workshop Track 论文集，2016。",{"type":16,"tag":44,"props":4071,"children":4074},{"href":4072,"rel":4073},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1604.00981%E3%80%82",[48],[4075],{"type":22,"value":4076},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1604.00981。",{"type":16,"tag":28,"props":4078,"children":4079},{},[4080,4082,4087,4089],{"type":22,"value":4081},"[11] T. Chen、M. Li、Y. Li、M. Lin、N. Wang、M. Wang、T. Xiao、B. Xu、C. Zhang、Z. Zhang：",{"type":16,"tag":146,"props":4083,"children":4084},{},[4085],{"type":22,"value":4086},"MXNet：面向异构分布式系统的灵活高效机器学习库",{"type":22,"value":4088},"（MXNet: A flexible and efficient machine learning library for heterogeneous distributed systems）。LearningSys 论文集，2015。",{"type":16,"tag":44,"props":4090,"children":4093},{"href":4091,"rel":4092},"http:\u002F\u002Fwww.cs.cmu.edu\u002F~muli\u002Ffile\u002Fmxnet-learning-sys.pdf%E3%80%82",[48],[4094],{"type":22,"value":4095},"www.cs.cmu.edu\u002F~muli\u002Ffile\u002Fmxnet-learning-sys.pdf。",{"type":16,"tag":28,"props":4097,"children":4098},{},[4099,4101,4106],{"type":22,"value":4100},"[12] H.-T. Cheng 等：",{"type":16,"tag":146,"props":4102,"children":4103},{},[4104],{"type":22,"value":4105},"用于推荐系统的宽而深学习",{"type":22,"value":4107},"（Wide & deep learning for recommender systems）。arXiv 预印本 1606.07792，2016。",{"type":16,"tag":28,"props":4109,"children":4110},{},[4111,4113,4118,4120],{"type":22,"value":4112},"[13] S. Chetlur 等：",{"type":16,"tag":146,"props":4114,"children":4115},{},[4116],{"type":22,"value":4117},"cuDNN：深度学习的高效原语",{"type":22,"value":4119},"（cuDNN: Efficient primitives for deep learning）。arXiv 预印本 1410.0759，2014。",{"type":16,"tag":44,"props":4121,"children":4124},{"href":4122,"rel":4123},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1410.0759%E3%80%82",[48],[4125],{"type":22,"value":4126},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1410.0759。",{"type":16,"tag":28,"props":4128,"children":4129},{},[4130,4132,4137,4139],{"type":22,"value":4131},"[14] T. Chilimbi、Y. Suzue、J. Apacible、K. Kalyanaraman：",{"type":16,"tag":146,"props":4133,"children":4134},{},[4135],{"type":22,"value":4136},"Project Adam：构建高效且可扩展的深度学习训练系统",{"type":22,"value":4138},"（Project Adam: Building an efficient and scalable deep learning training system）。OSDI 论文集，571–582 页，2014。",{"type":16,"tag":44,"props":4140,"children":4143},{"href":4141,"rel":4142},"http:\u002F\u002Fwww.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fosdi14\u002Fosdi14-paper-chilimbi.pdf%E3%80%82",[48],[4144],{"type":22,"value":4145},"www.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fosdi14\u002Fosdi14-paper-chilimbi.pdf。",{"type":16,"tag":28,"props":4147,"children":4148},{},[4149,4151,4156],{"type":22,"value":4150},"[15] S. Chintala：",{"type":16,"tag":146,"props":4152,"children":4153},{},[4154],{"type":22,"value":4155},"convnet-benchmarks",{"type":22,"value":4157},"，2016。github.com\u002Fsoumith\u002Fconvnet-benchmarks。",{"type":16,"tag":28,"props":4159,"children":4160},{},[4161,4163,4168,4170],{"type":22,"value":4162},"[16] E. S. Chung、J. D. Davis、J. Lee：",{"type":16,"tag":146,"props":4164,"children":4165},{},[4166],{"type":22,"value":4167},"LINQits：小型客户端上的大数据",{"type":22,"value":4169},"（LINQits: Big data on little clients）。ISCA 论文集，261–272 页，2013。",{"type":16,"tag":44,"props":4171,"children":4174},{"href":4172,"rel":4173},"http:\u002F\u002Fwww.microsoft.com\u002Fen-us\u002Fresearch\u002Fwp-content\u002Fuploads\u002F2013\u002F06\u002FISCA13-linqits.pdf%E3%80%82",[48],[4175],{"type":22,"value":4176},"www.microsoft.com\u002Fen-us\u002Fresearch\u002Fwp-content\u002Fuploads\u002F2013\u002F06\u002FISCA13-linqits.pdf。",{"type":16,"tag":28,"props":4178,"children":4179},{},[4180,4182,4187],{"type":22,"value":4181},"[17] R. Collobert、S. Bengio、J. Marithoz：",{"type":16,"tag":146,"props":4183,"children":4184},{},[4185],{"type":22,"value":4186},"Torch：模块化机器学习软件库",{"type":22,"value":4188},"（Torch: A modular machine learning software library）。IDIAP 技术报告，2002。infoscience.epfl.ch\u002Frecord\u002F82802\u002Ffiles\u002Frr02-46.pdf。",{"type":16,"tag":28,"props":4190,"children":4191},{},[4192,4194,4199,4201],{"type":22,"value":4193},"[18] H. Cui、H. Zhang、G. R. Ganger、P. B. Gibbons、E. P. Xing：",{"type":16,"tag":146,"props":4195,"children":4196},{},[4197],{"type":22,"value":4198},"GeePS：使用 GPU 专用参数服务器的可扩展分布式 GPU 深度学习",{"type":22,"value":4200},"（GeePS: Scalable deep learning on distributed GPUs with a GPU-specialized parameter server）。EuroSys 论文集，2016。",{"type":16,"tag":44,"props":4202,"children":4205},{"href":4203,"rel":4204},"http:\u002F\u002Fwww.pdl.cmu.edu\u002FPDL-FTP\u002FCloudComputing\u002FGeePS-cui-eurosys16.pdf%E3%80%82",[48],[4206],{"type":22,"value":4207},"www.pdl.cmu.edu\u002FPDL-FTP\u002FCloudComputing\u002FGeePS-cui-eurosys16.pdf。",{"type":16,"tag":28,"props":4209,"children":4210},{},[4211,4213,4218,4220],{"type":22,"value":4212},"[19] A. Dai、C. Olah、Q. V. Le：",{"type":16,"tag":146,"props":4214,"children":4215},{},[4216],{"type":22,"value":4217},"使用段落向量进行文档嵌入",{"type":22,"value":4219},"（Document embedding with paragraph vectors）。arXiv 预印本 1507.07998，2015。",{"type":16,"tag":44,"props":4221,"children":4224},{"href":4222,"rel":4223},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1507.07998%E3%80%82",[48],[4225],{"type":22,"value":4226},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1507.07998。",{"type":16,"tag":28,"props":4228,"children":4229},{},[4230,4232,4237],{"type":22,"value":4231},"[20] J. Dean 等：",{"type":16,"tag":146,"props":4233,"children":4234},{},[4235],{"type":22,"value":4236},"大规模分布式深度网络",{"type":22,"value":4238},"（Large scale distributed deep networks）。NIPS 论文集，1232–1240 页，2012。research.google.com\u002Farchive\u002Flarge_​​deep_networks_nips2012.pdf。",{"type":16,"tag":28,"props":4240,"children":4241},{},[4242,4244,4249],{"type":22,"value":4243},"[21] J. Dean、S. Ghemawat：",{"type":16,"tag":146,"props":4245,"children":4246},{},[4247],{"type":22,"value":4248},"MapReduce：简化大规模集群上的数据处理",{"type":22,"value":4250},"（MapReduce: Simplified data processing on large clusters）。OSDI 论文集，137–149 页，2004。research.google.com\u002Farchive\u002Fmapreduce-osdi04.pdf。",{"type":16,"tag":28,"props":4252,"children":4253},{},[4254,4256,4261],{"type":22,"value":4255},"[22] DMLC：",{"type":16,"tag":146,"props":4257,"children":4258},{},[4259],{"type":22,"value":4260},"用于深度学习的 MXNet",{"type":22,"value":4262},"（MXNet for deep learning），2016。github.com\u002Fdmlc\u002Fmxnet。",{"type":16,"tag":28,"props":4264,"children":4265},{},[4266,4268,4273],{"type":22,"value":4267},"[23] J. Duchi、E. Hazan、Y. Singer：",{"type":16,"tag":146,"props":4269,"children":4270},{},[4271],{"type":22,"value":4272},"在线学习和随机优化的自适应次梯度方法",{"type":22,"value":4274},"（Adaptive subgradient methods for online learning and stochastic optimization）。《Journal of Machine Learning Research》12:2121–2159，2011。jmlr.org\u002Fpapers\u002Fvolume12\u002Fduchi11a\u002Fduchi11a.pdf。",{"type":16,"tag":28,"props":4276,"children":4277},{},[4278,4280,4285],{"type":22,"value":4279},"[24] A. Frome 等：",{"type":16,"tag":146,"props":4281,"children":4282},{},[4283],{"type":22,"value":4284},"DeVISE：深度视觉—语义嵌入模型",{"type":22,"value":4286},"（DeVISE: A deep visual-semantic embedding model）。NIPS 论文集，2121–2129 页，2013。research.google.com\u002Fpubs\u002Farchive\u002F41473.pdf。",{"type":16,"tag":28,"props":4288,"children":4289},{},[4290,4292,4297],{"type":22,"value":4291},"[25] J. Gonzalez-Dominguez、I. Lopez-Moreno、P. J. Moreno、J. Gonzalez-Rodriguez：",{"type":16,"tag":146,"props":4293,"children":4294},{},[4295],{"type":22,"value":4296},"使用深度神经网络对短语音逐帧进行语言识别",{"type":22,"value":4298},"（Frame-by-frame language identification in short utterances using deep neural networks）。《Neural Networks》64:49–58，2015。research.google.com\u002Fpubs\u002Farchive\u002F42929.pdf。",{"type":16,"tag":28,"props":4300,"children":4301},{},[4302,4304,4309],{"type":22,"value":4303},"[26] I. J. Goodfellow 等：",{"type":16,"tag":146,"props":4305,"children":4306},{},[4307],{"type":22,"value":4308},"生成对抗网络",{"type":22,"value":4310},"（Generative adversarial nets）。NIPS 论文集，2672–2680 页，2014。papers.nips.cc\u002Fpaper\u002F5423-generative-adversarial-nets.pdf。",{"type":16,"tag":28,"props":4312,"children":4313},{},[4314,4316,4321],{"type":22,"value":4315},"[27] Google Research：",{"type":16,"tag":146,"props":4317,"children":4318},{},[4319],{"type":22,"value":4320},"TensorFlow Serving",{"type":22,"value":4322},"，2016。tensorflow.github.io\u002Fserving\u002F。",{"type":16,"tag":28,"props":4324,"children":4325},{},[4326,4328,4333,4335],{"type":22,"value":4327},"[28] K. He、X. Zhang、S. Ren、J. Sun：",{"type":16,"tag":146,"props":4329,"children":4330},{},[4331],{"type":22,"value":4332},"用于图像识别的深度残差学习",{"type":22,"value":4334},"（Deep residual learning for image recognition）。CVPR 论文集，770–778 页，2016。",{"type":16,"tag":44,"props":4336,"children":4339},{"href":4337,"rel":4338},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1512.03385%E3%80%82",[48],[4340],{"type":22,"value":4341},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1512.03385。",{"type":16,"tag":28,"props":4343,"children":4344},{},[4345,4347,4352],{"type":22,"value":4346},"[29] G. Heigold 等：",{"type":16,"tag":146,"props":4348,"children":4349},{},[4350],{"type":22,"value":4351},"使用分布式深度神经网络的多语言声学模型",{"type":22,"value":4353},"（Multilingual acoustic models using distributed deep neural networks）。ICASSP 论文集，8619–8623 页，2013。research.google.com\u002Fpubs\u002Farchive\u002F40807.pdf。",{"type":16,"tag":28,"props":4355,"children":4356},{},[4357,4359,4364,4366],{"type":22,"value":4358},"[30] G. E. Hinton：",{"type":16,"tag":146,"props":4360,"children":4361},{},[4362],{"type":22,"value":4363},"学习概念的分布式表示",{"type":22,"value":4365},"（Learning distributed representations of concepts）。第八届认知科学学会年会论文集，1–12 页，1986。",{"type":16,"tag":44,"props":4367,"children":4370},{"href":4368,"rel":4369},"http:\u002F\u002Fwww.cogsci.ucsd.edu\u002F~ajyu\u002FTeaching\u002FCogs202-sp13\u002FReadings\u002Fhinton86.pdf%E3%80%82",[48],[4371],{"type":22,"value":4372},"www.cogsci.ucsd.edu\u002F~ajyu\u002FTeaching\u002FCogs202-sp13\u002FReadings\u002Fhinton86.pdf。",{"type":16,"tag":28,"props":4374,"children":4375},{},[4376,4378,4383,4385],{"type":22,"value":4377},"[31] G. E. Hinton 等：",{"type":16,"tag":146,"props":4379,"children":4380},{},[4381],{"type":22,"value":4382},"语音识别声学建模的深度神经网络：四个研究小组的共同观点",{"type":22,"value":4384},"（Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups）。《IEEE Signal Processing Magazine》29(6):82–97，2012。",{"type":16,"tag":44,"props":4386,"children":4389},{"href":4387,"rel":4388},"http:\u002F\u002Fwww.cs.toronto.edu\u002F~gdahl\u002Fpapers\u002FdeepSpeechReviewSPM2012.pdf%E3%80%82",[48],[4390],{"type":22,"value":4391},"www.cs.toronto.edu\u002F~gdahl\u002Fpapers\u002FdeepSpeechReviewSPM2012.pdf。",{"type":16,"tag":28,"props":4393,"children":4394},{},[4395,4397,4402],{"type":22,"value":4396},"[32] S. Hochreiter、J. Schmidhuber：",{"type":16,"tag":146,"props":4398,"children":4399},{},[4400],{"type":22,"value":4401},"长短期记忆",{"type":22,"value":4403},"（Long short-term memory）。《Neural Computation》9(8):1735–1780，1997。deeplearning.cs.cmu.edu\u002Fpdfs\u002FHochreiter97-lstm.pdf。",{"type":16,"tag":28,"props":4405,"children":4406},{},[4407,4409,4414],{"type":22,"value":4408},"[33] S. Ioffe、C. Szegedy：",{"type":16,"tag":146,"props":4410,"children":4411},{},[4412],{"type":22,"value":4413},"批归一化：通过减少内部协变量偏移加速深度网络训练",{"type":22,"value":4415},"（Batch normalization: Accelerating deep network training by reducing internal covariate shift）。ICML 论文集，448–456 页，2015。jmlr.org\u002Fproceedings\u002Fpapers\u002Fv37\u002Fioffe15.pdf。",{"type":16,"tag":28,"props":4417,"children":4418},{},[4419,4421,4426,4428],{"type":22,"value":4420},"[34] M. Isard、M. Budiu、Y. Yu、A. Birrell、D. Fetterly：",{"type":16,"tag":146,"props":4422,"children":4423},{},[4424],{"type":22,"value":4425},"Dryad：由顺序构件组成的分布式数据并行程序",{"type":22,"value":4427},"（Dryad: Distributed data-parallel programs from sequential building blocks）。EuroSys 论文集，59–72 页，2007。",{"type":16,"tag":44,"props":4429,"children":4432},{"href":4430,"rel":4431},"http:\u002F\u002Fwww.microsoft.com\u002Fen-us\u002Fresearch\u002Fwp-content\u002Fuploads\u002F2007\u002F03\u002Feurosys07.pdf%E3%80%82",[48],[4433],{"type":22,"value":4434},"www.microsoft.com\u002Fen-us\u002Fresearch\u002Fwp-content\u002Fuploads\u002F2007\u002F03\u002Feurosys07.pdf。",{"type":16,"tag":28,"props":4436,"children":4437},{},[4438,4440,4445],{"type":22,"value":4439},"[35] B. Jacob 等：",{"type":16,"tag":146,"props":4441,"children":4442},{},[4443],{"type":22,"value":4444},"gemmlowp：小型自包含低精度 GEMM 库",{"type":22,"value":4446},"（gemmlowp: A small self-contained low-precision GEMM library），2015。github.com\u002Fgoogle\u002Fgemmlowp。",{"type":16,"tag":28,"props":4448,"children":4449},{},[4450,4452,4457],{"type":22,"value":4451},"[36] B. Jacob、G. Guennebaud 等：",{"type":16,"tag":146,"props":4453,"children":4454},{},[4455],{"type":22,"value":4456},"Eigen 线性代数库",{"type":22,"value":4458},"（Eigen library for linear algebra）。eigen.tuxfamily.org。",{"type":16,"tag":28,"props":4460,"children":4461},{},[4462,4464,4469,4471],{"type":22,"value":4463},"[37] S. Jean、K. Cho、R. Memisevic、Y. Bengio：",{"type":16,"tag":146,"props":4465,"children":4466},{},[4467],{"type":22,"value":4468},"在神经机器翻译中使用超大目标词表",{"type":22,"value":4470},"（On using very large target vocabulary for neural machine translation）。ACL-IJCNLP 论文集，1–10 页，2015 年 7 月。",{"type":16,"tag":44,"props":4472,"children":4475},{"href":4473,"rel":4474},"http:\u002F\u002Fwww.aclweb.org\u002Fanthology\u002FP15-1001%E3%80%82",[48],[4476],{"type":22,"value":4477},"www.aclweb.org\u002Fanthology\u002FP15-1001。",{"type":16,"tag":28,"props":4479,"children":4480},{},[4481,4483,4488,4490],{"type":22,"value":4482},"[38] Y. Jia 等：",{"type":16,"tag":146,"props":4484,"children":4485},{},[4486],{"type":22,"value":4487},"Caffe：用于快速特征嵌入的卷积架构",{"type":22,"value":4489},"（Caffe: Convolutional architecture for fast feature embedding）。ACM Multimedia 论文集，675–678 页，2014。",{"type":16,"tag":44,"props":4491,"children":4494},{"href":4492,"rel":4493},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1408.5093%E3%80%82",[48],[4495],{"type":22,"value":4496},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1408.5093。",{"type":16,"tag":28,"props":4498,"children":4499},{},[4500,4502,4507],{"type":22,"value":4501},"[39] M. I. Jordan：",{"type":16,"tag":146,"props":4503,"children":4504},{},[4505],{"type":22,"value":4506},"串行顺序：一种并行分布式处理方法",{"type":22,"value":4508},"（Serial order: A parallel distributed processing approach）。ICS 报告 8608，加州大学圣迭戈分校认知科学研究所，1986。cseweb.ucsd.edu\u002F~gary\u002FPAPER-SUGGESTIONS\u002FJordan-TR-8604.pdf。",{"type":16,"tag":28,"props":4510,"children":4511},{},[4512,4514,4519],{"type":22,"value":4513},"[40] N. Jouppi：",{"type":16,"tag":146,"props":4515,"children":4516},{},[4517],{"type":22,"value":4518},"Google 使用 TPU 定制芯片大幅加速机器学习任务",{"type":22,"value":4520},"（Google supercharges machine learning tasks with TPU custom chip），2016。cloudplatform.googleblog.com\u002F2016\u002F05\u002FGoogle-supercharges-machine-learning-tasks-with-custom-chip.html。",{"type":16,"tag":28,"props":4522,"children":4523},{},[4524,4526,4531,4533],{"type":22,"value":4525},"[41] R. Józefowicz、O. Vinyals、M. Schuster、N. Shazeer、Y. Wu：",{"type":16,"tag":146,"props":4527,"children":4528},{},[4529],{"type":22,"value":4530},"探索语言建模的极限",{"type":22,"value":4532},"（Exploring the limits of language modeling）。arXiv 预印本 1602.02410，2016。",{"type":16,"tag":44,"props":4534,"children":4537},{"href":4535,"rel":4536},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1602.02410%E3%80%82",[48],[4538],{"type":22,"value":4539},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1602.02410。",{"type":16,"tag":28,"props":4541,"children":4542},{},[4543,4545,4550],{"type":22,"value":4544},"[42] A. Karpathy、G. Toderici、S. Shetty、T. Leung、R. Sukthankar、L. Fei-Fei：",{"type":16,"tag":146,"props":4546,"children":4547},{},[4548],{"type":22,"value":4549},"使用卷积神经网络进行大规模视频分类",{"type":22,"value":4551},"（Large-scale video classification with convolutional neural networks）。CVPR 论文集，1725–1732 页，2014。research.google.com\u002Fpubs\u002Farchive\u002F42455.pdf。",{"type":16,"tag":28,"props":4553,"children":4554},{},[4555,4557,4562,4564],{"type":22,"value":4556},"[43] A. Krizhevsky：",{"type":16,"tag":146,"props":4558,"children":4559},{},[4560],{"type":22,"value":4561},"并行化卷积神经网络的一个奇妙技巧",{"type":22,"value":4563},"（One weird trick for parallelizing convolutional neural networks）。arXiv 预印本 1404.5997，2014。",{"type":16,"tag":44,"props":4565,"children":4568},{"href":4566,"rel":4567},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1404.5997%E3%80%82",[48],[4569],{"type":22,"value":4570},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1404.5997。",{"type":16,"tag":28,"props":4572,"children":4573},{},[4574,4576,4581],{"type":22,"value":4575},"[44] A. Krizhevsky、I. Sutskever、G. E. Hinton：",{"type":16,"tag":146,"props":4577,"children":4578},{},[4579],{"type":22,"value":4580},"使用深度卷积神经网络进行 ImageNet 分类",{"type":22,"value":4582},"（ImageNet classification with deep convolutional neural networks）。NIPS 论文集，1106–1114 页，2012。papers.nips.cc\u002Fpaper\u002F4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf。",{"type":16,"tag":28,"props":4584,"children":4585},{},[4586,4588,4593],{"type":22,"value":4587},"[45] H. Larochelle、Y. Bengio、J. Louradour、P. Lamblin：",{"type":16,"tag":146,"props":4589,"children":4590},{},[4591],{"type":22,"value":4592},"探索训练深度神经网络的策略",{"type":22,"value":4594},"（Exploring strategies for training deep neural networks）。《Journal of Machine Learning Research》10:1–40，2009。jmlr.org\u002Fpapers\u002Fvolume10\u002Flarochelle09a\u002Flarochelle09a.pdf。",{"type":16,"tag":28,"props":4596,"children":4597},{},[4598,4600,4605,4607],{"type":22,"value":4599},"[46] A. Lavin、S. Gray：",{"type":16,"tag":146,"props":4601,"children":4602},{},[4603],{"type":22,"value":4604},"卷积神经网络的快速算法",{"type":22,"value":4606},"（Fast algorithms for convolutional neural networks）。CVPR 论文集，4013–4021 页，2016。",{"type":16,"tag":44,"props":4608,"children":4611},{"href":4609,"rel":4610},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1509.09308%E3%80%82",[48],[4612],{"type":22,"value":4613},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1509.09308。",{"type":16,"tag":28,"props":4615,"children":4616},{},[4617,4619,4624],{"type":22,"value":4618},"[47] Q. Le、M. Ranzato、R. Monga、M. Devin、G. Corrado、K. Chen、J. Dean、A. Ng：",{"type":16,"tag":146,"props":4620,"children":4621},{},[4622],{"type":22,"value":4623},"通过大规模无监督学习构建高级特征",{"type":22,"value":4625},"（Building high-level features using large scale unsupervised learning）。ICML 论文集，81–88 页，2012。research.google.com\u002Farchive\u002Funsupervised-icml2012.pdf。",{"type":16,"tag":28,"props":4627,"children":4628},{},[4629,4631,4636],{"type":22,"value":4630},"[48] Y. LeCun、C. Cortes、C. J. Burges：",{"type":16,"tag":146,"props":4632,"children":4633},{},[4634],{"type":22,"value":4635},"MNIST 手写数字数据库",{"type":22,"value":4637},"（The MNIST database of handwritten digits），1998。yann.lecun.com\u002Fexdb\u002Fmnist\u002F。",{"type":16,"tag":28,"props":4639,"children":4640},{},[4641,4643,4648,4650],{"type":22,"value":4642},"[49] M. Li、D. G. Andersen、J. Park、A. J. Smola、A. Ahmed、V. Josifovski、J. Long、E. J. Shekita、B.-Y. Su：",{"type":16,"tag":146,"props":4644,"children":4645},{},[4646],{"type":22,"value":4647},"使用参数服务器扩展分布式机器学习",{"type":22,"value":4649},"（Scaling distributed machine learning with the Parameter Server）。OSDI 论文集，583–598 页，2014。",{"type":16,"tag":44,"props":4651,"children":4654},{"href":4652,"rel":4653},"http:\u002F\u002Fwww.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fosdi14\u002Fosdi14-paper-li_mu.pdf%E3%80%82",[48],[4655],{"type":22,"value":4656},"www.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fosdi14\u002Fosdi14-paper-li_mu.pdf。",{"type":16,"tag":28,"props":4658,"children":4659},{},[4660,4662,4667,4669],{"type":22,"value":4661},"[50] C. J. Maddison、A. Huang、I. Sutskever、D. Silver：",{"type":16,"tag":146,"props":4663,"children":4664},{},[4665],{"type":22,"value":4666},"使用深度卷积神经网络进行围棋落子评估",{"type":22,"value":4668},"（Move evaluation in Go using deep convolutional neural networks）。arXiv 预印本 1412.6564，2014。",{"type":16,"tag":44,"props":4670,"children":4673},{"href":4671,"rel":4672},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1412.6564%E3%80%82",[48],[4674],{"type":22,"value":4675},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1412.6564。",{"type":16,"tag":28,"props":4677,"children":4678},{},[4679,4681,4686,4688],{"type":22,"value":4680},"[51] F. McSherry、M. Isard、D. G. Murray：",{"type":16,"tag":146,"props":4682,"children":4683},{},[4684],{"type":22,"value":4685},"可扩展性！但代价是什么？",{"type":22,"value":4687},"（Scalability! But at what COST?）。HotOS（HOTOS’15）论文集，2015。",{"type":16,"tag":44,"props":4689,"children":4692},{"href":4690,"rel":4691},"http:\u002F\u002Fwww.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fhotos15\u002Fhotos15-paper-mcsherry.pdf%E3%80%82",[48],[4693],{"type":22,"value":4694},"www.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fhotos15\u002Fhotos15-paper-mcsherry.pdf。",{"type":16,"tag":28,"props":4696,"children":4697},{},[4698,4700,4705,4707],{"type":22,"value":4699},"[52] T. Mikolov、K. Chen、G. Corrado、J. Dean：",{"type":16,"tag":146,"props":4701,"children":4702},{},[4703],{"type":22,"value":4704},"向量空间中词表示的高效估计",{"type":22,"value":4706},"（Efficient estimation of word representations in vector space）。ICLR Workshops Track 论文集，2013。",{"type":16,"tag":44,"props":4708,"children":4711},{"href":4709,"rel":4710},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1301.3781%E3%80%82",[48],[4712],{"type":22,"value":4713},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1301.3781。",{"type":16,"tag":28,"props":4715,"children":4716},{},[4717,4719,4724],{"type":22,"value":4718},"[53] V. Mnih、N. Heess、A. Graves、K. Kavukcuoglu：",{"type":16,"tag":146,"props":4720,"children":4721},{},[4722],{"type":22,"value":4723},"视觉注意力的循环模型",{"type":22,"value":4725},"（Recurrent models of visual attention）。NIPS 论文集，2204–2212 页，2014。papers.nips.cc\u002Fpaper\u002F5542-recurrent-models-of-visual-attention.pdf。",{"type":16,"tag":28,"props":4727,"children":4728},{},[4729,4731,4736,4738],{"type":22,"value":4730},"[54] V. Mnih 等：",{"type":16,"tag":146,"props":4732,"children":4733},{},[4734],{"type":22,"value":4735},"通过深度强化学习实现人类级控制",{"type":22,"value":4737},"（Human-level control through deep reinforcement learning）。《Nature》518(7540):529–533，2015。",{"type":16,"tag":44,"props":4739,"children":4742},{"href":4740,"rel":4741},"https:\u002F\u002Fdoi.org\u002F10.1038\u002Fnature14236%E3%80%82",[48],[4743],{"type":22,"value":4744},"https:\u002F\u002Fdoi.org\u002F10.1038\u002Fnature14236。",{"type":16,"tag":28,"props":4746,"children":4747},{},[4748,4750,4755,4757],{"type":22,"value":4749},"[55] P. Moritz、R. Nishihara、I. Stoica、M. I. Jordan：",{"type":16,"tag":146,"props":4751,"children":4752},{},[4753],{"type":22,"value":4754},"SparkNet：在 Spark 中训练深度网络",{"type":22,"value":4756},"（SparkNet: Training deep networks in Spark）。ICLR 论文集，2016。",{"type":16,"tag":44,"props":4758,"children":4761},{"href":4759,"rel":4760},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1511.06051%E3%80%82",[48],[4762],{"type":22,"value":4763},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1511.06051。",{"type":16,"tag":28,"props":4765,"children":4766},{},[4767,4769,4774],{"type":22,"value":4768},"[56] D. G. Murray、F. McSherry、M. Isard、R. Isaacs、P. Barham、M. Abadi：",{"type":16,"tag":146,"props":4770,"children":4771},{},[4772],{"type":22,"value":4773},"使用及时数据流进行增量式迭代数据处理",{"type":22,"value":4775},"（Incremental, iterative data processing with timely dataflow）。《Communications of the ACM》59(10):75–83，2016。dl.acm.org\u002Fcitation.cfm?id=2983551。",{"type":16,"tag":28,"props":4777,"children":4778},{},[4779,4781,4786,4788],{"type":22,"value":4780},"[57] A. Nair 等：",{"type":16,"tag":146,"props":4782,"children":4783},{},[4784],{"type":22,"value":4785},"深度强化学习的大规模并行方法",{"type":22,"value":4787},"（Massively parallel methods for deep reinforcement learning）。arXiv 预印本 1507.04296，2015。",{"type":16,"tag":44,"props":4789,"children":4792},{"href":4790,"rel":4791},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1507.04296%E3%80%82",[48],[4793],{"type":22,"value":4794},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1507.04296。",{"type":16,"tag":28,"props":4796,"children":4797},{},[4798,4800,4805],{"type":22,"value":4799},"[58] Nervana Systems：",{"type":16,"tag":146,"props":4801,"children":4802},{},[4803],{"type":22,"value":4804},"Neon 深度学习框架",{"type":22,"value":4806},"（Neon deep learning framework），2016。github.com\u002FNervanaSystems\u002Fneon。",{"type":16,"tag":28,"props":4808,"children":4809},{},[4810,4812,4817],{"type":22,"value":4811},"[59] NVIDIA Corporation：",{"type":16,"tag":146,"props":4813,"children":4814},{},[4815],{"type":22,"value":4816},"NCCL：优化的多 GPU 集合通信原语",{"type":22,"value":4818},"（NCCL: Optimized primitives for collective multi-GPU communication），2016。github.com\u002FNVIDIA\u002Fnccl。",{"type":16,"tag":28,"props":4820,"children":4821},{},[4822,4824,4829],{"type":22,"value":4823},"[60] R. Pascanu、T. Mikolov、Y. Bengio：",{"type":16,"tag":146,"props":4825,"children":4826},{},[4827],{"type":22,"value":4828},"训练循环神经网络的困难",{"type":22,"value":4830},"（On the difficulty of training recurrent neural networks）。ICML 论文集，1310–1318 页，2013。jmlr.org\u002Fproceedings\u002Fpapers\u002Fv28\u002Fpascanu13.pdf。",{"type":16,"tag":28,"props":4832,"children":4833},{},[4834,4836,4841],{"type":22,"value":4835},"[61] B. Recht、C. Re、S. Wright、F. Niu：",{"type":16,"tag":146,"props":4837,"children":4838},{},[4839],{"type":22,"value":4840},"Hogwild：一种无锁并行随机梯度下降方法",{"type":22,"value":4842},"（Hogwild: A lock-free approach to parallelizing stochastic gradient descent）。NIPS 论文集，693–701 页，2011。papers.nips.cc\u002Fpaper\u002F4390-hogwild-a-lock-free-approach-to-parallelizing-stochastic-gradient-descent.pdf。",{"type":16,"tag":28,"props":4844,"children":4845},{},[4846,4848,4853],{"type":22,"value":4847},"[62] C. J. Rossbach、Y. Yu、J. Currey、J.-P. Martin、D. Fetterly：",{"type":16,"tag":146,"props":4849,"children":4850},{},[4851],{"type":22,"value":4852},"Dandelion：面向异构系统的编译器和运行时",{"type":22,"value":4854},"（Dandelion: A compiler and runtime for heterogeneous systems）。SOSP 论文集，49–68 页，2013。sigops.org\u002Fsosp\u002Fsosp13\u002Fpapers\u002Fp49-rossbach.pdf。",{"type":16,"tag":28,"props":4856,"children":4857},{},[4858,4860,4865,4867],{"type":22,"value":4859},"[63] D. E. Rumelhart、G. E. Hinton、R. J. Williams：",{"type":16,"tag":146,"props":4861,"children":4862},{},[4863],{"type":22,"value":4864},"通过反向传播误差学习表示",{"type":22,"value":4866},"（Learning representations by back-propagating errors）。《Cognitive modeling》第 5 卷，213–220 页，MIT Press，1988。",{"type":16,"tag":44,"props":4868,"children":4871},{"href":4869,"rel":4870},"http:\u002F\u002Fwww.cs.toronto.edu\u002F~hinton\u002Fabsps\u002Fnaturebp.pdf%E3%80%82",[48],[4872],{"type":22,"value":4873},"www.cs.toronto.edu\u002F~hinton\u002Fabsps\u002Fnaturebp.pdf。",{"type":16,"tag":28,"props":4875,"children":4876},{},[4877,4879,4884,4886],{"type":22,"value":4878},"[64] O. Russakovsky 等：",{"type":16,"tag":146,"props":4880,"children":4881},{},[4882],{"type":22,"value":4883},"ImageNet 大规模视觉识别挑战赛",{"type":22,"value":4885},"（ImageNet Large Scale Visual Recognition Challenge）。《International Journal of Computer Vision》115(3):211–252，2015。",{"type":16,"tag":44,"props":4887,"children":4890},{"href":4888,"rel":4889},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1409.0575%E3%80%82",[48],[4891],{"type":22,"value":4892},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1409.0575。",{"type":16,"tag":28,"props":4894,"children":4895},{},[4896,4898,4903],{"type":22,"value":4897},"[65] A. Smola、S. Narayanamurthy：",{"type":16,"tag":146,"props":4899,"children":4900},{},[4901],{"type":22,"value":4902},"并行主题模型的架构",{"type":22,"value":4904},"（An architecture for parallel topic models）。《Proceedings of the VLDB Endowment》3(1–2):703–710，2010。vldb.org\u002Fpvldb\u002Fvldb2010\u002Fpapers\u002FR63.pdf。",{"type":16,"tag":28,"props":4906,"children":4907},{},[4908,4910,4915],{"type":22,"value":4909},"[66] I. Sutskever、J. Martens、G. E. Dahl、G. E. Hinton：",{"type":16,"tag":146,"props":4911,"children":4912},{},[4913],{"type":22,"value":4914},"初始化和动量在深度学习中的重要性",{"type":22,"value":4916},"（On the importance of initialization and momentum in deep learning）。ICML 论文集，1139–1147 页，2013。jmlr.org\u002Fproceedings\u002Fpapers\u002Fv28\u002Fsutskever13.pdf。",{"type":16,"tag":28,"props":4918,"children":4919},{},[4920,4922,4927],{"type":22,"value":4921},"[67] I. Sutskever、O. Vinyals、Q. V. Le：",{"type":16,"tag":146,"props":4923,"children":4924},{},[4925],{"type":22,"value":4926},"使用神经网络进行序列到序列学习",{"type":22,"value":4928},"（Sequence to sequence learning with neural networks）。NIPS 论文集，3104–3112 页，2014。papers.nips.cc\u002Fpaper\u002F5346-sequence-to-sequence-learning-with-neural.pdf。",{"type":16,"tag":28,"props":4930,"children":4931},{},[4932,4934,4939,4941],{"type":22,"value":4933},"[68] C. Szegedy 等：",{"type":16,"tag":146,"props":4935,"children":4936},{},[4937],{"type":22,"value":4938},"使用卷积深入网络",{"type":22,"value":4940},"（Going deeper with convolutions）。CVPR 论文集，1–9 页，2015。",{"type":16,"tag":44,"props":4942,"children":4945},{"href":4943,"rel":4944},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1409.4842%E3%80%82",[48],[4946],{"type":22,"value":4947},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1409.4842。",{"type":16,"tag":28,"props":4949,"children":4950},{},[4951,4953,4958,4960],{"type":22,"value":4952},"[69] C. Szegedy、V. Vanhoucke、S. Ioffe、J. Shlens、Z. Wojna：",{"type":16,"tag":146,"props":4954,"children":4955},{},[4956],{"type":22,"value":4957},"重新思考 Inception 视觉架构",{"type":22,"value":4959},"（Rethinking the Inception architecture for computer vision）。arXiv 预印本 1512.00567，2015。",{"type":16,"tag":44,"props":4961,"children":4964},{"href":4962,"rel":4963},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1512.00567%E3%80%82",[48],[4965],{"type":22,"value":4966},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1512.00567。",{"type":16,"tag":28,"props":4968,"children":4969},{},[4970,4972,4977],{"type":22,"value":4971},"[70] C. tao Chu、S. K. Kim、Y. an Lin、Y. Yu、G. Bradski、K. Olukotun、A. Y. Ng：",{"type":16,"tag":146,"props":4973,"children":4974},{},[4975],{"type":22,"value":4976},"多核上的机器学习 MapReduce",{"type":22,"value":4978},"（Map-reduce for machine learning on multicore）。NIPS 论文集，281–288 页，2007。papers.nips.cc\u002Fpaper\u002F3150-map-reduce-for-machine-learning-on-multicore.pdf。",{"type":16,"tag":28,"props":4980,"children":4981},{},[4982,4984,4989],{"type":22,"value":4983},"[71] A. Verma、L. Pedrosa、M. Korupolu、D. Oppenheimer、E. Tune、J. Wilkes：",{"type":16,"tag":146,"props":4985,"children":4986},{},[4987],{"type":22,"value":4988},"Google 的大规模集群管理：Borg",{"type":22,"value":4990},"（Large-scale cluster management at Google with Borg）。EuroSys 论文集，2015。research.google.com\u002Fpubs\u002Farchive\u002F43438.pdf。",{"type":16,"tag":28,"props":4992,"children":4993},{},[4994,4996,5001,5003],{"type":22,"value":4995},"[72] O. Vinyals、L. Kaiser、T. Koo、S. Petrov、I. Sutskever、G. Hinton：",{"type":16,"tag":146,"props":4997,"children":4998},{},[4999],{"type":22,"value":5000},"把语法当作外语",{"type":22,"value":5002},"（Grammar as a foreign language）。arXiv 预印本，2014。",{"type":16,"tag":44,"props":5004,"children":5007},{"href":5005,"rel":5006},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1412.7449%E3%80%82",[48],[5008],{"type":22,"value":5009},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1412.7449。",{"type":16,"tag":28,"props":5011,"children":5012},{},[5013,5015,5020,5022],{"type":22,"value":5014},"[73] Y. Wu 等：",{"type":16,"tag":146,"props":5016,"children":5017},{},[5018],{"type":22,"value":5019},"Google 神经机器翻译系统：弥合人机翻译差距",{"type":22,"value":5021},"（Google’s Neural Machine Translation system: Bridging the gap between human and machine translation）。arXiv 预印本 1609.08144，2016。",{"type":16,"tag":44,"props":5023,"children":5026},{"href":5024,"rel":5025},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1609.08144%E3%80%82",[48],[5027],{"type":22,"value":5028},"https:\u002F\u002Farxiv.org\u002Fabs\u002F1609.08144。",{"type":16,"tag":28,"props":5030,"children":5031},{},[5032,5034,5039,5041],{"type":22,"value":5033},"[74] Y. Yu、M. Isard、D. Fetterly、M. Budiu、U. Erlingsson、P. K. Gunda、J. Currey：",{"type":16,"tag":146,"props":5035,"children":5036},{},[5037],{"type":22,"value":5038},"DryadLINQ：使用高级语言进行通用分布式数据并行计算的系统",{"type":22,"value":5040},"（DryadLINQ: A system for general-purpose distributed data-parallel computing using a high-level language）。OSDI 论文集，1–14 页，2008。",{"type":16,"tag":44,"props":5042,"children":5045},{"href":5043,"rel":5044},"http:\u002F\u002Fwww.usenix.org\u002Flegacy\u002Fevent\u002Fosdi08\u002Ftech\u002Ffull_papers\u002Fyu_y\u002Fyu_y.pdf%E3%80%82",[48],[5046],{"type":22,"value":5047},"www.usenix.org\u002Flegacy\u002Fevent\u002Fosdi08\u002Ftech\u002Ffull_papers\u002Fyu_y\u002Fyu_y.pdf。",{"type":16,"tag":28,"props":5049,"children":5050},{},[5051,5053,5058,5060],{"type":22,"value":5052},"[75] M. Zaharia、M. Chowdhury、T. Das、A. Dave、J. Ma、M. McCauley、M. J. Franklin、S. Shenker、I. Stoica：",{"type":16,"tag":146,"props":5054,"children":5055},{},[5056],{"type":22,"value":5057},"弹性分布式数据集：内存集群计算的容错抽象",{"type":22,"value":5059},"（Resilient distributed datasets: A fault-tolerant abstraction for in-memory cluster computing）。NSDI 论文集，15–28 页，2012。",{"type":16,"tag":44,"props":5061,"children":5064},{"href":5062,"rel":5063},"http:\u002F\u002Fwww.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fnsdi12\u002Fnsdi12-final138.pdf%E3%80%82",[48],[5065],{"type":22,"value":5066},"www.usenix.org\u002Fsystem\u002Ffiles\u002Fconference\u002Fnsdi12\u002Fnsdi12-final138.pdf。",{"type":16,"tag":28,"props":5068,"children":5069},{},[5070,5072,5077],{"type":22,"value":5071},"[76] M. D. Zeiler、M. Ranzato、R. Monga、M. Mao、K. Yang、Q. Le、P. Nguyen、A. Senior、V. Vanhoucke、G. E. Hinton：",{"type":16,"tag":146,"props":5073,"children":5074},{},[5075],{"type":22,"value":5076},"用于语音处理的修正线性单元",{"type":22,"value":5078},"（On rectified linear units for speech processing）。ICASSP 论文集，3517–3521 页，2013。research.google.com\u002Fpubs\u002Farchive\u002F40811.pdf。",{"type":16,"tag":5080,"props":5081,"children":5082},"style",{},[5083],{"type":22,"value":344},{"title":344,"searchDepth":5085,"depth":5086,"links":5087},3,2,[5088,5089,5090,5095,5098,5105,5113,5116,5125,5126,5127],{"id":60,"depth":5086,"text":60},{"id":75,"depth":5086,"text":78},{"id":111,"depth":5086,"text":114,"children":5091},[5092,5093,5094],{"id":123,"depth":5085,"text":126},{"id":180,"depth":5085,"text":183},{"id":231,"depth":5085,"text":234},{"id":287,"depth":5086,"text":290,"children":5096},[5097],{"id":318,"depth":5085,"text":321},{"id":359,"depth":5086,"text":362,"children":5099},[5100,5101,5102,5103,5104],{"id":495,"depth":5085,"text":498},{"id":1272,"depth":5085,"text":1275},{"id":1295,"depth":5085,"text":1298},{"id":1388,"depth":5085,"text":1391},{"id":1515,"depth":5085,"text":1518},{"id":1554,"depth":5086,"text":1557,"children":5106},[5107,5108,5109,5110,5111,5112],{"id":1565,"depth":5085,"text":1568},{"id":2286,"depth":5085,"text":2289},{"id":2809,"depth":5085,"text":2812},{"id":2893,"depth":5085,"text":2896},{"id":2995,"depth":5085,"text":2998},{"id":3021,"depth":5085,"text":3024},{"id":3042,"depth":5086,"text":3045,"children":5114},[5115],{"id":3114,"depth":5085,"text":3117},{"id":3135,"depth":5086,"text":3138,"children":5117},[5118,5119,5120,5121,5122,5123,5124],{"id":3151,"depth":5085,"text":3154},{"id":3334,"depth":5085,"text":3337},{"id":3360,"depth":5085,"text":3363},{"id":3380,"depth":5085,"text":3383},{"id":3790,"depth":5085,"text":3793},{"id":3811,"depth":5085,"text":3814},{"id":3842,"depth":5085,"text":3845},{"id":3862,"depth":5086,"text":3865},{"id":3883,"depth":5086,"text":3883},{"id":3893,"depth":5086,"text":3893},76357,"\u002Fmaterials\u002Fcmu-15-779\u002Ftensorflow-paper-zh.md",1795088941177]