💻 bioinformatics

Bioprocess Modeling Made Easy With Hybrax

This paper introduces Hybrax, an open-source Python framework that streamlines bioprocess modeling by providing a standardized data format and an automated end-to-end training pipeline for hybrid mechanistic-neural network models, thereby enhancing reproducibility and reducing the coding effort required to develop and share these models.

Original authors: Libiseller-Egger, J., Gotsmy, M., Guillen-Gosalbez, G., Zanghellini, J.

Published 2026-11-06

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Libiseller-Egger, J., Gotsmy, M., Guillen-Gosalbez, G., Zanghellini, J.

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ⚕️ This is an AI-generated explanation of a preprint that has not been peer-reviewed. It is not medical advice. Do not make health decisions based on this content. Read full disclaimer

In the factories that make life-saving medicines, the most critical work often happens inside invisible glass vessels where tiny cells are coaxed into producing complex proteins. These bioprocesses are delicate, expensive, and difficult to control because the living organisms inside are constantly changing their behavior in response to their environment. Scientists have long tried to build computer models to predict how these cells will act, hoping to optimize production without running endless, costly experiments. The most successful approach so far has been a hybrid method: combining the known laws of physics and chemistry with flexible computer programs that learn patterns directly from the data. However, building these models has traditionally been a laborious, custom job for every single project, requiring researchers to write vast amounts of code just to handle the messy details of feeding the cells, removing samples, and tracking volume changes. This repetitive work has made it difficult to share models or compare different approaches, slowing down progress in the field.

To solve this bottleneck, a team of researchers has developed a new open-source software framework called Hybrax. Think of this tool as a standardized chassis for building bioprocess models, much like a car frame allows engineers to swap out engines without rebuilding the entire vehicle. Before Hybrax, scientists had to manually write the code that accounts for how adding liquid or removing a sample changes the concentration of substances in the reactor. Hybrax automates this entire process. It takes raw data from the lab—measurements of what was added, what was removed, and what the cells produced—and automatically calculates the necessary physical adjustments. This allows researchers to skip the tedious plumbing of the code and focus entirely on the biological question: how do the cells actually behave?

The framework is designed to be flexible enough to handle different types of models, from those based strictly on known chemical equations to those that use artificial intelligence to guess the unknown parts of the process. The researchers demonstrated its power by re-creating two existing models from scientific literature. The first involved a well-known bacterium, E. coli, used to produce a specific compound. By feeding the real-world data from a previous study into Hybrax, the team built a model that matched the original results, achieving a high level of accuracy in predicting biomass and product levels. The second test used synthetic data from a mammalian cell line, HEK293, which is commonly used to make antibodies. This process is more complex, involving dozens of different nutrients and waste products. The team built a model using a type of artificial intelligence known as a long short-term memory network, which is good at remembering patterns over time. This model performed just as well as the original version written in a different programming language, accurately predicting the levels of biomass, antibodies, and glucose over time.

One of the most significant features of Hybrax is how it handles the sharing of scientific work. In many fields, it is difficult to reproduce a study because the original data is buried in custom spreadsheets and the code is scattered across different files. Hybrax bundles everything together. Every time a model is trained, the software saves a complete checkpoint containing the model's settings, the code used to define it, the configuration, and the processed data. This means that any other researcher can take that single file, run the model immediately, or retrain it from scratch without needing to hunt down the original dataset or decipher the original author's notes. The researchers found that this approach not only made their own work faster but also made it possible to swap different model architectures onto the same data set with ease, allowing for direct and fair comparisons of which methods work best.

The team also showed that the software can handle the tricky problem of keeping predictions physically realistic. In their tests with the mammalian cells, the initial models sometimes predicted negative amounts of a substance, which is impossible in the real world. By adding a simple rule to the software that penalizes these impossible predictions, they were able to train a second version of the model that performed just as well but kept all its predictions positive. This flexibility suggests that the tool can be adapted to enforce the physical laws of the specific process being studied without requiring a complete rewrite of the underlying code.

Ultimately, Hybrax represents a shift toward making bioprocess modeling more accessible and reproducible. By taking the routine, repetitive tasks of data preparation and equation setup off the shoulders of researchers, the software frees them to focus on the actual science of how cells function. The authors note that while the tool is currently open-source and available for anyone to use, it is still evolving. Future versions will aim to improve training speed and add better tools for understanding why a model makes certain predictions. For now, the framework stands as a practical solution to a long-standing problem, offering a way to build, share, and compare complex biological models with a level of clarity and consistency that was previously out of reach.

Technical Summary: Hybrax – A Framework for Bioprocess Hybrid Modeling

Problem Statement
Bioprocess modeling increasingly relies on Hybrid Models (HMs)—systems of Ordinary Differential Equations (ODEs) where parameters are estimated by Artificial Neural Networks (ANNs)—to bridge the gap between mechanistic interpretability and data-driven flexibility. However, the practical implementation of HMs remains a significant bottleneck. Researchers currently face three primary challenges:

Repetitive Coding Effort: Setting up an HM requires extensive custom code for data import, pre-processing, handling discontinuous events (e.g., bolus feeds, sampling), and deriving transport terms (mass balances) for volume changes. This "boilerplate" code is often rewritten from scratch for every project.
Lack of Standardization: There is no widely adopted format for bioprocess data. Datasets are typically published in bespoke spreadsheets or not at all, making it difficult to reproduce, reuse, or compare models across the literature.
Tool Fragmentation: Existing open-source tools either lack efficient ANN training machinery (e.g., pyFOOMB) or target broader systems biology without specific bioprocess features like feeding and sampling (e.g., PEtab SciML, SiNDAE). While some tools like HYBpy cover bioprocess applications, they often trade flexibility for ease-of-use, supporting only a subset of model architectures and lacking custom loss functions. Commercial tools exist but are proprietary and closed-source.

Methodology
The authors present Hybrax, an open-source Python framework designed to serve as a "chassis" for bioprocess hybrid modeling. Hybrax integrates a flexible data representation with a customizable end-to-end training pipeline.

Core Architecture: Hybrax is built on JAX, Equinox, and Diffrax, utilizing differentiable ODE solvers to enable direct training on concentration data without intermediate rate estimation.
Data Representation (hybrax.format): The framework introduces a novel, ontology-inspired data structure (BioProcessCollection and BioProcess objects). This structure explicitly encodes:
- Process configuration (inflows, outflows, media composition).
- Measured and controlled variables (e.g., biomass, pH, temperature).
- Discrete events (e.g., sampling, bolus feeds).
- Automatic Transport Derivation: Based on the process configuration, Hybrax automatically constructs the transport terms ( $T$ ) of the ODEs ( $\frac{dy}{dt} = R(y, q) + T(y, u)$ ). This eliminates the need for researchers to manually derive mass balance terms for volume changes.
- Reaction Dynamics: Users define the reaction term ( $R$ ) via a ReactionOde, which can include symbolic expressions for algebraic quantities (e.g., active biomass vs. total biomass) and placeholders for rates ( $q$ ) to be estimated by the neural network ( $f_\theta$ ).
Training Pipeline (hybrax.train): The framework provides a modular command-line interface with four entry points:
- prepare: Handles data transformations (augmentation, smoothing) and validation without modifying raw data.
- train: Fits models to data using user-defined custom.py modules for the neural network architecture.
- loo: Performs cross-validation (defaulting to leave-one-out) to train ensembles.
- forward: Generates predictions on new data.
Reproducibility: Training checkpoints are self-contained, bundling model parameters, optimizer states, configuration, custom code, and pre-processed data, allowing for immediate re-runs or retraining from scratch.

Key Contributions

Unified Framework: Hybrax is an open-source framework that combines a versatile bioprocess data format with a complete, flexible training pipeline specifically for mechanistic and hybrid models, addressing the lack of tools that balance routine automation with design flexibility.
Automation of Transport Terms: By deriving dilution and feed terms automatically from process configuration, Hybrax significantly reduces the coding burden and potential for human error in mass balance formulation.
Decoupled Model Design: The separation of the process dynamics (transport and reaction structure) from the rate estimation function ( $f_\theta$ ) allows researchers to swap model architectures (e.g., from kinetic expressions to ANNs) without rewriting the entire pipeline.
Enhanced Reproducibility: The framework facilitates the sharing of complete training artifacts, addressing the "bespoke spreadsheet" problem and enabling direct benchmarking of different model architectures on identical datasets.

Results
The authors validated Hybrax by re-implementing two distinct models from the literature:

Mechanistic Model (E. coli): A pruned mechanistic model (OptFed) was fitted directly to raw concentration data. Hybrax achieved comparable or better agreement with measurements than the original study ( $R^2$ of 0.86 for biomass and 0.85 for product vs. 0.83 and 0.82 in the original).
Hybrid Model (E. coli): A simple ANN-based HM (2 dense layers) was trained on the same dataset. Despite its small size (59 parameters), it achieved reconstruction losses similar to the full kinetic model ( $R^2$ of 0.90 and 0.85).
LSTM Hybrid Model (HEK293): An LSTM-based HM was implemented for a mammalian cell culture process (inspired by Ramos et al.). Using Principal Component Analysis (PCA) to reduce the dimensionality of reaction rates, the Hybrax implementation achieved Normalized Root Mean Squared Error (NRMSE) values on test data (0.0348) comparable to the original MATLAB model (0.0376). Furthermore, the framework demonstrated the ease of adding penalty terms to the loss function to enforce non-negative concentration constraints, reducing negative prediction artifacts by an order of magnitude.

Significance and Claims
The paper positions Hybrax as a necessary step toward standardizing bioprocess modeling, an area lagging behind genomics and proteomics in open-source momentum. The authors claim that by handling routine functional tasks (ODE transport terms, scaling, training loops), Hybrax allows researchers to focus on the core scientific challenge: developing the process-specific model itself.

The framework is presented not as a solution to all modeling challenges, but as a robust foundation for rapid prototyping and model comparison. The authors emphasize that Hybrax enables comprehensive benchmarks—comparing meaningful portions of published model architectures on diverse, publicly available data—which were previously "exceedingly difficult to conduct" due to the lack of standardized pipelines and data formats. The work aims to reduce duplicated effort and accelerate progress in the field by making model sharing and reproducibility seamless.

More like this