Dataflow Matrix Machines (DMMs)

• Dataflow Matrix Machines are generalized recurrent networks that use sparse, countable matrices to parameterize dynamic dataflow graphs and support multiple stream types.
• They enable programmable, self-modifying architectures that effectively combine structured data processing, probabilistic sampling, and dynamic network evolution.
• Their matrix-centric design unifies recurrent computation, dataflow programming, and continuous program deformation, offering a versatile platform for advanced machine learning and probabilistic programming.

Dataflow Matrix Machines (DMMs) are a generalization of recurrent neural networks and of dataflow programming systems in which a countable dataflow graph of neurons is parameterized by a sparse, real-valued, countable connectivity matrix, and edges carry linear streams rather than only scalar activations (Bukatin et al., 2016). In the 2016–2017 sequence of papers by Bukatin, Matthews, Radul, and collaborators, they are presented as programmable, dynamically expandable, self-referential generalized recurrent neural networks, as a model of computations with linear streams, and, in the V-value formulation, as a bridge between programs and neural nets (Bukatin et al., 2016, Bukatin et al., 2017, Bukatin et al., 2017).

1. Concept and motivation

The original motivation for DMMs is that standard RNNs are confined to streams of real numbers or fixed-dimensional real vectors, whereas a programmable platform for machine learning, probabilistic programming, and synthesis of dynamic systems benefits from richer stream types, richer neuron interfaces, and explicit higher-order mechanisms (Bukatin et al., 2016). The papers emphasize four recurring limitations of classical RNNs: the awkwardness of representing structured data, the limited notion of linear combination when one wants to linearly combine execution runs, the lack of convenience as a general-purpose programming platform despite Turing-completeness results for certain architectures, and the absence of a natural substrate for probabilistic sampling and generalized animations as first-class streams (Bukatin et al., 2016).

Within this program, DMMs preserve the RNN “two-stroke engine” structure. The global linear step computes new neuron inputs as linear combinations of previous outputs, and the local nonlinear step applies neuron transforms to those inputs. What changes is the surrounding formalism: DMMs allow multiple stream kinds, multiple neuron types with arbitrary input and output arities, countably many potential neurons with only a finite active subnetwork at any time, and explicit self-reference through neurons that can read and modify the network matrix while the network is running (Bukatin et al., 2016, Bukatin et al., 2017).

This framing places DMMs at the intersection of recurrent neural networks, synchronous dataflow programming, and linear models of computation. The papers repeatedly treat the matrix not only as a parameterization of network dynamics but as the primary program representation. A DMM program over a fixed signature is a sparse matrix, and program evolution is a trajectory in the corresponding matrix space (Bukatin et al., 2016).

2. Formal architecture and dynamics

In the typed formulation, one fixes a signature: a finite set of stream kinds and a finite set of neuron types. Each neuron type has a finite non-negative input arity, a positive output arity, designated stream kinds for each port, and an associated transform. One then takes a countable number of copies of each neuron type, obtaining a countable set of neuron inputs and outputs indexed across the whole network (Bukatin et al., 2016, Bukatin et al., 2016).

The central object is the dataflow matrix $A = (a_{ij})$. Rows correspond to neuron inputs, columns correspond to neuron outputs, and $a_{ij}\in\mathbb{R}$ is the weight by which output $X_j$ contributes to input $Y_i$. The matrix is countable in size but sparse: at any time only finitely many entries are non-zero. This sparsity guarantees that any finite dataflow graph over the signature can be embedded into the universal countable graph, while keeping computation restricted to a finite active part (Bukatin et al., 2016).

At time $t$, the output state is $\mathbf{X}(t)=(X_1(t),X_2(t),\dots)$, and the inputs are derived by the linear step

$$Y_i(t)=\sum_j a_{ij}X_j(t), \qquad \mathbf{Y}(t)=A\mathbf{X}(t).$$

Each neuron $k$, with input indices $I_k$, output indices $O_k$, and transform $a_{ij}\in\mathbb{R}$0, then performs the nonlinear update

$a_{ij}\in\mathbb{R}$1

Collectively, the network step has the same conceptual form as an RNN step,

$a_{ij}\in\mathbb{R}$2

but here $a_{ij}\in\mathbb{R}$3 is block-structured by neuron type rather than a single homogeneous activation (Bukatin et al., 2016).

The later V-value formulation rewrites the same architecture with a single universal stream type and a rank-6 sparse weight tensor

$a_{ij}\in\mathbb{R}$4

where $a_{ij}\in\mathbb{R}$5 and $a_{ij}\in\mathbb{R}$6 are neuron types, $a_{ij}\in\mathbb{R}$7 and $a_{ij}\in\mathbb{R}$8 are neuron names, and $a_{ij}\in\mathbb{R}$9 are labeled input and output fields. The down movement becomes

$X_j$0

and the up movement becomes

$X_j$1

This preserves the same global-local decomposition while moving from typed ports to named fields inside structured values (Bukatin et al., 2017).

3. Linear streams, stream kinds, and V-values

A defining feature of DMMs is the replacement of scalar activation streams by linear streams. For a given stream kind, values live in a vector space $X_j$2, and linear combinations of streams are defined pointwise in time or, for sampling-based streams, by an appropriate stochastic mixture procedure (Bukatin et al., 2016, Bukatin et al., 2017). Typed DMMs keep kinds separate: no direct linear combination of streams of different kinds is allowed; cross-kind transformations must go through neurons (Bukatin et al., 2016).

The early papers emphasize several canonical stream classes. Real-valued streams and finite-dimensional vector streams recover the ordinary RNN setting. Generalized animations treat image-like objects as vectors with pixel-wise or voxel-wise linear operations. Probabilistic sampling streams represent probability distributions or signed measures by samples; positive linear combinations correspond to mixture distributions, and in the signed-measure formulation the sign of a coefficient determines whether a sample is marked as coming from the positive or negative part of the distribution (Bukatin et al., 2016, Bukatin et al., 2016). This is the basis for the claim that DMMs can hybridize recurrent computation with probabilistic programming.

The 2017 line of work introduces a particularly important single-stream instantiation based on the vector space $X_j$3 of finite prefix trees with numerical leaves (Bukatin et al., 2017). Formally, $X_j$4 is the free vector space over the set $X_j$5 of finite strings over a countable token set $X_j$6, restricted to finite support. The same structure admits several equivalent views: finite prefix trees, sparse mixed-rank tensors, and recurrent maps. In the recurrent-map view,

$X_j$7

with finitary maps only. In implementation-oriented terms, a V-value is a nested map, often with a reserved :number key for the scalar component (Bukatin et al., 2017, Bukatin et al., 2017).

This construction is important for two reasons. First, it supplies a single universal stream type that can encode scalars, sparse vectors, matrices, higher-rank tensors, lists, trees, graphs, and associative arrays. Second, it supports variadic neurons: a neuron can read selected first-level labels as named inputs and emit selected first-level labels as named outputs, even though the formal type is simply $X_j$8, where $X_j$9 is the top-level map space with no scalar at the root (Bukatin et al., 2017). The papers explicitly relate V-values to dictionary-based analogues of Lisp S-expressions, but with vector-space structure and therefore with compatibility with DMM linear algebra (Bukatin et al., 2017).

4. Self-reference, higher-order neurons, and pure DMMs

A central novelty of DMMs is their explicit self-referential mechanism. The basic idea is to include matrix-valued streams whose elements have the same index structure as the network matrix, and to designate a distinguished neuron, Self, whose output is the current matrix and whose input accumulates matrix updates (Bukatin et al., 2016, Bukatin et al., 2017). In the simplest formulation, Self is an identity transformer with a weight-1 connection from its output back to its input; if other neurons send a matrix $Y_i$0 into that input, then the next output becomes

$Y_i$1

Future down movements then use $Y_i$2 instead of $Y_i$3 (Bukatin et al., 2016, Bukatin et al., 2016).

This mechanism turns the weight matrix into first-class data. Higher-order neurons can read the current matrix, operate on rows, columns, or submatrices, and emit structured updates. The canonical matrix-editing idiom is the update operation

$Y_i$4

where $Y_i$5 selects rows to update, $Y_i$6 is a column mask, and $Y_i$7 selects rows to read from (Bukatin et al., 2016, Bukatin et al., 2016). The papers emphasize that such updates act on functional blocks rather than isolated weights, which is presented as more robust than element-wise weight tinkering.

The 2016 programming paper makes this matrix-centricity explicit in a DMM-oriented language with declarations such as #kind, #newcelltype, #neuron, #weight, and #updateweights, and stresses a key semantic point: declaring neurons or streams does not by itself change behavior; the only way to change behavior is to update the matrix weights (Bukatin et al., 2016). This is a distinctive feature of the programming model: topology, activation of dormant neurons, subnetwork encapsulation, and deep copy are all matrix operations.

The “pure” variant pushes self-reference further by using only one stream kind: streams of appropriately shaped matrices (Bukatin et al., 2016). Pure DMMs are proposed as an analogue of untyped lambda calculus for this architecture: all data are matrices, and matrices describe pure DMMs themselves. In this setting, even scalars, rows, columns, and other vectors are encoded as matrices. The paper also refines the accumulator discipline by splitting the state $Y_i$8 from the update $Y_i$9, so that Self explicitly computes

$t$0

from a persistent state input and a separate update input, which is especially useful when $t$1 is a large sparse structure and $t$2 is a small patch (Bukatin et al., 2016).

5. Programming idioms, examples, and implementation practice

The programming literature on DMMs treats recurrent connectivity patterns as reusable programming idioms. The simplest is the identity neuron with a self-loop of weight $t$3, which becomes an accumulator. Changing the self-loop weight to a value $t$4 yields a leaky accumulator, and setting it to $t$5 yields an oscillator (Bukatin et al., 2016). These are not merely low-level implementation tricks; they are presented as basic stateful building blocks for program-like behavior inside the network.

A second major idiom is multiplicative masking. A neuron may have one data input and one scalar mask input, with outputs multiplied by the mask value. When the mask is $t$6, the neuron is effectively inactive; when the mask is $t$7, it is fully active. This supports conditionals, gating, sequential layer firing, and subnetwork control, and the papers explicitly compare such constructions to if-statements, gating, and attention-like mechanisms (Bukatin et al., 2016, Bukatin et al., 2016).

A third family of idioms concerns structural editing: subnetworks, deep copy, and active data. The deep-copy operations described in the 2016 programming paper copy internal connectivity blocks and, depending on the variant, may also copy incoming and outgoing external connectivity or distribute outgoing weights between old and new copies (Bukatin et al., 2016). Since neurons exist in a countable address space, setting previously zero weights to non-zero activates dormant neurons, while returning all associated weights to zero effectively garbage-collects them. This is the basis for dynamically expandable memory in DMMs (Bukatin et al., 2016).

The duplicate-character detector serves as the most concrete worked example. Characters are represented as c-vector streams using 1-of-$t$8 encoding, an accumulator sums all characters seen so far, a max-norm-of-c-vector neuron computes the maximum coordinate, a comparison neuron tests whether that maximum exceeds $t$9, and a separate dot-product path detects the end-of-string marker (Bukatin et al., 2016). The paper reports that, in DMM form, the solution uses 9 neurons and 10 non-zero scalar connection weights, and that propagation delays are part of the semantics: input-to-output latency is determined by graph depth, with the example organized so that the duplicate-detection path does not lag behind end-of-string detection (Bukatin et al., 2016).

Implementation discussions across the papers assume a universal countable dataflow graph realized by sparse data structures. Only a finite subset of neurons and weights is active at any given time; rows and columns with all zeros can remain only logical, not computational, objects (Bukatin et al., 2016, Bukatin et al., 2016). In the lightweight pure-DMM prototypes, fixed-size matrix streams were implemented in Processing 2.2.1 under the Fluid project, and experiments demonstrated oscillation of network weights and wave-like movement of nonzero connectivity along a row of the control matrix (Bukatin et al., 2016).

6. Relation to RNNs, expressive power, and unresolved issues

Every DMM paper in this corpus presents classical RNNs as a special case. If one restricts the signature to a single stream kind over $\mathbf{X}(t)=(X_1(t),X_2(t),\dots)$0, a single neuron type with fixed nonlinearity, a fixed finite network, and a fixed finite connectivity matrix, the DMM update reduces to the familiar RNN form (Bukatin et al., 2016, Bukatin et al., 2016). The later survey adds that DMMs also contain architectures such as LSTMs and Gated Recurrent Units as special cases (Bukatin et al., 2017). The generalization consists in moving from homogeneous scalar/vector recurrence to arbitrary linear streams, arbitrary arities, countable sparse address spaces, and self-referential topology updates.

The papers consistently ascribe strong expressive power to this framework. DMMs are described as Turing-complete and as a general-purpose model of computation, with the countable-but-finitely-active network playing the role of unbounded addressable memory and with accumulators, gating, and self-modification providing the ingredients for deterministic programs, probabilistic programs, and dynamic systems (Bukatin et al., 2017, Bukatin et al., 2017). The probabilistic angle is especially explicit in the early papers: streams of samples, mixtures of distributions, and signed measures are treated as linear streams, and this is proposed as a substrate for probabilistic programming and program synthesis (Bukatin et al., 2016).

At the same time, the literature is explicit that many aspects remain exploratory. Rich signatures make the framework expressive but complicated; efficient representation and updating of infinite sparse matrices is a separate technical topic; streams over infinite-dimensional spaces may require approximate representations such as sampling; and practical training methodologies for networks that modify their own topology are not yet developed (Bukatin et al., 2016, Bukatin et al., 2017). The V-value line further notes that irregular, variadic architectures are harder to batch and less GPU-friendly than fixed-shape lightweight pure DMMs, while pure DMMs trade some expressiveness for regularity (Bukatin et al., 2016, Bukatin et al., 2017).

A recurrent theme is continuity of program space. Because DMM programs are represented by real matrices or tensors, and because the transition combines a linear operator with built-in continuous activations, small changes in weights produce small changes in behavior under the appropriate stream-space norms (Bukatin et al., 2017). This suggests an overview of hand-crafted programming, differentiable programming, and continuous optimization. The papers are careful, however, not to treat this as a completed engineering program: they state that it remains to be seen whether DMMs can become fully competitive with traditional programming platforms for practical general-purpose software engineering (Bukatin et al., 2017).

In that sense, DMMs occupy a distinctive position in the neural-programming landscape. They are neither merely a larger class of recurrent networks nor simply a reformulation of dataflow graphs. They are a matrix-parametrized attempt to unify structured data, variadic computation, self-modification, and continuous program deformation within a single recurrent formalism (Bukatin et al., 2016, Bukatin et al., 2017).