DeepMind initiated a strategic shift nearly a year ago to adopt TensorFlow (TF) as the sole framework across its research organization. This move has proven to be a strong decision, delivering tangible benefits across models and workflows. In particular, many of our models learn at markedly faster rates, and the built-in distributed training features embedded in TF have substantially simplified our codebases. As we navigated this transition, we discovered that TF’s flexibility and adaptability are well-suited for constructing higher-level tooling tailored to our research needs. In response, we developed a dedicated framework to accelerate the construction of neural network modules within TF. Today, we are excited to announce that this framework is being open-sourced. We have named it Sonnet.
TF Adoption and Early Impact on Research Productivity
From the outset, the shift to TensorFlow represented more than a change in tooling; it signified a reimagining of how DeepMind conducts rapid experimentation at scale. The move leveraged TF’s robust ecosystem for large-scale model training, enabling researchers to deploy more ambitious architectures without being overwhelmed by boilerplate code or stability concerns. One of the most immediate advantages was the acceleration of learning curves for novel models. Researchers could iterate faster because TF’s dataflow graph model and its optimizations—ranging from automatic differentiation to device placement—facilitate experimentation with fewer hand-tuned patches for performance.
The built-in distributed training capabilities embedded in TF played a central role in reducing the friction that often accompanies scaling experiments. Researchers could distribute workloads across multiple GPUs or machines with relative ease, which translated into more substantial gains in throughput and more reliable benchmarking. This, in turn, allowed teams to test hypotheses at larger scales and with more rigorous control over experimental conditions. The overall effect was a more efficient research pipeline: faster prototyping, more reproducible results, and a clearer path from idea to empirical validation.
Another key takeaway from the transition was TF’s broad flexibility and adaptability. These qualities proved especially valuable when exploring high-level abstractions and frameworks designed to support specific research workflows. Rather than being constrained by a monolithic codebase, our teams could tailor and extend the TF ecosystem to fit the distinctive requirements of various research quests. It became clear that the framework’s extensibility wasn’t merely a convenience; it was a foundational capability that encouraged innovative approaches to neural architectures and training paradigms.
Given this environment, we recognized an opportunity to create tooling that would further streamline the development of neural network modules within TF. The result is Sonnet, a practical, object-oriented framework designed to complement TF’s core capabilities. Sonnet aims to make it faster and easier to assemble, reuse, and experiment with neural network components—without compromising the flexibility researchers expect from TF. This is not a competing framework; it is a specialized layer that sits atop TF to accelerate modular design patterns and to standardize practices across DeepMind’s research groups.
Sonnet: A Purpose-Built Framework for Neural Network Modules in TensorFlow
The creation of Sonnet was driven by concrete research needs and an intimate understanding of how deep neural networks are commonly composed. At its core, Sonnet embraces an object-oriented approach that mirrors familiar patterns from other deep learning libraries, while adding features that are particularly valuable for research-oriented workflows. The design philosophy centers on enabling modules to encapsulate forward computations and to be composed into larger architectures with clarity and reuse in mind.
In practice, Sonnet modules define a forward pass over input tensors and, when invoked, contribute new operations to the computational graph in a predictable manner. A deliberate design choice was to manage variable sharing transparently: subsequent calls to the same module automatically reuse existing variables. This eliminates a significant source of boilerplate and potential errors, allowing researchers to focus on architectural innovation rather than low-level bookkeeping.
Sonnet’s architecture supports a natural hierarchy of components. Many neural networks can be viewed as composed of submodules in a nested structure. For example, a Differentiable Neural Computer may contain a controller, which itself can be realized as an LSTM, which can be implemented using standard linear layers. Recognizing and exploiting this hierarchy yields practical benefits: code that models such structures can be more easily reused, extended, and tested. Sonnet explicitly encourages declaring submodules within a parent module or injecting submodules at construction time, which fosters modularity and rapid experimentation.
The module-based, forward-pass-centric model in Sonnet aligns well with both established and emerging practices in neural network research. It enables researchers to construct complex architectures by aggregating smaller, well-defined building blocks. In addition, the framework supports clear separation of concerns: a module is responsible for a specific computation, a submodule encapsulates a distinct neural component, and high-level models are assembled by composing these parts. This organization improves readability, maintainability, and scalability of code—an essential consideration when pursuing reproducible, long-running research projects.
Sonnet’s design also emphasizes ease of reuse across different models and experiments. By allowing modules to declare submodules internally or to accept other modules via their construction interfaces, researchers can rapidly explore different configurations without rewriting substantial portions of code. This capability becomes especially valuable when iterating on architectures that share common substructures or when implementing a family of models that differ primarily in the arrangement or parameters of their components. In such cases, the framework reduces duplication and accelerates the path from concept to testable implementation.
From a practical standpoint, Sonnet is intended to integrate smoothly with the broader TensorFlow ecosystem. It leverages TF’s graph-based execution model while providing a more ergonomic, object-oriented API for common neural network constructs. This combination helps researchers stay focused on experimental design and empirical evaluation rather than wrestling with low-level API intricacies. The result is a tool that amplifies the speed and quality of research without compromising the rigor and flexibility that TF already enables.
Public Release and the Learning-to-Learn Paper: A Step Toward Community Collaboration
The decision to publish Sonnet publicly was motivated by the desire to democratize the tooling that had proven valuable within DeepMind. By making Sonnet available to the research community, we make it easier for other models developed at DeepMind to be shared and reused, broadening the potential impact of the framework beyond internal projects. Our aim is to foster a broader ecosystem in which researchers can build on each other’s work, lowering barriers to entry and accelerating progress in machine learning research.
The timing of the release is tied to the Learning to Learn paper, where Sonnet’s initial capabilities were showcased in a preliminary form. The code accompanying that publication included an initial version of Sonnet, demonstrating how it could be used to implement neural networks and experiment with novel training paradigms. Since then, we have continued to refine the framework and to develop its capabilities further. The current public release represents the culmination of those efforts and provides a more complete and robust foundation for researchers to leverage in their own work.
As part of the broader strategy, we intend for forthcoming code releases to build on the fully developed Sonnet library now being made available. This approach ensures that new iterations, features, and improvements can be integrated smoothly, reducing fragmentation and promoting a cohesive development experience for users. In this way, Sonnet serves not only as a tool for DeepMind researchers but also as a platform that can adapt to the evolving needs of the machine learning community.
Making Sonnet public offers practical benefits for internal and external researchers alike. For DeepMind, it enables models and experiences developed within our labs to be more easily shared with the community, promoting collaboration and transparency. For the wider research community, Sonnet provides a structured, well-documented approach to building neural network modules with TF, potentially reducing the time required to implement common architectures and enabling researchers to focus on novel ideas and experiments.
DeepMind’s Open-Source Momentum and the Broader TensorFlow Ecosystem
In recent months, DeepMind has extended its open-source initiatives beyond Sonnet by releasing another flagship platform: DeepMind Lab. The lab represents a rich environment for AI research and has been opened to the public as part of our ongoing commitment to reproducibility and collaboration. The open-source strategy aligns with the broader growth of TensorFlow-based tooling in the research community, where a diverse ecosystem of higher-level libraries has emerged since TensorFlow’s initial release in November 2015. These libraries collectively enable researchers to accomplish common tasks more quickly, allowing them to experiment with more ambitious ideas and to compare results across different approaches with greater ease.
Sonnet shares many philosophical similarities with existing neural network libraries that emphasize modular design and forward computation, but it has features that are specifically tailored to DeepMind’s research requirements. The framework’s emphasis on clarity, reuse, and hierarchical organization mirrors common patterns in contemporary deep learning research while adapting them to a practical workflow that supports large-scale experimentation and rapid iteration.
As part of this ecosystem, DeepMind has contributed a practical example of how higher-level abstractions can integrate with TF’s core capabilities. The code release associated with Sonnet demonstrates how researchers can structure neural networks in a modular, reusable fashion, enabling rapid prototyping of complex architectures. This approach complements other efforts within the TensorFlow ecosystem, reinforcing a collaborative dynamic where researchers can leverage shared tools to accelerate progress.
Looking ahead, the open-source strategy is expected to continue with additional releases and enhancements. We anticipate that more projects will be published that either build on Sonnet or integrate with it in meaningful ways. The ongoing development will be coordinated through a central Open Source page, which serves as a hub where researchers can discover, evaluate, and adopt new tools that align with their work. In this way, the broader community benefits from a connected set of resources designed to advance AI research collectively.
The Object-Oriented Paradigm: Modules, Forward Passes, and Transparent Variable Sharing
A core aspect of Sonnet’s value proposition is its adherence to an object-oriented paradigm that resonates with approaches familiar to Torch/NN users, while delivering TF-specific advantages. The fundamental construct in Sonnet is the module—a self-contained unit that encapsulates a forward pass of computation. These modules can be instantiated, configured, and invoked with input tensors. When invoked, a module contributes the necessary operations to the computational graph and returns output tensors, enabling seamless composition with other modules to form more complex networks.
One of the design goals behind Sonnet is to handle variable sharing in a transparent and automatic manner. In many neural network architectures, reusing the same module across multiple parts of a network is common, requiring careful management of variable reuse to ensure consistent parameters. Sonnet addresses this challenge by automatically reusing variables when the same module is called again. This feature reduces boilerplate and minimizes the risk of inadvertently creating duplicate variables, a frequent source of confusion during rapid experimentation.
The relationship between modules and submodules is central to Sonnet’s modular philosophy. Many research models can naturally be described as hierarchical structures in which a high-level module contains several submodules. By explicitly representing submodules within a parent module, researchers gain the ability to encapsulate complex functionality in a clear, reusable unit. Sonnet also supports the alternative pattern of passing pre-constructed submodules during the parent module’s initialization, enabling flexible composition and experimentation with different configurations.
This emphasis on submodules and hierarchical organization has practical implications for research workflows. First, it promotes reuse: a submodule that implements a particular transformation can be employed across multiple models or experiments without reimplementation. Second, it supports rapid iteration: researchers can swap submodules with alternatives to assess how a given architectural choice affects performance, convergence, or generalization. Third, it makes code easier to read and reason about: a model’s structure is laid out in a way that mirrors the underlying architecture, making it simpler to identify which components contribute to a given behavior.
From a broader perspective, the object-oriented approach aligns with the way many researchers conceive of neural network architectures. It mirrors natural engineering practices, where systems are decomposed into components with defined interfaces and responsibilities. This alignment helps bridge the gap between theoretical ideas and practical implementations, facilitating more productive collaboration among team members who contribute to Sonnet-based projects.
Use Cases: Hierarchical Models, Reuse, and Quick Experimentation
The architecture of neural networks in real-world research often mirrors hierarchical patterns. For instance, a Differentiable Neural Computer may involve a controller that could itself be an LSTM, which in turn relies on standard linear layers for its internal computations. The ability to represent such structure in a modular fashion—where submodules can be declared internally or supplied from the outside—enables researchers to articulate and manipulate these designs with clarity and efficiency.
With Sonnet, researchers can define a high-level module that orchestrates several submodules, each responsible for a distinct subtask within the broader computation. This approach yields several practical benefits:
-
Code reuse: Submodules representing common operations (e.g., attention mechanisms, feedforward blocks, normalization layers) can be reused across multiple models without duplicating code.
-
Rapid experimentation: Researchers can assemble different architectural configurations by swapping submodules at construction time or by reconfiguring internal submodules, enabling quick testing of hypotheses about component interactions.
-
Better organization: The hierarchical structure clarifies the relationships among components, making it easier to understand and modify large, complex networks.
-
Improved readability: The modular composition maps naturally to the conceptual structure of the network, which helps new contributors understand and extend the codebase.
Beyond architectural experimentation, Sonnet also supports practical benefits for training and evaluation workflows. By encapsulating behaviors in well-defined modules, teams can write focused unit tests, validate the behavior of individual components, and ensure consistent interfaces across different models. This modularity reduces debugging time and improves the reliability of experimental results, which is particularly valuable in long-running research programs that require reproducibility and robust benchmarking.
Open Source Momentum and Community Engagement
The release of Sonnet marks a meaningful step in DeepMind’s ongoing commitment to open science and community engagement. By sharing the framework with the broader research community, we invite others to build on the same foundation that has proven useful within our own labs. This reciprocal exchange has the potential to accelerate progress across the field, as researchers adopt standardized patterns for building neural networks with TensorFlow and contribute improvements that benefit all users.
In parallel with Sonnet’s release, we have also expanded our open-source footprint by making DeepMind Lab available to the public. The lab provides a rich environment for AI research with a focus on navigation and interaction within 3D environments, offering researchers a platform to explore reinforcement learning, planning, and other advanced techniques. The Together with industry collaborations—such as our ongoing work with Blizzard to develop an open-source API for StarCraft II AI research—demonstrates our broader strategy of combining open tooling with real-world applications. These initiatives underscore our belief that sharing tools and resources accelerates discovery and fosters a vibrant ecosystem around AI research.
Looking forward, the Open Source page serves as a central hub for forthcoming releases and updates. The promise of additional tooling, libraries, and improvements will be reflected there, ensuring researchers have access to a coherent set of resources that align with their needs. By maintaining a cohesive platform for open-source contributions, we aim to reduce fragmentation, encourage interoperability, and promote collaborative progress across teams and institutions.
Technical Philosophy: Compatibility, Extensibility, and Research-Driven Design
Sonnet’s technical philosophy emphasizes compatibility with the TensorFlow core while prioritizing extensibility and a research-driven design. The framework is built to be pragmatic: it offers a clear, readable API that aligns with the way researchers conceptualize neural networks, while remaining faithful to TF’s established paradigms. This balance ensures that users can leverage the powerful capabilities of TF without sacrificing the modularity and clarity that Sonnet provides.
The emphasis on forward computation, modular assembly, and transparent variable sharing reflects a practical understanding of how researchers work. By providing a consistent mechanism for reusing variables, Sonnet reduces the cognitive load associated with managing parameter scope and lifetimes across complex networks. This, in turn, fosters more reliable experimentation and reduces the likelihood of subtle errors that can undermine interpretability or reproducibility.
In practice, Sonnet enables researchers to express architectural ideas in a way that mirrors their conceptual models. By supporting internal submodule declarations and the ability to accept pre-constructed modules at construction time, Sonnet makes it straightforward to prototype a family of architectures that share common building blocks. This design supports the iterative cycles of hypothesis, implementation, and evaluation that characterize state-of-the-art machine learning research.
The broader TF ecosystem—together with Sonnet—supports a wide array of research workflows, from quick, one-off experiments to large-scale, production-grade projects. The synergy between a robust, scalable framework and a modular, reusable design helps researchers push the boundaries of what is possible, while maintaining the rigor and reproducibility required for credible scientific progress.
Conclusion
DeepMind’s transition to TensorFlow has yielded tangible benefits: faster learning in models, streamlined distributed training, and a flexible foundation that supports higher-level frameworks. In response to these advantages, we developed Sonnet, an object-oriented framework that makes it easier to build, reuse, and experiment with neural network modules within TF. We are pleased to open-source Sonnet, making it accessible to the broader research community and enabling DeepMind models to be shared more readily with others who can advance the field.
The broader open-source trajectory—exemplified by the public release of DeepMind Lab and ongoing collaboration in domains like StarCraft II AI research—highlights our commitment to reproducibility, collaboration, and rapid scientific advance. Sonnet sits within a thriving TensorFlow ecosystem of higher-level libraries, designed to address research needs while remaining compatible with TF’s core capabilities. Its emphasis on modular design, clear hierarchies, and automatic variable reuse positions it as a practical tool for researchers seeking to accelerate experimentation and push the frontiers of artificial intelligence.
As we continue to develop Sonnet and expand our open-source offerings, we anticipate sustained engagement from the research community. The ongoing evolution of the framework, the introduction of additional modules and patterns, and the refinement of best practices will likely shape how researchers structure, share, and reproduce neural network experiments for years to come. Our broader goal is to enable researchers everywhere to build more powerful, more reliable models with greater speed and ease, thereby advancing the pace of discovery in AI.
Conclusion
In summary, the decision to adopt TensorFlow across DeepMind has unlocked faster model learning, simplified distributed training, and provided a flexible environment for higher-level frameworks. The creation and open-sourcing of Sonnet—an object-oriented framework designed to facilitate rapid construction and reuse of neural network modules within TF—embodies our commitment to practical tooling that accelerates research. By sharing Sonnet and continuing to contribute to the open-source ecosystem, including DeepMind Lab and collaborations for AI research APIs, we aim to foster a collaborative community that drives progress in machine learning and artificial intelligence for the broader scientific and research community.
