Compiling to linear neurons
This work addresses the challenge for machine learning researchers and practitioners in integrating discrete algorithms into neural networks, offering a novel approach that is foundational but incremental in bridging programming and learning.
The paper tackles the problem of indirectly programming neural networks via learning algorithms, which lacks discrete structure and prevents compiling algorithms into networks due to differentiability issues, by introducing Cajal, a programming language that compiles to linear neurons, enabling discrete algorithms to be expressed in a differentiable form; experiments show that linking these neurons with other networks improves learning speed, data-efficiency, and debuggability.
We don't program neural networks directly. Instead, we rely on an indirect style where learning algorithms, like gradient descent, determine a neural network's function by learning from data. This indirect style is often a virtue; it empowers us to solve problems that were previously impossible. But it lacks discrete structure. We can't compile most algorithms into a neural network -- even if these algorithms could help the network learn. This limitation occurs because discrete algorithms are not obviously differentiable, making them incompatible with the gradient-based learning algorithms that determine a neural network's function. To address this, we introduce $\textsf{Cajal}$: a typed, higher-order and linear programming language intended to be a minimal vehicle for exploring a direct style of programming neural networks. We prove $\textsf{Cajal}$ programs compile to linear neurons, allowing discrete algorithms to be expressed in a differentiable form compatible with gradient-based learning. With our implementation of $\textsf{Cajal}$, we conduct several experiments where we link these linear neurons against other neural networks to determine part of their function prior to learning. Linking with these neurons allows networks to learn faster, with greater data-efficiency, and in a way that's easier to debug. A key lesson is that linear programming languages provide a path towards directly programming neural networks, enabling a rich interplay between learning and the discrete structures of ordinary programming.