I’m a PhD student at MIT studying computer science and getting up to all sorts of mischief. Previously, I attended MIT as an undergraduate and M.Eng in computer science and physics. Before that, I attended Thomas Jefferson High School for Science and Technology (TJHSST) in Northern Virginia.
An algorithmic decisionmaker incentivizes people to act in certain ways to receive better decisions. These incentives can dramatically influence subjects’ behaviors and lives, and it is important that both decisionmakers and decisionrecipients have clarity on which actions are incentivized by the chosen model. While for linear functions, the changes a subject is incentivized to make may be clear, we prove that for many nonlinear functions (e.g. neural networks, random forests), classical methods for interpreting the behavior of models (e.g. input gradients) provide poor advice to individuals on which actions they should take. In this work, we propose a mathematical framework for understanding algorithmic incentives as the challenge of solving a Markov Decision Process, where the state includes the set of input features, and the reward is a function of the model’s output. We can then leverage the many toolkits for solving MDPs (e.g. treebased planning, reinforcement learning) to identify the optimal actions each individual is incentivized to take to improve their decision under a given model. We demonstrate the utility of our method by estimating the maximallyincentivized actions in two realworld settings: a recidivism risk predictor we train using ProPublica’s COMPAS dataset, and an online credit scoring tool published by the Fair Isaac Corporation (FICO)
@misc{shavit2019extracting, title = {Extracting Incentives from BlackBox Decisions}, booktitle = {arXiv preprint}, series = {arXiv}, author = {Shavit, Yonadav and Moses, William S.}, year = {2019}, eprint = {1910.05664}, archiveprefix = {arXiv}, primaryclass = {cs.LG}, pdf = {https://arxiv.org/pdf/1910.05664.pdf} }
Deep learning frameworks automate the deployment, distribution, synchronization, memory allocation, and hardware acceleration of models represented as graphs of computational operators. These operators wrap highperformance libraries such as cuDNN or NNPACK. When the computation does not match any predefined library call, custom operators must be implemented, often at high engineering cost and performance penalty, limiting the pace of innovation. To address this productivity gap, we propose and evaluate: (1) a domainspecific language with a tensor notation close to the mathematics of deep learning; (2) a JustInTime optimizing compiler based on the polyhedral framework; (3) carefully coordinated linear optimization and evolutionary algorithms to synthesize highperformance CUDA kernels; (4) the transparent integration of our flow into PyTorch and Caffe2, providing the fully automatic synthesis of highperformance GPU kernels from simple tensor algebra. The performance is comparable to, and often exceeds the performance of, highly tuned libraries.
@article{Vasilache:2019:NAL:3366460.3355606, author = {Vasilache, Nicolas and Zinenko, Oleksandr and Theodoridis, Theodoros and Goyal, Priya and Devito, Zachary and Moses, William S. and Verdoolaege, Sven and Adams, Andrew and Cohen, Albert}, booktitle = {Architecture and Code Optimization (TACO)}, series = {TACO}, title = {The Next 700 Accelerated Layers: From Mathematical Expressions of Network Computation Graphs to Accelerated GPU Kernels, Automatically}, journal = {ACM Trans. Archit. Code Optim.}, issue_date = {October 2019}, volume = {16}, number = {4}, month = oct, year = {2019}, issn = {15443566}, pages = {38:138:26}, articleno = {38}, numpages = {26}, url = {http://doi.acm.org/10.1145/3355606}, doi = {10.1145/3355606}, acmid = {3355606}, publisher = {ACM}, address = {New York, NY, USA}, keywords = {Deep learning layers, GPU acceleration, polyhedral compilation}, pdf = {https://c.wsmoses.com/papers/tctaco.pdf} }
Deterministic software transactional memory (STM) is a useful programming model for writing parallel codes, as it improves programmability (by supporting transactions) and debuggability (by supporting determinism). This paper presents LiTM, a new deterministic STM system that achieves both simplicity and efficiency at the same time. LiTM implements the deterministic reservations framework of Blelloch et al., but without requiring the programmer to understand the internals of the algorithm. Instead, the programmer writes the program in a transactional fashion and LiTM manages all data conflicts and automatically achieves deterministic parallelism. Our experiments on six benchmarks show that LiTM outperforms the stateoftheart framework Galois by up to 5.8x on a 40core machine
@inproceedings{xia2019litm, title = {LiTM: A Lightweight Deterministic Software Transactional Memory System}, author = {Xia, Yu and Yu, Xiangyao and Moses, William and Shun, Julian and Devadas, Srinivas}, booktitle = {Proceedings of the 10th International Workshop on Programming Models and Applications for Multicores and Manycores}, series = {PPoPP PMAMM '19}, pages = {110}, year = {2019}, organization = {ACM}, pdf = {https://c.wsmoses.com/papers/litm.pdf} }
Deep learning models with convolutional and recurrent networks are now ubiquitous and analyze massive amounts of audio, image, video, text and graph data, with applications in automatic translation, speechtotext, scene understanding, ranking user preferences, ad placement, etc. Competing frameworks for building these networks such as TensorFlow, Chainer, CNTK, Torch/PyTorch, Caffe1/2, MXNet and Theano, explore different tradeoffs between usability and expressiveness, research or production orientation and supported hardware. They operate on a DAG of computational operators, wrapping highperformance libraries such as CUDNN (for NVIDIA GPUs) or NNPACK (for various CPUs), and automate memory allocation, synchronization, distribution. Custom operators are needed where the computation does not fit existing highperformance library calls, usually at a high engineering cost. This is frequently required when new operators are invented by researchers: such operators suffer a severe performance penalty, which limits the pace of innovation. Furthermore, even if there is an existing runtime call these frameworks can use, it often does not offer optimal performance for a user’s particular network architecture and dataset, missing optimizations between operators as well as optimizations that can be done knowing the size and shape of data. Our contributions include (1) a language close to the mathematics of deep learning called Tensor Comprehensions, (2) a polyhedral JustInTime compiler to convert a mathematical description of a deep learning DAG into a CUDA kernel with delegated memory management and synchronization, also providing optimizations such as operator fusion and specialization for specific sizes, (3) a compilation cache populated by an autotuner. In particular, we demonstrate the suitability of the polyhedral framework to construct a domainspecific optimizer effective on stateoftheart deep learning models on GPUs. Our flow reaches up to 4× speedup over NVIDIA libraries on kernels relevant to the Machine Learning Community, and on an actual model used in production at Facebook. It is integrated with mainstream frameworks Caffe2 (productionoriented), PyTorch (researchoriented), through the ATen asynchronous tensor library.
@article{tc, title = {Tensor Comprehensions: FrameworkAgnostic HighPerformance Machine Learning Abstractions}, booktitle = {arXiv preprint}, series = {arXiv}, author = {Vasilache, Nicolas and Zinenko, Oleksandr and Theodoridis, Theodoros and Goyal, Priya and DeVito, Zachary and Moses, William S and Verdoolaege, Sven and Adams, Andrew and Cohen, Albert}, journal = {arXiv preprint arXiv:1802.04730}, year = {2018}, reddit = {http://www.reddit.com/r/MachineLearning/comments/7xjqq9/r_announcing_tensor_comprehensions/}, hackernews = {http://news.ycombinator.com/item?id=16377389}, pdf = {https://arxiv.org/pdf/1802.04730.pdf} }
This paper explores how forkjoin parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler’s intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics.
Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program’s control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, we added or modified about 6000 lines of LLVM’s 4millionline codebase. Tapir enables LLVM’s existing compiler optimizations for serial code – including loopinvariantcode motion, commonsubexpression elimination, and tailrecursion elimination – to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
@inproceedings{tapir, author = {Schardl, Tao B. and Moses, William S. and Leiserson, Charles E.}, title = {Tapir: Embedding ForkJoin Parallelism into LLVM's Intermediate Representation}, booktitle = {Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming}, series = {PPoPP '17}, month = jan, year = {2017}, isbn = {9781450344937}, location = {Austin, Texas, USA}, pages = {249265}, numpages = {17}, pdf = {https://c.wsmoses.com/papers/tapir.pdf}, doi = {10.1145/3018743.3018758}, acmid = {3018758}, publisher = {ACM}, address = {New York, NY, USA}, award = {Best Paper Award}, reddit = {http://www.reddit.com/r/programming/comments/5ra59l/mit_says_their_modified_llvm_compiler_optimizes/}, mitnews = {http://news.mit.edu/2017/optimizingcodecompilerparallelprograms0130}, hackernews = {http://news.ycombinator.com/item?id=13568585}, blog = {/tapir} }
Optimizing compilers for tasklevel parallelism are still in their infancy. This work explores a compiler front end that translates OpenMP tasking semantics to Tapir, an extension to LLVM IR that represents forkjoin parallelism. This enables analyses and optimizations that were previously inaccessible to OpenMP codes, as well as the ability to target additional runtimes at code generation. Using a Cilk runtime back end, we compare results to existing OpenMP implementations. Initial performance results for the Barcelona OpenMP task suite show performance improvements over existing implementations.
@inproceedings{openmpir, author = {Stelle, George and Moses, William S. and Olivier, Stephen L. and McCormick, Patrick}, title = {OpenMPIR: Implementing OpenMP Tasks with Tapir}, booktitle = {Proceedings of the Fourth Workshop on the LLVM Compiler Infrastructure in HPC}, series = {LLVMHPC'17}, year = {2017}, isbn = {9781450355650}, location = {Denver, CO, USA}, pages = {3:13:12}, articleno = {3}, numpages = {12}, url = {http://doi.acm.org/10.1145/3148173.3148186}, doi = {10.1145/3148173.3148186}, acmid = {3148186}, publisher = {ACM}, address = {New York, NY, USA}, pdf = {https://c.wsmoses.com/papers/openmpir.pdf} }
This thesis explores how forkjoin parallelism, as supported by concurrency platforms such as Cilk and OpenMP, can be embedded into a compiler’s intermediate representation (IR). Mainstream compilers typically treat parallel linguistic constructs as syntactic sugar for function calls into a parallel runtime. These calls prevent the compiler from performing optimizations across parallel control constructs. Remedying this situation is generally thought to require an extensive reworking of compiler analyses and code transformations to handle parallel semantics.
Tapir is a compiler IR that represents logically parallel tasks asymmetrically in the program’s control flow graph. Tapir allows the compiler to optimize across parallel control constructs with only minor changes to its existing analyses and code transformations. To prototype Tapir in the LLVM compiler, for example, the Tapir team added or modi fied about 6000 lines of LLVM’s 4millionline codebase. Tapir enables LLVM’s existing compiler optimizations for serial code — including loopinvariantcode motion, commonsubexpression elimination, and tailrecursion elimination — to work with parallel control constructs such as spawning and parallel loops. Tapir also supports parallel optimizations such as loop scheduling.
@mastersthesis{wmosesmeng, title = {How {S}hould {C}ompilers {R}epresent {F}ork{J}oin {P}arallelism?}, author = {Moses, William S.}, booktitle = {Master's Thesis}, series = {Thesis '17}, school = {Massachusetts Institute of Technology}, year = {2017}, month = may, pdf = {https://c.wsmoses.com/papers/wmosesmeng.pdf}, blog = {/tapir} }
Music has long been an interesting subject of analysis for mathematicians and has led to many interesting questions in music theory and other fields. For the most part, computer scientists have looked into applying artificial intelligence to music and finding algorithms and data structures to solve various problems in music. Prior work on these algorithms often involves computing various properties of music such as the edit distance between two songs or the optimal fingering. These problems tend to be solvable in polynomial time using dynamic programming and have various application such as the music identification service Shazam or operations on RISM, an online music database.
This paper takes an additional step in this direction, asking what sorts of problems in music cannot be efficiently computed. Specifically, this paper asks how various constraints affect the computational complexity of arranging music originally written for one set of instruments down to a single instrument. The paper then applies these results to other domains including musical choreography (such as ice skating and ballet) as well as creating levels for rhythm games (such as Rock Band). We prove that all of the problems are NPcomplete, meaning that there is no efficient algorithm to solve them (assuming the standard conjecture that P != NP).
@incollection{moves15, author = {Demaine, Erik D. and Moses, William S.}, title = {Computational Complexity of Arranging Music}, booktitle = {Revised Papers from MOVES 2015: Mathematics of Various Entertaining Subjects}, series = {MOVES '15}, publisher = {Princeton University Press}, year = {2015}, pdf = {https://c.wsmoses.com/papers/moves15.pdf} }
@article{spacex15, title = {Extreme MultiResolution Visualization: A Challenge on Many Levels}, author = {Balme, Joanna and BrownDymkoski, Eric and Guerrero, Victor and Jones, Stephen and Kessler, Andre and Lichtl, Adam and Lung, Kevin and Moses, William and Museth, Ken and Roberson, Nathan and others}, booktitle = {SuperComputing Visualization Contest 2015}, series = {SCVis '15}, year = {2015}, pdf = {https://c.wsmoses.com/papers/spacex15.pdf} }
Adaptive frequency hopping is one way to maximize the utilization of the wireless spectrum. Yet, when the environment itself is changing, the frequency at which the radio senses can become increasingly less optimal. By having the radio create a model of the environment based off of the sensing data, it is possible to achieve high data rates when the spectrum is not being heavily utilized and maintain a low level of interference at times when it is. The radio was modeled both mathematically and run in simulations. The outcomes of these tests were compared with existing standards such as Bluetooth (random frequency hopping) and IEEE 802.22 (fixed sensing rate). In order to evaluate data rate and interference simultaneously, a metric was created that combined them by taking the product of data rate and ( 1  interference ). Overall, the online adaptive frequency hopper had a 35% increase in the combined metric over the random frequency hopper and 25% increase over the fixed sensing rate radio.
@misc{oafh, title = {Online Adaptive Frequency Hopping}, author = {Moses, William and Robertson, Andrew and Dell, John}, booktitle = {TJHSST Teknos 2014}, series = {TJHSST '14}, year = {2014}, pdf = {https://c.wsmoses.com/papers/oafh.pdf} }
6.828: Operating Systems
A graduatelevel class on the design and implementation of operating systems. Topics included: locking, virtual memory, file systems, threads, context switches, kernel interrupts, system calls, IPC, and MMIO devices. Over the semester, implemented a functioning multicore operating system called jos, designed to be a simpler version of xv6.

6.867: Machine Learning
A graduatelevel class in machine learning. Topics included support vector machines, neural networks (including convolutional and deep networks), decision tree, boosting algorithms, Bayesian methods, and Markov models.

6.UAR: Seminar in Undergraduate Research
The first semester in a yearlong class in methods for advanced research.

21M.359: Interactive Music Systems
A combination humanties and computer science subject focusing on developping interactive systems involving audio. Labs included making games using input devices such as the Microsoft Kinect, audio analysis, and developing a simple guitar hero game.

11.011: The Art and Science of Negotiation
An advanced class on negotiation skills with an emphasis on methods in mutual gains.

6.115: Microcomputer Project Laboratory
An advanced laboratory subject on analysis and design of embedded systems from capacitors to assembly and MMIO. Emphasizes construction of complete systems, including labs involving a fiveaxis robot arm, a fluorescent lamp ballast, a tomographic imaging station (e.g., a CAT scan), and a simple calculator.

CMS.335: Short Documentary
A humanities subject exploring the world of short documentaries.

6.THM: Thesis
A class denoting work on my master's thesis on Tapir and related advances in performance engineering parallel programs

6.172: Performance Engineering
An advanced undergraduate course in performance engineering covering both the theory and practice behind technologies in parallelism, cachebehavior, among others.

6.002: Circuits
Introductory class in circuit design.

8.370: Quantum Computation
A graduatelevel class in quantum computation and quantum algorithms.

8.07: Advanced Electrodynamics
An advanced undergraduate class in electrodynamics focusing on moving systems and the behavior of materials.

24.241: Logic I
An undergraduate class on formal logic.

6.854: Advanced Algorithms
A graduatelevel course in algorithms. Topics include universal/consistent hashing, dimensionality reduction, multicommodity flow and other generalizations of maxflow, linear programming and duality, gradient descent, interior points, multiplicative weights, semidefinited programming, and compressed sensing.

6.035: Computer Language Engineering
An advanced class on computer languages and compilers.

8.962: General Relativity
A graduatelevel class on general relativity

8.06: Quantum Mechanics III
The most advanced undergraduate course in quantum mechanics

4.352: Advanced Video Making
An advanced course in video production.

6.886: Performance Engineering for Multicore Systems
A seminar class in performance engineering with a focus on performing research in the field

6.046: Design and Analysis Algorithms
The most advanced undergraduate course in algorithms spanning subjects from Van Emde Boas trees to network flow.

8.S05: Quantum Mechanics II
An intermediate course in Quantum Mechanics, using linear algebra as a basis for describing subjects
from the quantum harmonic oscillator, to squeeze states, to the fine structure of Hydrogen.

8.044: Statistical Mechanics
An class in statistical mechanics using quantum mechanics to build up
more macroscopic effects.

21W.789: Communicating With Mobile Technology
A class on how to design, build, and market new computer science startups made
for mobile platforms.

18.075: Advanced Calculus for Engineers (Complex Analysis)
Complex analysis and differential equations taught from the perspective
of engineering applications.

8.223: Classical Mechanics II
An advanced course in classical mechanics covering approximations, Lagrangian mechanics, Hamiltonian Mechanics, among other topics.

18.031: System Functions and the Laplace Transform
A supplementary class in differential equations covering system functions and the Laplace transform as methods of solving differential equations and modeling systems.

6.179: Introduction to C/C++ (Instructor)
An introductory class to C/C++ that I taught with William Qian with over 200 students. Geared towards those already with a programming background, this provided a fastpaced introduction to C/C++ covering more advacned topics such as template metaprogramming. There were weekly algorithmic PSETS (USACO style) and a capstone final project.

6.890: Algorithmic Lower Bounds, Fun With Hardness Proofs
A graduatelevel computer science class on hardness (NP,PSPACE,EXPSPACE,etc). Covered material ranging from 3SAT to APX and constraint logic. Produced final paper with hopes of publishing in the near future. Final Paper Taught by Erik Demaine.

8.04: Quantum Mechanics I
An introductory course in quantum mechanics covering the basic experiments such as the double slit experiment through interference, quantum tunneling, operators, and the hydrogen atom.

5.111: Chemistry
An introductory course in chemistry covering topics such as equilibrium, acidbase, orbital shapes, crystal field theory, dorbitals, thermodynamics, and kinetics.

7.012: Biology
An introductory course in biology focusing on genetics and neurobiology. Taught by Eric Lander.

21W.035: Science Writing for the Public
A writing class focusing on making science accessible to the public. Projects included: a news article and a researched science article.

12.000: Solving Complex Problems (Terrascope)
A seminar class focusing on solving the world's energy problem in the next 100 years. Redulted in heavy research in climate change, statistical modeling and predictions of the future, a
website
with articles on current and future energy issues and solutions and an hourlong presentation followed by a twohour question and answer session with experts and executives from oil companies.
More information on the class including a recording of the presenation can be found here.

Advanced Mathematical Techniques for Scientists and Engineers
Postmutivariable calculus math course focusing on mathematical methods with important applications to physics and engineering such as Fourier series, linear algebra, introductory complex analysis, the Gamma function, Bessel functions, Legendre polynomials, and the Riemann Zeta function. Includes a brief introduction to quantum mechanics and statistical mechanics.

Quantum Physics and Electrodynamics
An introductory course in quantum mechanics covering SternGerlach machines, entanglement, tunneling as well as a more rigorous treatment of E&M through the use of fourier transforms and Greens functions as well as an introduction to relativity.

Quantum and Modern Physics Research Lab Mentorship
A capstone class focused on research in physics. Researched wireless communication at the Naval Research Laboratory. Research was named a semifinalist in
Intel's Science and Talent Search and patent.

Computational Physics
Introduction to computational techniques used to study and analyze physical phenomena.

Advanced Communication Data Streams
A laboratorybased class focusing on how data is transmitted. Covered signal analysis topics such as convolutions, filters, and fourier transforms.

Artificial Intelligence
Class focusing on artificial intelligence, machine learning, and applications thereof. Subjects included genetic algorithms, neural networks, and image processing.

Parallel Computing
Introduction to parallel algorithms, and techniques. Covers CUDA, MPI, OpenMP, and OpenGL. Labs included nbody simulation, ray tracer, parallel sorts, and huffman encoding.
