Tutorial: Halide
Writing fast image processing pipelines is hard, because you need to simultaneously optimize for parallelism and locality (memory bandwidth). This usually wrecks the modularity, portability, and readability of your code, because it involves fusing all your pipeline stages into one architecture-specific monolithic mess. Trying alternative optimizations is then very painful, because it requires rearranging huge chunks of code and then fixing the bugs you inevitably introduced.

Halide (http://halide-lang.org) makes it easier to explore possible optimizations by separating the specification of the algorithm from the specification of the “schedule”, which defines what gets computed when and where it is stored. Halide is described in this SIGGRAPH 2012 paper. The compiler is open source, and can found found here.

Halide Presenters:

Andrew Adams
Software Engineer
Google (X)
Adams works on Halide at Google. Halide is currently used in several Google products, including “HDR+” on Nexus phones and “auto-enhance” in Google+ Photos. Before Google, he was a postdoc at MIT with Fredo Durand. Andrew did grad school at Stanford, where he worked on computational photography under Marc Levoy. His dissertation describes algorithms for fast bilateral filtering. While at Stanford, he also worked on the “frankencamera” and the FCam API. Andrew also enjoys woodworking, playing computer games, and describing himself in the third person.

Jonathan Ragan-Kelley
Post-doctoral Researcher
Computer Graphics Group
Department of Computer Science, Stanford University
Ragan-Kelley is a postdoc in computer science at Stanford. His work focuses on high-efficiency computer graphics, at the intersection of graphics with systems, architecture, and compilers. He completed his PhD with Frédo Durand and Saman Amarasinghe at MIT CSAIL, has worked at all three major GPU vendors in architecture, software, compilers, and research, and built a real-time preview system for the special effects industry in collaboration with Industrial Light & Magic.

Tutorial: Deep Learning for Vision and Imaging
Ankit Patel
Post-doctoral Researcher
Digital Signal Processing Group
Department of Electrical and Computer Engineering, Rice University
Ankit Patel is a Research Scientist at Rice University, focusing on deep machine learning and computational neuroscience, working with Richard Baraniuk in the ECE Dept. He received his Ph.D in Applied Mathematics from Harvard while working in the EECS Dept. with Radhika Nagpal. Ankit received his undergraduate degree in Computer Science and Master’s degree in Applied Mathematics from Harvard.

Ankit spent 6 years in industry working on real-time inference systems, including 2 years at MIT Lincoln Laboratory and 4 years as a Quantitative Trader at Global Electronic Trading Corporation — a high-frequency market-making firm that is now a part of KCG Holdings.

His current work tries to shed new light on the successes (and shortcomings) of techniques in modern Deep Learning. The simple question that started this work was: “Why does Deep Learning work?” In order to answer this question, Ankit and his team started by building a probabilistic theory based on a generative model — the Deep Rendering Model (DRM). With the DRM, they can show how to derive Deep Convolutional Nets and, unexpectedly, Random Decision Forests from first principles.