A Modular Benchmarking Infrastructure for High-Performance and   Reproducible Deep Learning

Tal Ben-Nun; Maciej Besta; Simon Huber; Alexandros Nikolaos Ziogas,; Daniel Peter; Torsten Hoefler

arXiv:1901.10183·cs.DC·June 14, 2019

A Modular Benchmarking Infrastructure for High-Performance and Reproducible Deep Learning

Tal Ben-Nun, Maciej Besta, Simon Huber, Alexandros Nikolaos Ziogas,, Daniel Peter, Torsten Hoefler

PDF

1 Repo

TL;DR

Deep500 is a modular, customizable benchmarking system for deep learning that ensures fair, reproducible, and scalable evaluation across various frameworks, algorithms, and hardware configurations.

Contribution

It introduces the first distributed, reproducible benchmarking infrastructure with a modular design for fair comparison of deep learning methods.

Findings

01

Deep500 enables combining different deep learning codes for benchmarking.

02

It maintains negligible overheads, ensuring fast performance.

03

Provides infrastructure for analyzing correctness and reproducibility.

Abstract

We introduce Deep500: the first customizable benchmarking infrastructure that enables fair comparison of the plethora of deep learning frameworks, algorithms, libraries, and techniques. The key idea behind Deep500 is its modular design, where deep learning is factorized into four distinct levels: operators, network processing, training, and distributed training. Our evaluation illustrates that Deep500 is customizable (enables combining and benchmarking different deep learning codes) and fair (uses carefully selected metrics). Moreover, Deep500 is fast (incurs negligible overheads), verifiable (offers infrastructure to analyze correctness), and reproducible. Finally, as the first distributed and reproducible benchmarking system for deep learning, Deep500 provides software infrastructure to utilize the most powerful supercomputers for extreme-scale workloads.

Figures18

Click any figure to enlarge with its caption.

Tables2

Table 1. TABLE I : An overview of DL frameworks, related systems that can be integrated within Deep500, and the advantages of such integration . Each column is a specific feature/functionality; they are explained in more detail in Background ( § II ). Sta : Standard Operators, Cus : Customizable (without full recompilation), Def : Deferred Execution Mode, Eag : Eager Execution Mode (also called “define-by-run”), Com : Network Compilation, Tra : Transformable, Dat : Dataset Network Integration, Opt : Standard Optimizers, PS : Parameter Server, Dec : Decentralized, Asy : Asynchronous SGD, UR : Update Rule Optimizers, \faThumbsOUp , \faThumbsUp , \faThumbsDown : A given system does offer a given feature, offers a given feature in a limited way, or does not offer it. (L) : a library, (F) : a framework, (E) : a frontend. † † {}^{\text{\textdagger}} Caffe2 and PyTorch exist as a single repository of code, but execute as two separate frameworks. ∗ Deep500 provides an isolated modular abstraction of a given feature. ‡ Deep500 provides a reference implementation. Native system support for a category of features: none , partial , full .

System

Operators

Networks

Training

Dist. Training

Sta

Cus

Def

Eag

Com

Tra

Dat

Opt

Cus

PS

Dec

Asy

Cus

(L) cuDNN

\faThumbsOUp

\faThumbsDown

(L) MKL-DNN

\faThumbsOUp

\faThumbsDown

(F) TensorFlow [abadi2016tensorflow]

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

UR

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsDown

(F) Caffe, Caffe2

^{†}

[jia2014caffe]

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsDown

UR

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(F) [Py]Torch

^{†}

[collobert2002torch, paszke2017automatic]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(F) MXNet [chen2015mxnet]

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

UR

\faThumbsUp

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(F) CNTK [yu2014introduction]

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

UR

\faThumbsUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(F) Theano [bergstra2011theano]

\faThumbsOUp

\faThumbsDown

\faThumbsUp

\faThumbsDown

(F) Chainer[MN] [tokui2015chainer]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(F) Darknet [darknet13]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsUp

\faThumbsDown

(F) DL4j [team2016deeplearning4j]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

UR

\faThumbsUp

\faThumbsOUp

\faThumbsDown

(F) DSSTNE

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

UR

\faThumbsDown

(F) PaddlePaddle

\faThumbsOUp

\faThumbsDown

\faThumbsUp

UR

\faThumbsUp

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsUp

(F) TVM [tvm]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(E) Keras [chollet2015others]

\faThumbsOUp

\faThumbsDown

UR

\faThumbsUp

\faThumbsDown

(E) Horovod [sergeev2018horovod]

\faThumbsDown

\faThumbsOUp

\faThumbsDown

(E) TensorLayer [dong2017tensorlayer]

\faThumbsOUp

\faThumbsDown

UR

\faThumbsDown

\faThumbsUp

\faThumbsDown

(E) Lasagne

\faThumbsUp

\faThumbsOUp

\faThumbsDown

UR

\faThumbsUp

\faThumbsDown

(E) TFLearn [tflearn]

\faThumbsUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

Integration within Deep500 [This work]

\faThumbsOUp^∗‡

\faThumbsOUp^∗

\faThumbsOUp^∗‡

\faThumbsOUp

\faThumbsOUp^∗

\faThumbsOUp^∗‡

\faThumbsOUp^∗

\faThumbsOUp^∗‡

\faThumbsOUp^∗

Table 2. TABLE II : An overview of available DL benchmarks , focusing on the offered functionalities. Perf : Performance, Con : Convergence, Acc : Accuracy, Tim : Time, Cos : Cost, Ene : Energy, Util : Utilization, Mem : Memory Footprint, Tput : Throughput (Samples per Second), Brk : Timing Breakdown, Sca : Strong Scaling, Com : Communication and Load Balancing, TTA : Time to Accuracy, FTA : Final Test Accuracy, Lat : Latency (Inference), Clo : Closed (Fixed) Model Contests, Ope : Open Model Contests, Inf : Fixed Infrastructure for Benchmarking, Ops : Operator Benchmarks, Img : Image Processing, Obj : Object Detection and Localization, Spe : Speech Recognition, Txt : Text Processing and Machine Translation, RL : Reinforcement Learning Problems, \faThumbsOUp : A given benchmark does offer the feature. \faThumbsUp : Planned benchmark feature. \faThumbsDown : A given benchmark does not offer the feature.

Benchmark

Focus

Metrics

Criteria

Customizability

DL Workloads

Remarks

Perf

Con

Acc

Tim

Cos

Ene

Util

Mem

Tput

Brk

Sca

Com

TTA

FTA

Lat

Clo

Ope

Inf

Ops

Img

Obj

Spe

Txt

RL

DeepBench [deepbench]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

Ops: Conv., GEMM, RNN, Allreduce

TBD [tbd]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

+GANs

Fathom [fathom]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

+Auto-encoders

DLBS [dlcookbook]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

DAWNBench [coleman2017dawnbench]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

Kaggle [kaggle]

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

Varying workloads

ImageNet [imagenet]

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

MLPerf [mlp]

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

\faThumbsDown

\faThumbsOUp

Deep500

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsUp

\faThumbsOUp

\faThumbsUp

Peer Reviews

No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.

Code & Models

Repositories

deep500/deep500
tfOfficial

Videos

No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.

Full text

\stackMath\xpatchcmd

00

\hfsetbordercolorwhite \hfsetfillcolorvlgray

A Modular Benchmarking Infrastructure for High-Performance and Reproducible Deep Learning

Tal Ben-Nun, Maciej Besta, Simon Huber, Alexandros Nikolaos Ziogas, Daniel Peter, Torsten Hoefler

*Department of Computer Science, ETH Zurich

Abstract

We introduce Deep500: the first customizable benchmarking infrastructure that enables fair comparison of the plethora of deep learning frameworks, algorithms, libraries, and techniques. The key idea behind Deep500 is its modular design, where deep learning is factorized into four distinct levels: operators, network processing, training, and distributed training. Our evaluation illustrates that Deep500 is customizable (enables combining and benchmarking different deep learning codes) and fair (uses carefully selected metrics). Moreover, Deep500 is fast (incurs negligible overheads), verifiable (offers infrastructure to analyze correctness), and reproducible. Finally, as the first distributed and reproducible benchmarking system for deep learning, Deep500 provides software infrastructure to utilize the most powerful supercomputers for extreme-scale workloads.

Index Terms:

Deep Learning, High-Performance Computing, Benchmarks, Distributed Deep Learning

Deep500 Code: https://www.github.com/deep500/deep500

I Introduction

Deep Learning (DL) has transformed the world and is now ubiquitous in areas such as speech recognition, image classification, or autonomous driving [ben2018demystifying]. Its central concept is a Deep Neural Network (DNN), a structure modeled after the human brain. Thanks to rigorous training, DNNs are able to solve various problems, previously deemed unsolvable.

Recent years saw an unprecedented growth in the number of approaches, schemes, algorithms, applications, platforms, and frameworks for DL. First, DL computations can aim at inference or training. Second, hardware platforms can vary significantly, including CPUs, GPUs, or FPGAs. Third, operators can be computed using different methods, e.g., im2col [im2col] or Winograd [lavin2016fast] in convolutions. Next, DL functionalities have been deployed in a variety of frameworks, such as TensorFlow [dong2017tensorlayer] or Caffe [jia2014caffe]. These functionalities may incorporate many parallel and distributed optimizations, such as data, model, and pipeline parallelism. Finally, DL workloads are executed in wildly varying environments, such as mobile phones, multi-GPU clusters, or large-scale supercomputers.

This richness of the DL domain raises an important question: How can one ensure a leveled, fair ground for comparison, competition, and benchmarking in Deep Learning? The key issue is that, due to the complex nature of DL workloads, there is no single metric by which one DNN or hardware is objectively better than another on all counts. This is an open question and there are multiple proposed metrics (e.g., throughput, time-to-solution), especially for hardware ranking for distributed DL. Thus, it is necessary to design an abstraction that supports these and future potential metrics for DL evaluation. Several benchmarks [coleman2017dawnbench, mlp, tbd, fathom, dlcookbook, kaggle, imagenet, mlp] have been designed for DL, but they are either specialized for a given aspect (e.g., single-layer performance) or perform black-box tests, which hinder verifiability and reproducibility. Since DL is converging in terms of procedures, it is possible to design a white-box abstraction that covers key functionalities of the problem, enabling arbitrary metric measurement and full integration of the different software stacks (see Table I) for benchmarking.

We propose Deep500: a white-box benchmarking infrastructure that enables fair analysis and comparison of diverse DL workloads and algorithms. Deep500 is based on the following five pillars: ❶ Customizability, ❷ Metrics, ❸ Performance, ❹ Validation, and ❺ Reproducibility. ❶ “Customizability” indicates that Deep500 enables benchmarking of arbitrary combinations of DL elements, such as various frameworks running on different platforms, and executing custom algorithms. To achieve this, we design Deep500 to be a meta-framework that can be straightforwardly extended to benchmark any DL code. Table I illustrates how various DL frameworks, libraries, and frontends can be integrated in Deep500 to enable easier and faster DL programming. ❷ “Metrics” indicates that Deep500 embraces a complex nature of DL that, unlike benchmarks such as Top500 [dongarra1994top500], makes a single number such as FLOPS an insufficient measure. To this end, we propose metrics that consider the accuracy-related aspects of DL (e.g., time required to ensure a specific test-set accuracy) and performance-related issues (e.g., communication volume). ❸ “Performance” means that Deep500 is the first DL benchmarking infrastructure that can be integrated with parallel and distributed DL codes. ❹ “Validation” indicates that Deep500 provides infrastructure to ensure correctness of aspects such as convergence. Finally, Deep500 embraces ❺ “Reproducibility” as specified in recent HPC initiatives [hoefler2015scientific] to help developing reproducible DL codes.

Table II compares Deep500 to other benchmarking infrastructures with respect to the offered functionalities. Deep500 is the only system that focuses on performance, accuracy, and convergence, while simultaneously offering a wide spectrum of metrics and criteria for benchmarking, enabling customizability of design, and considering a diversity of workloads.

Towards these goals, we contribute:

•

the identification and analysis of challenges in high-performance reproducible benchmarking of deep learning,

•

the design and implementation of the Deep500 Benchmark, a meta-framework for customizable, fast, validatable, and reproducible benchmarking of extreme-scale DL frameworks, applications, algorithms, and techniques,

•

extensive evaluation, illustrating that Deep500 ❶ incurs negligible ( $<$ 1%) overheads of benchmarking on top of tested systems, and ❷ vastly reduces development efforts to integrate and benchmark various elements of deep learning.

II Background

We start with describing background on deep learning.

II-A Deep Learning

We focus on Deep Learning (DL): a subclass of Machine Learning (ML) that uses Deep Neural Networks (DNNs) [ben2018demystifying] for approximating certain complex functions. In this paper, we mostly discuss supervised learning, but Deep500 can be used to benchmark workloads for other tasks, such as unsupervised and reinforcement learning. A DNN is first trained: it is provided with various input data samples in a randomized order to minimize the difference (loss) between the obtained and the desired outcome (this difference is computed with some loss function $\ell$ ). After training, a DNN is used to infer outcomes for given inputs.

Intuitively, a DNN is a composition of multiple functions called operators. Operators can range from fully-connected neural networks, through multi-dimensional convolution, to recurrent operators that maintain state. The process of evaluating a given operator for a given input data (referred to as a sample) is called inference. These operators are organized as a Directed Acyclic Graph (DAG) (Fig. 1, top right).

Formally, for an input dataset $S\subset\left(X\times Y\right)\sim\mathcal{D}$ of labeled samples (sampled from a data distribution $\mathcal{D}$ ), and a parametric model $f:X\rightarrow Y$ (denoted by $f(w,x)$ ), the goal is to minimize the expected loss over the dataset, i.e., find a minimizing set of parameters $w^{*}=\operatorname*{arg\,min}_{w}\mathbb{E}_{(x,y)}\left[\ell\left(f(w,x),y\right)\right]$ , where $\ell$ is a certain norm function for assessing difference.

Training To minimize the expected loss, we use algorithms such as Stochastic Gradient Descent (SGD) [sgd] for training. In SGD, dataset elements are sampled at random in minibatches (data portions) of size $B$ ; usually $16\leq B\leq 64$ k [batch64k]. In training, one iterates over the whole dataset (one such loop iteration is called an epoch) multiple times, and modifies minimizing parameters $w^{(t)}$ at iteration $t$ according to the average gradient and possibly historical values of $w$ . Algorithm 1 depicts such an SGD optimizer with a weight update rule $U$ .

Distributed Training When distributing training among compute nodes, it is common to use data parallelism, i.e., partitioning across minibatches. The gradient average (Algorithm 1, line 5), necessary for descent, becomes a parallel reduction that is performed collectively (allreduce in MPI nomenclature). Data-parallel distributed training can be implemented in one of two general approaches: decentralized, using an allreduce operation; or centralized, where a (possibly sharded) “parameter server” (PS) governs optimization [dean2012large] by receiving individual gradients and broadcasting back new parameters (Algorithm 1, lines 3 and 5–7). Deep500 enables all these distributed schemes while vastly reducing development effort.

II-B Frameworks

Many frameworks for training and inference exist; see Table I. According to GitHub [dlranking], the three most popular DL frameworks are TensorFlow [abadi2016tensorflow], Caffe [jia2014caffe], and PyTorch [collobert2002torch]. We use these three frameworks (except for Caffe, which we replace with Caffe2, an improved Caffe version written by the same authors) as use cases to demonstrate the flexibility of Deep500. Now, the frameworks can differ vastly, ranging from how operators are implemented and how extensible (Customizable) the frameworks are; to how DNNs are evaluated and trained. Some frameworks compute operators on-the-fly, i.e., as they are called (Eager Execution). Others construct a graph in advance (Deferred Execution) and modify it for high-level optimizations (Transformable), ahead-of-time Network Compilation, or employ Dataset Integration by adding data loading operators to the graph, enabling automatic pipelining of samples to accelerators and distributed storage integration. As for training, most frameworks support the aforementioned Update Rule SGD, but some also provide other optimizers, or enable implementing arbitrary algorithms.

A complete DL framework provides: ❶ operator representation and implementations, ❷ network definition (connections between operators), ❸ schemes for loading datasets and for data augmentation (i.e., increasing variation in samples by perturbing data), ❹ inference and gradient computation, ❺ stochastic optimization (training), and ❻ distributed optimization and communication infrastructure. Elements ❶–❷ are partially standardized by initiatives such as ONNX [exchange2018onnx] and NNEF [nnef] that define portable (up to framework limitations) file formats. Other elements are not standardized at all. Moreover, frameworks do not provide standardized metrics, such as accuracy and performance, which are absolutely necessary for scientific computing purposes, high-performance computing, and reproducibility. Table I illustrates the various DL frameworks, libraries, and frontends, and how Deep500 integrates them through its meta-framework design. These systems can then be analyzed using a set of carefully selected metrics.

II-C Benchmarks

There exist preliminary efforts to benchmark DL and general ML. Table II analyzes the functionalities of these efforts. In general, only Deep500 focuses on performance, accuracy, and convergence, considering the five challenges of large-scale DL benchmarking discussed in the introduction.

II-D Data Model and Format

We use the Open Neural Network Exchange (ONNX) [exchange2018onnx] format to store DNNs reproducibly. ONNX provides a binary file format capable of describing an arbitrary DAG and standardizes a list of 118 common operators (as of version 1.3.0) used in DL and in general ML. Many popular frameworks provide and are actively improving interoperability with ONNX. Thus, we select ONNX as the basis of data format for Deep500. To use ONNX for reproducible training and to enable extensibility, we augment the ONNX with additional built-in operators and with support for user-defined operators.

III Benchmarking Deep Learning: Challenges

We analyze challenges in benchmarking large-scale DL.

III-A Motivation

We first describe motivating example use cases.

Use Case 1

We observe that different frameworks come with significant differences between basic functionalities. For example, we present the initialization of 2D convolution in TensorFlow and CNTK in Listings LABEL:lst:tf_motivate–LABEL:lst:cntk_motivate. TensorFlow uses 19 parameters while CNTK needs 10. Thus, comparing fairly both frameworks in metrics such as runtime or accuracy is unclear (“Which parameters correspond to each other?”), and for some operators impossible due to implementation differences. Among the factors that vary between frameworks is data layout, which is unclear in the CNTK example. For the case of performance, we use the Adam SGD optimizer [adam] as a second example. As TensorFlow provides general tensor operators (using the Eigen linear algebra library), it requires sequentially executing several short operations on the GPU (e.g. subtraction, division) to compute the optimizer update. Conversely, Caffe2 implements a specific “Adam” operator that performs the entire update using a single GPU kernel, drastically reducing invocation and GPU scheduling overheads. This operation fusion in Caffe2 is a common optimization technique, and Deep500 enables straightforward comparison of such TensorFlow and Caffe2 instances, both in an isolated environment and as an integrated part of training over existing datasets. In general, this use case calls for an infrastructure that enables straightforward invocation of existing and custom implementations, in order to enable simple, maintainable comparison and benchmarking.