PolyMon: Unified Polymer Property Prediction

• PolyMon is a unified, open-source framework for polymer property prediction that integrates various representations, models, and training strategies.
• It standardizes data ingestion, feature construction, and evaluation, enabling direct comparisons across descriptors, graphs, and sequences.
• It incorporates advanced training strategies such as multi-fidelity learning, Δ-learning, active learning, and ensembles to boost prediction accuracy and reliability.

PolyMon is a unified, open-source framework for polymer property prediction that integrates multiple polymer representations, machine learning methods, and training strategies within a single, accessible platform. It is designed to take a CSV of polymer structures and properties and support systematic benchmarking across descriptors, sequences, graphs, pretrained embeddings, tabular models, graph neural networks, and advanced training protocols such as multi-fidelity learning, $\Delta$-learning, active learning, and ensemble learning. Its benchmark studies focus on five key polymer properties: MD density $\rho_{\rm md}$, fractional free volume (FFV), radius of gyration $R_g$, thermal conductivity (TC), and glass transition temperature $T_g$ (Ren et al., 2 Mar 2026).

1. Definition, motivation, and problem setting

PolyMon addresses several persistent problems in polymer property prediction. The underlying application domain is characterized by data scarcity and heterogeneity, because many polymer properties are expensive to measure or simulate and because datasets often mix experiments, molecular dynamics (MD), and empirical equations. At the same time, polymer ML is fragmented across incompatible representations—monomer SMILES, oligomer structures, graphs with or without periodicity, hand-crafted descriptors, and embeddings from polymer LLMs such as PolyBERT and PolyCL—while model comparisons are often confounded by inconsistent datasets, splits, and evaluation protocols (Ren et al., 2 Mar 2026).

Within that setting, PolyMon defines a single, coherent framework in which these modeling choices can be varied under the same experimental protocol. Its stated scope is broader than a standalone predictor. It implements a unified API and CLI, supports a broad palette of polymer representations, exposes a large model zoo, and provides plug-and-play advanced strategies including multi-fidelity learning, $\Delta$-learning, active learning, and ensembles. This positioning is important: PolyMon is not presented as one new predictor architecture, but as a benchmarking and experimentation ecosystem for polymer property prediction (Ren et al., 2 Mar 2026).

A common misconception is to treat PolyMon as synonymous with graph-based polymer modeling. The framework is explicitly representation-agnostic and includes both descriptor-centric and graph-centric workflows. Another misconception is to assume that its contribution is limited to model wrappers. The framework also standardizes data ingestion, feature construction, splitting, hyperparameter optimization, cross-validation, checkpointing, and recommendation-style acquisition for active learning.

2. Representations and model families

PolyMon supports descriptor, graph, and sequence-style representations selected through feature flags such as --feature-names and --descriptors. Descriptor-based inputs include RDKit 2D descriptors (rdkit2d, oligomer_rdkit2d), RDKit 3D descriptors (rdkit3d), Mordred (mordred, oligomer_mordred, mordred3d), ECFP4 fingerprints (ecfp4, oligomer_ecfp4), MACCS keys (maccs), XenonPy descriptors (xenonpy_atom, xenonpy_desc), group-contribution and physics-inspired features such as fedors_density, gaff2_mod, and source, and polymer LLM embeddings polycl and polybert. It also includes monomer, defined as monomer SMILES without attachment points (Ren et al., 2 Mar 2026).

Graph-based representations map a polymer to

$$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$

with node feature matrix $X \in \mathbb{R}^{N \times d_v}$ and edge feature tensor $E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$. Node features may include z, xenonpy_atom, cgcnn, pos, and relative_position; edge features include edge, bond, fully_connected_edges, periodic_bond, and virtual_bond. The framework therefore accommodates standard monomer graphs, periodic graphs that connect attachment points to mimic chain periodicity, graphs with virtual nodes for global readout, and graphs with positional encodings relative to attachment points (Ren et al., 2 Mar 2026).

The model zoo spans tabular models, multilayer perceptrons, KAN-based models, and GNNs. The tabular suite includes Random Forest, XGBoost, LightGBM, CatBoost, TabPFN, fastkan, efficientkan, fourierkan, and mlp. The GNN suite includes gatv2, gin, pna, attentivefp, dimenetpp, gt, gps, dmpnn, and polymer-specific or strategy-specific variants such as gatv2vn, gatv2_pe, gatv2_chainreadout, gatv2_source, and gatv2_embed_residual, together with KAN-augmented variants including kan_gin, fastkan_gin, kan_gcn, kan_dmpnn, kan_gatv2, and kan_gps (Ren et al., 2 Mar 2026).

These GNNs share a message-passing structure of the form

$$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$

with architecture-specific choices for $\psi^{(k)}$, $\rho_{\rm md}$0, and $\rho_{\rm md}$1. For GATv2, PolyMon uses attention-weighted message aggregation; for DimeNet++ it uses directional message passing with distance and angle features; and for DMPNN it defines messages on directed edges rather than nodes (Ren et al., 2 Mar 2026).

A practical implication of this design is that PolyMon can evaluate whether performance is primarily controlled by representation choice, model class, or training strategy, rather than embedding those factors in separate codebases.

3. Training strategies and learning protocols

PolyMon’s advanced training strategies are one of its central technical features. In multi-fidelity learning, the framework combines low-fidelity and high-fidelity labels for the same property. For density, the documented workflow is to train a low-fidelity GATv2 model on MD density $\rho_{\rm md}$2, save the pretrained model, and then adapt it to high-fidelity experimental density using either full-network finetuning, encoder-freezing finetuning, label residual learning, or embedding residual learning (Ren et al., 2 Mar 2026).

In the label-residual formulation, the low-fidelity model prediction $\rho_{\rm md}$3 is used as a baseline and a new model learns

$\rho_{\rm md}$4

so that

$\rho_{\rm md}$5

In the embedding-residual formulation, a pretrained embedding $\rho_{\rm md}$6 is combined with the current model embedding $\rho_{\rm md}$7 through

$\rho_{\rm md}$8

where $\rho_{\rm md}$9 is a learned linear projection when dimensions differ (Ren et al., 2 Mar 2026).

PolyMon uses $R_g$0-learning in three contexts. The first is property knowledge transfer, exemplified by TC $R_g$1 density transfer via embedding residual. The second is residual learning against empirical equations for $R_g$2 and density. For $R_g$3, one estimator is

$R_g$4

For density, empirical estimators take the form

$R_g$5

The $R_g$6-learning objective is then

$R_g$7

The third context is atomic contribution models, in which the baseline is a linear model

$R_g$8

over atomic composition vectors $R_g$9 (Ren et al., 2 Mar 2026).

Active learning is implemented through the polymon rec workflow. The loop consists of training on the current labeled set, scoring unlabeled polymers in a pool CSV, selecting candidates via an acquisition function—currently --acquisition uncertainty—labeling them with an external workflow such as RadonPy plus LAMMPS, and retraining. For $T_g$0, the labeling expression used in the framework is

$T_g$1

Ensemble learning is implemented through bagging, multiple seeds, K-fold ensembles, and voting or averaging, with predictive mean and variance computed from the ensemble members (Ren et al., 2 Mar 2026).

This suggests that PolyMon’s most distinctive contribution is not a specific network architecture, but a uniform operationalization of advanced learning regimes that are typically reported in isolation.

4. Benchmarks, datasets, and empirical findings

PolyMon evaluates models on five benchmark properties: MD-predicted density $T_g$2, FFV, $T_g$3, TC, and $T_g$4. The reported data sources include Kaggle competition data, the PI1070 dataset, the PolyMetriX ecosystem, MAFA-exp for experimental density, and MD data from Afzal et al. and RadonPy workflows. The primary split strategy is 5-fold cross-validation for hyperparameter optimization and performance reporting, while --run-production enforces a 95:5 train:validation split (Ren et al., 2 Mar 2026).

Performance is reported mainly as MAE with means and standard deviations over 5 folds. Among tabular models, TabPFN with Mordred descriptors gives the following MAEs: $T_g$5 $T_g$6, FFV $T_g$7, $T_g$8 $T_g$9, TC $\Delta$0, and $\Delta$1 $\Delta$2. Best classical tree models, such as LightGBM with Oligomer-Mordred and CatBoost or LightGBM with Mordred or RDKit2D, are typically in the ranges density MAE $\Delta$3–$\Delta$4, FFV MAE $\Delta$5–$\Delta$6, $\Delta$7 MAE $\Delta$8–$\Delta$9, TC MAE $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$0–$$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$1, and $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$2 MAE $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$3–$$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$4 (Ren et al., 2 Mar 2026).

Among GNNs, GATv2 achieves $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$5 $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$6, FFV $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$7, $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$8 $$G = (V, E),\quad V = \{1,\dots,N\},\quad E \subseteq V\times V$$9, TC $X \in \mathbb{R}^{N \times d_v}$0, and $X \in \mathbb{R}^{N \times d_v}$1 $X \in \mathbb{R}^{N \times d_v}$2. DMPNN gives $X \in \mathbb{R}^{N \times d_v}$3 $X \in \mathbb{R}^{N \times d_v}$4, $X \in \mathbb{R}^{N \times d_v}$5 $X \in \mathbb{R}^{N \times d_v}$6, and TC $X \in \mathbb{R}^{N \times d_v}$7. The gatv2_chain_readout variant slightly improves $X \in \mathbb{R}^{N \times d_v}$8 to $X \in \mathbb{R}^{N \times d_v}$9, supporting the value of chain-level modeling for chain-scale observables (Ren et al., 2 Mar 2026).

Model / representation	Property	MAE
TabPFN + Mordred	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$0	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$1
TabPFN + Mordred	FFV	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$2
TabPFN + Mordred	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$3	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$4
GATv2	FFV	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$5
GATv2	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$6	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$7
DMPNN	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$8	$E_{\text{feat}} \in \mathbb{R}^{|E| \times d_e}$9
DMPNN	TC	$$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$0
gatv2_chain_readout	$$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$1	$$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$2

Several systematic findings recur across the benchmarks. Descriptor-based models, especially TabPFN on Mordred or RDKit2D-type inputs, provide strong baselines and are often competitive when data is limited. GNNs, particularly GATv2 and DMPNN, generally outperform classical tabular models for density, FFV, TC, and $$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$3 given enough data and suitable hyperparameter tuning. For $$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$4, chain-aware graph variants help slightly. By contrast, RDKit3D descriptors perform worse across the board, with density MAE around $$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$5–$$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$6 and $$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$7 MAE around $$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$8–$$h_i^{(k+1)} = \phi^{(k)}\Big( h_i^{(k)}, \square_{j\in\mathcal{N}(i)} \psi^{(k)}(h_i^{(k)}, h_j^{(k)}, e_{ij}) \Big),$$9 in the reported benchmarks (Ren et al., 2 Mar 2026).

The framework also documents strategy-level results. Fine-tuning and residual strategies improve high-fidelity density prediction over training only on the small experimental subset. $\psi^{(k)}$0-learning with empirical equations yields meaningful gains when the empirical baseline is already reasonably accurate, such as density and $\psi^{(k)}$1, and limited benefit where the baseline is poor, such as TC and FFV. Ensembles reduce variance and provide uncertainty estimates, with modest but consistent performance gains. Active learning for $\psi^{(k)}$2 is reported to improve coverage of informative regions in chemical space under an MD labeling budget (Ren et al., 2 Mar 2026).

5. Workflow, command-line interface, and software architecture

PolyMon is implemented as a Python package with both command-line and programmatic interfaces. The two principal CLI entry points are polymon train for training, hyperparameter optimization, cross-validation, and ensembles, and polymon rec for recommendation and active-learning acquisition. Typical polymon train arguments specify the raw CSV, data sources, target labels, feature names or descriptors, model type, model hyperparameters, number of folds, number of Optuna trials, number of epochs, early stopping patience, and strategy flags such as --finetune, --pretrained-model, --train-residual, --low-fidelity-model, --emb-model, --ensemble-type, and --n-estimator (Ren et al., 2 Mar 2026).

The software stack is organized around data handling, feature generation, model wrappers, training loops, early stopping, logging, and checkpointing. Checkpoints store model weights together with hyperparameters, feature metadata, and normalization or transformation parameters. Prediction can be performed through the Python API using ModelWrapper.from_file(...), while ensemble inference uses EnsembleModelWrapper.from_file(...) (Ren et al., 2 Mar 2026).

Extensibility is explicit in the framework design. New representations can be added by registering new feature generators from SMILES. New models can be introduced by implementing the base ModelWrapper API and registering them in the model factory. New training strategies can be exposed by adding CLI flags and corresponding training-loop logic. This architecture makes PolyMon suitable not only for retrospective benchmarking but also for forward integration of custom polymer descriptors, specialized GNNs, or external simulators.

A plausible implication is that PolyMon’s value increases with the diversity of representations and baselines available in a laboratory or group. Because the framework standardizes evaluation across those alternatives, it can serve as an internal model-selection environment rather than only as a fixed benchmark package.

6. Position within polymer informatics and relation to PolyGraphPy

PolyMon occupies a distinct position in polymer informatics. Property-specific benchmarks and toolkits often fix one representation or one model family, whereas PolyMon systematically compares descriptors, language-model embeddings, and graph representations under a unified protocol. It also incorporates empirical estimators, graph architectures, KAN networks, multi-fidelity learning, $\psi^{(k)}$3-learning, active learning, and ensembles within the same workflow (Ren et al., 2 Mar 2026).

A related development is PolyGraphPy, an open-source Python framework that integrates atomistic simulations with machine learning for accurate property prediction and property-guided polymer design. PolyGraphPy automates DFTB+ calculations, constructs graph datasets for monomers, homopolymers, and alternating copolymers, trains Bayesian GNNs with stochastic graph representations, and couples them to a SELFIES-based GPT and a BRICS-based genetic algorithm for de novo design. Its authors describe it as essentially a prototype of what a “PolyMon” system for polymer modeling/monitoring could look like, because it unifies simulation, curation, predictive modeling with uncertainty quantification, and generative search in one Python framework (Duarte et al., 4 Jun 2026).

The comparison is technically informative. PolyMon emphasizes systematic evaluation across representations, models, and training strategies for five benchmark properties. PolyGraphPy emphasizes end-to-end automation from monomer SMILES to DFTB+ simulation, graph construction, Bayesian prediction, and property-guided generation, demonstrated on acrylates and static polarizability. This suggests complementary trajectories within polymer informatics: PolyMon as a benchmarking and experimentation ecosystem for polymer property prediction, and PolyGraphPy as a concrete seed for a broader simulation-to-design platform (Duarte et al., 4 Jun 2026).

PolyMon’s documented limitations include compute cost for some models, especially DMPNN; representation specificity, illustrated by underperforming 3D descriptors; a current benchmark scope centered on five properties; and an active learning implementation that currently uses uncertainty-based acquisition rather than more sophisticated multi-objective or diversity-aware criteria. These limitations do not alter the framework’s core role, but they delimit its current operating regime and indicate where subsequent extensions are most natural (Ren et al., 2 Mar 2026).