Graph-based transformer to predict the octanol–water partition coefficient

Abstract

Lipophilicity is a fundamental physicochemical property that significantly influences various aspects of drug behavior, such as solubility, permeability, metabolism, distribution, protein binding, and excretion. Consequently, accurate prediction of this property is critical for the successful discovery and development of new drug candidates. The classical metric for assessing lipophilicity is logP, defined as the partition coefficient between n-octanol and water at physiological pH 7.4. Recently, graph-based deep learning methods have gained considerable attention and demonstrated strong performance across diverse drug discovery tasks, from molecular property prediction to virtual screening. These models learn informative representations directly from molecular graphs in an end-to-end manner, without the need for handcrafted descriptors. In this work, we propose a logP prediction approach based on a fine-tuned pre-trained GraphormerMapper model, named GraphormerLogP. To evaluate its performance, the model was tested on two datasets: one is compiled by us from publicly available sources and contains 42 006 unique SMILES-logP pairs (named GLP); the second consists of 13 688 molecules and is used for benchmarking purposes. Our comparative analysis against state-of-the-art models (Random Forest, Chemprop, CheMeleon, StructGNN, and Attentive FP) demonstrates that GraphormerLogP consistently achieves competitive or superior predictive accuracy across both datasets, attaining mean absolute error values of 0.251 and 0.269, respectively. The GLP dataset is available in the GitHub repository https://github.com/cimm-kzn/GraphormerLogP/tree/main/data.

Scientific contribution

This paper presents two key scientific contributions. First, we have collected and carefully curated a large and diverse dataset of molecules with measured logP values, comprising over 42 000 compounds. Second, we propose a Graphormer-based model with a task-specific fine-tuning architecture for logP prediction, tailored to leverage representations learned from reaction data. This model demonstrates high performance in benchmark studies on both established literature data and the newly compiled dataset.

Supplementary Information

The online version contains supplementary material available at 10.1186/s13321-026-01160-2.

Introduction

Molecular property prediction is one of the fundamental applications in chemoinformatics. The physicochemical properties of chemical compounds play a crucial role in various fields, especially in pharmaceuticals [1, 2]. Among these properties, lipophilicity (quantified by the octanol–water partition coefficient, logP, Eq. 1) is considered a key indicator of the hydrophobic character of molecules [3]. It is commonly used to estimate the uptake and bioaccumulation of chemicals and drugs in organisms [4].

$$\text{logP}=\text{log}\left(\frac{{[S]}_{\mathit{octanol}}}{{[S]}_{\mathit{water}}}\right),$$ 1

where [S] denotes the concentration of the unionized (neutral) form of the compound [5].

Experimental methods for determining logP values can generally be divided into two categories: direct and indirect approaches. Direct methods, such as the shake-flask [6], slow-stirring [7], and generator column techniques [8] calculate logP based on the measured concentration ratio of the compound between octanol and water phases. In contrast, indirect methods estimate logP by measuring related properties, such as capacity factors or solute retention times [9]. Among these, the shake-flask and slow-stirring methods are generally considered as the gold standard for experimental logP determination [10]. However, the accuracy of these measurements can vary, with reported experimental uncertainties ranging from less than 0.2 to approximately 0.4 logP units, depending on the specific experimental setup [11–13]. Despite their reliability, experimental procedures for determining logP are labor-intensive and may yield unreliable results for compounds that are poorly soluble, strongly hydrophilic, or highly lipophilic [7, 10].

Several in silico strategies have been devised to estimate logP due to the complicated experimental determination process. These strategies rely on the Quantitative Structure–Property Relationship (QSPR) [15–34]. The QSPR models aim to learn a mapping between molecular structure and experimental logP values by fitting model parameters to a dataset of compounds with experimentally measured property. To enable the development of such models, a wide range of datasets containing logP values has been introduced. These datasets can be broadly divided into three categories. Experimental datasets derived from direct measurements (e.g. OpenChem [14], Dataset_and_Predictions [13] and so on) provide highly reliable values but are limited in size, chemical diversity, and accessibility. Theoretical or computed datasets generated through predictive models or quantum-chemical methods (e.g. XLogP [15], ALogP [16]) cover broader chemical spaces but may contain systematic biases. Finally, many pharmaceutical companies maintain large in-house datasets (e.g. Novartis logP [17], Bayer AG LOD (logD7.5) [18]), which are often the most extensive and high-quality resources, but they remain inaccessible to the academic community.

To enable the use of QSPR models a variety of molecular representations have been proposed, such as SMILES strings, molecular fingerprints, and predefined descriptors. For example, Prasad and Brooks [19], and Wu et al. [20] employed fingerprints and molecular descriptors to encode molecular structure information. In contrast, Wang et al. [21] used a deep learning framework based on Tree-LSTM networks in combination with canonical molecular signatures, allowing the model to automatically learn relevant structural features without relying on engineering of descriptors. String-based molecular representations provide a less direct correspondence to the underlying molecular structures. Different 2-dimensional descriptors, such as Extended Connectivity Fingerprints, may fail to capture deeper interactions and the spatial arrangement of atoms and bonds [22].

Alternatively, chemical structures can be represented as graphs, where atoms are treated as nodes and chemical bonds as edges. This representation provides a seemingly more realistic depiction of molecules [23]. Recently, graph-based deep learning methods have attracted considerable attention and demonstrated substantial effectiveness in drug discovery, encompassing tasks ranging from molecular property prediction [24] to virtual screening [25]. These approaches are capable of learning informative molecular representations directly from chemical graphs in an end-to-end manner [26, 27].

Previous studies on lipophilicity prediction have highlighted the advantages of graph-based representation learning, particularly through the use of graph neural network (GNN) architectures [28–32]. One notable example is the Message Passing Neural Network (MPNN) introduced by Gilmer et al. [33] which achieved predictive accuracy for logP estimation that was comparable to that of quantum chemical methods. Among the practical implementations of MPNN, Chemprop demonstrated superior performance over classical machine learning models such as Random Forest, Lasso, XGBoost, attaining mean absolute errors (MAE) of 0.44 and 0.34 log units for Bemis-Murcko scaffold splits of public and in-house datasets, respectively [17]. Yang et al. [21] extended the MPNN architecture to include directed edge information (D-MPNN) and evaluated various molecular descriptors calculated with CDK, PaDEL, RDKit, and Chemopy. Among these combinations, the D-MPNN combined with CDK-based descriptors exhibited the best performance, achieving an RMSE of 0.32, an MAE of 0.22, and an R² of 0.97. Lukashina et al. [34] introduced a substructure encoder representing functional groups as hyperatoms to provide complementary information to the D-MPNN architecture. The proposed StructGNN model outperformed D-MPNN in predicting logP and logD values, attaining an R² of 0.94 and an RMSE of 0.45 on their public dataset [34]. An alternative development in GNN architectures involves the integration of attention mechanisms within recurrent neural networks with message passing (Attentive FP [31], ALipSol [35]).

While GNNs are effective in capturing local chemical environments, their reliance on limited-radius message passing inherently constrains their ability to model long-range dependencies. Recently, graph-based transformer architectures with attention mechanisms have demonstrated state-of-the-art performance in various molecular modelling tasks, including reaction prediction, atom–atom mapping [36], and property prediction. One such architecture is Graphormer, introduced by Microsoft [37] which is specifically designed for processing graph-structured data. This model has exhibited outstanding performance in predicting molecular quantum properties by adapting the BERT architecture [38]. Graphormer incorporates several novel features, the most notable of which is centrality encoding. This technique captures the relative importance of nodes within the graph by integrating graph degree centrality combined with atom type, each encoded as embedding vectors. Additionally, Graphormer employs a spatial encoding strategy that represents the shortest paths between pairs of nodes, which are used as learnable biases within the attention matrix. The Graphormer framework has been successfully applied to a wide range of tasks [36, 39, 40]. For example, pre-trained Graphormer models leveraging quantum-level atom-wise descriptors have been shown to improve performance on downstream property prediction tasks, such as ADMET modeling in the TDC dataset [39]. In another study [36], the authors showcased the utility of Graphormer for atom-to-atom mapping in chemical reactions (GraphormerMapper), which currently achieves the highest accuracy among mapping methods evaluated on the golden dataset. Thus, unlike classical GNNs, transformers can learn both local and global dependencies by allowing each atom to incorporate information from all other atoms simultaneously, thereby enabling more informative representations.

Despite their potential, graph-based transformer models have rarely been explored for logP prediction. Motivated by recent advances in transformer architectures for chemistry [36, 39, 40], we propose a logP prediction approach based on a fine-tuned, pre-trained GraphormerMapper model, referred to as GraphormerLogP. The model was evaluated on two datasets. The first dataset (hereafter referred to as SGNN) consists of 13 688 molecules reported in [34] and used in this study as a benchmark. To enable broader evaluation and improve generalizability, we additionally compiled a large dataset of octanol–water partition coefficients from publicly available sources, comprising logP values for 42 006 unique molecules (hereafter referred to as GLP). To assess the relative performance, GraphormerLogP was compared against several state-of-the-art logP prediction approaches, including Random Forest [41], Chemprop [42, 43], CheMeleon [44], StructGNN [34], and Attentive FP [31] across both datasets.

Materials and methods

Datasets

Benchmark SGNN dataset

The SGNN dataset (from the data reported in [34]) integrates several widely used sources, including PhysProp [45], the NCI Open Database Compounds [46], OChem [47], and DiverseDataset [48] and comprises 13 688 molecules. It is employed here as a benchmark dataset, as the StructGNN model [34], which demonstrated high predictive performances for logP, was trained and evaluated on this data. To ensure the fairest possible comparison, no additional preprocessing was applied to the molecular structures in this dataset.

Acquisition and curation of GLP dataset

The GLP dataset was compiled by combining data from databases and literature repositories, resulting in a collection of 80 333 molecules with experimental logP values, as outlined in Table 1 [13, 14, 49–54]. It should be noted that, in this study, logP = logD_7.4 for the unionized species was also assumed.

Table 1.

References used to compile the GLP dataset

Source	Number of data points	References
SAMPL6	11	[50]
SAMPL7	22	[50]
NonStar	42	[51]
Star	223	[51]
Huuskonen	373	[53, 54]
DB4	1 482	[52]
DB3	2 379	[52]
DB2	3 482	[52]
AstraZeneca	4 200	[49]
Dataset_and_Predictions	12 709	[13]
OpenChem	14 001	[14]
DB1	41 409	[52]

Compound structures in the GLP dataset were standardized according to the protocol described in [55]. Workflow for GLP dataset curation is shown in Fig. 1. The Chython library (version 1.75) was used for functional group normalization, removal of explicitly specified hydrogen atoms, aromatization and creation of canonical SMILES [36].

Fig. 1.

Workflow for GLP dataset acquisition and curation. The numbers shown at each step correspond to the number of unique compounds remaining after the respective filtering stage

After this step, 6 inorganic molecules were removed, together with 262 datapoints that contained multiple molecules (Fig. 1). Next, we applied an upper molecular weight limit of 850 g/mol to filter out oligomers and non–drug-like compounds and a lower limit of 80 g/mol to exclude small volatile molecules such as gases. Additionally, the logP range was restricted between − 10 and 10 to remove compounds with extreme values. In the present work, we intentionally adopted a broader range of logP in order to retain a more general chemical space and ensure applicability to highly lipophilic and highly hydrophilic chemical classes. To resolve inconsistencies in logP annotations originating from multiple sources, we identified 2955 datapoints corresponding to 1363 unique molecules with more than one reported logP value (Fig. 2). For molecules with multiple reported values, entries were removed from the GLP dataset if the difference between reported logP values exceeded 0.5 log units. In cases where the discrepancy was within 0.5 log units, the reported logP values were averaged and retained in the dataset. Then, the RDKit [56] library was employed to eliminate radicals, salts, and stereochemical information, which are not considered during modelling; subsequently, duplicate molecules were identified and removed. It should be noted that SGNN is a subset of the GLP dataset (8 639 molecules intersect). Importantly, if any molecules from the SGNN test set were present in the GLP dataset, they were removed. After curation of the dataset, 42 006 unique compounds were retained (Fig. 1).

Fig. 2.

Examples of molecules with more than one reported logP value collected from different sources

Computational procedure

GraphormerLogP neural network architecture

Model architecture. The architecture of the GraphormerLogP model consists of two primary components: a pre-trained GraphormerMapper-based encoder [37] that transformed molecular structures into latent representations, and a multilayer feedforward neural network for property prediction (Fig. 3). The input for the encoder is the structure of a compound provided as a SMILES string, which is converted into a molecular graph using the Chython library [39]. The initial weights of the encoder were taken from the original publication [37]. We utilize a pre-trained encoder with these weights and fine-tune it on the studied datasets. After passing through the GraphormerMapper, the resulting vector is fed into a multilayer feedforward neural network comprising an input layer with 1024 neurons and LeakyReLU activation, two hidden layers with 2048 and 256 neurons, respectively, and an output layer (Fig. 3). The second hidden layer employs a GELU activation function. To improve generalization and mitigate overfitting, dropout with a rate of 0.2 is applied after each layer. The weights of the feedforward network are initialized using Kaiming He initialization. The model predicts two values: the estimated logP value and the uncertainty of the prediction.

Fig. 3.

GraphormerLogP neural network architecture

Loss function. We employed a composite loss function that allows the model to jointly predict the target property and its uncertainty. The total loss is defined as:

$$L\left(y^{exp},y^{\mathit{pred}},{\sigma }^2\right)=\left(1-\lambda \right){\left(y^{exp}-y^{\mathit{pred}}\right)}^2+\lambda \left[{\left(y^{exp}-y^{\mathit{pred}}\right)}^2\left./\phantom{{\left(y^{exp}-y^{\mathit{pred}}\right)}^2{\sigma }^2}\right){\sigma }^2+log\left({\sigma }^2\right)\right],$$ 2

where $y^{\mathit{exp}}$ and $y^{\mathit{pred}}$ are experimental and predicted values of logP, respectively; σ² is the predicted variance (uncertainty); λ ∈ [0, 1] is a hyperparameter, when λ = 0, the loss function reduces to standard Mean Squared Error, while λ = 1 uses full probabilistic modeling. Intermediate values of λ allow for smooth interpolation between these regimes. Following common practice in uncertainty-aware regression models [57–59], we set λ = 1, which corresponds to the full negative log-likelihood loss under the assumption of Gaussian-distributed residuals.

While the loss formulation assumes Gaussian-distributed residuals, we do not claim that experimental logP errors strictly follow a normal distribution. As discussed above, experimental logP measurements may contain systematic biases arising from differences in experimental protocols, compound ionization states, and the aggregation of data from heterogeneous sources. In this context, the Gaussian assumption should be interpreted as a practical modeling approximation rather than a precise description of the true underlying error distribution.

Implementation details. The models are implemented using PyTorch Lightning (version 2.2.1) [60] and Chytorch (version 1.62) [37]. The Adam optimizer [61] as employed for training, with the Huber loss function. GraphormerLogP as trained using an early stopping strategy to reduce the likelihood of overfitting. The number of training epochs ranges from 50 to 500, with learning rate of 0.0004. A batch size of 128 is used for all experiments. Training was completed after 174–284 and 209–304 epochs for the GLP and SGNN datasets, respectively. All experiments were performed on an NVIDIA RTX 2080 Ti GPU.

Other models

To benchmark the performance of the GraphormerLogP model, a comparative analysis was conducted against several existing approaches for logP prediction. These models include both classical machine learning techniques and state-of-the-art deep learning frameworks: Random Forest, Chemprop [42, 43], StructGNN [34], CheMeleon [44], and Attentive FP [31].

Random Forest. We included scikit-learn's Random Forest regression model (denoted as RF) [41] as a baseline in our experiments. Each forest consisted of 500 trees. For the hyperparameter controlling the number of features considered at each split (the max_features option), the value was set to log₂(D), where D denotes the total number of descriptors. This configuration was found to be reasonable in our initial tests and previous studies [62–65]. All other parameters were kept at their default values. For molecular representation, we evaluated linear molecular fingerprints and Morgan molecular fingerprints generated with the Chython package [37], as well as physicochemical descriptors computed using the RDKit package [56]. We optimized parameters such as the minimum and maximum fingerprint radius, fingerprint length, number of active bits, and bit pairs in a cross-validation procedure. Hyperparameters were tuned using five-fold cross-validation on the training set, selecting the configuration that minimized the RMSE validation error across folds. The best-performing model in our experiments was trained using physicochemical descriptors.

Chemprop. Chemprop consists of four modules: (1) a local feature encoding function, (2) a directed message passing neural network to learn atomic embeddings from the local features, (3) an aggregation function to combine atomic embeddings into molecular embeddings, and (4) a standard feedforward neural network to transform the molecular embeddings into target property predictions [66]. Chemprop models were trained using the package’s default featurization, which includes atom-level features (e.g., atomic number, degree, and formal charge) and bond-level features (e.g., bond type and ring membership) [42, 43] The source code of Chemprop model (version 1.6.1) is available at https://github.com/chemprop/chemprop.

CheMeleon. CheMeleon is a descriptor-based foundation model built upon the directed message passing neural network (D-MPNN) architecture and pre-trained to predict deterministic molecular descriptors computed by the Mordred framework [44]. The model is trained on a large-scale corpus of approximately one million molecules from PubChem, where the target descriptors are derived directly from molecular graphs using counting, aggregation, and complexity-based algorithms, occasionally incorporating external physicochemical information. By learning to reproduce these low-noise and chemically informative descriptors, CheMeleon acquires a general-purpose molecular representation that can be fine-tuned for downstream molecular property prediction tasks, providing a strong pre-trained baseline for comparison with other representation learning approaches. The source code of CheMeleon model is available at https://github.com/JacksonBurns/CheMeleon.

StructGNN. StructGNN is an extension of D-MPNN with a substructure encoder that combines two parallel encoders to create a molecular embedding. The first encoder is a D-MPNN module that generates a molecular vector (h_d) by passing edge-focused messages across the molecular graph. The second encoder extracts generalized features of functional groups and substructures, representing them as a set of hyper-atoms, and encodes each with a feature vector. These vectors are passed through a one-layer feed-forward network and averaged to produce an embedding (h_s). The final molecular embedding is obtained by concatenating h_d and h_s and is fed into a regression neural network to predict logP and logD values simultaneously. The model is trained using RMSE loss [34]. The source code of StructGNN model is available at https://github.com/jbr-ai-labs/lipophilicity-prediction.

Attentive FP. Attentive FP consists of four components: (1) generation of the initial state vectors (embeddings) for each atom and its neighbors, where atom and bond features are computed using RDKit; (2) an atom-level message passing network composed of stacked attention-based layers, where each atom updates its embedding by selectively aggregating information («messages») from its neighbors using an attention mechanism; (3) a molecule-level embedding stage, where all atom embeddings are aggregated via a virtual supernode that connects to every atom and applies the same attention-based mechanism to capture global molecular context; and (4) a feedforward neural network that transforms the final molecular embedding into task-specific predictions, such as regression or classification outputs. To unify vector dimensions between atom and neighbor features, linear transformations with nonlinear activations are applied. The source code of Attentive FP model is available at https://github.com/OpenDrugAI/AttentiveFP.

Training, validation, and test splits of the SGNN and GLP datasets

In the case of SGNN, we relied on the predefined data partition provided by the original authors [34]. The dataset was already separated into training (70%), validation (15%), and test (15%) subsets, and we directly adopted these splits for our experiments. The corresponding files are publicly available at https://github.com/jbr-ai-labs/lipophilicity-prediction/tree/main/data/3_final_data.

The GLP data were randomly split into training (70%), validation (15%), and test (15%) sets. The GLP test set consisted of 6 301 compounds (some molecules are shown in the Fig. 4). The source of these sets is available at https://github.com/cimm-kzn/GraphormerLogP/tree/main/data.

Fig. 4.

Examples of molecules in the test set

Evaluation metrics

As performance metrics, determination coefficient (R²), mean absolute error (MAE) and root mean squared error (RMSE) on test set were used.

$$R^2=1-\frac{{\sum }_{i=1}^N{\left(y_i^{\mathit{pred}}-y_i^{\mathit{exp}}\right)}^2}{{\sum }_{i=1}^N{\left(y_i^{\mathit{exp}}-{\overline{y}}^{\mathit{exp}}\right)}^2}$$ 3

$$MAE=\frac{\left|y_i^{\mathit{exp}}-y_i^{\mathit{pred}}\right|}{N}$$ 4

$$RMSE=\sqrt{\frac{{\sum }_{i=1}^N{\left(y_i^{\mathit{pred}}-y_i^{\mathit{exp}}\right)}^2}{N}}$$ 5

where ${\overline{y}}^{\mathit{exp}}$ is the mean experimental value logP of the entire dataset, and N is the number of data points. To evaluate model performance, each model was trained five times with random weight initialization.

Statistical significance of performance differences between models was assessed using the Tukey Honestly Significant Difference (HSD) test, applied separately for each metric across five independent runs.

Results and discussion

Lipophilicity datasets (GLP and SGNN)

By integrating 12 publicly accessible datasets, we compiled the GLP dataset containing 42 006 unique molecules. The GLP and SGNN datasets itself are heterogeneous and include numerous classes of chemical compounds (Fig. 5). The overall distributions of structural characteristics in GLP and SGNN are largely similar, with minor differences attributable to the broader integration of multiple datasets in GLP (Fig. 5A-D). Both datasets are dominated by aromatic compounds, though the SGNN dataset has a higher fraction (84.8% vs. 73.1%), whereas GLP contains more aliphatic molecules (26.9% vs. 15.2%) (Fig. 5B). The distributions of functional groups are comparable: H-bond acceptors occur in ~ 30% of molecules, H-bond donors in ~ 12%, and hydrophobic groups in ~ 39% across both datasets (Fig. 5C). Minor differences are observed for charged groups, with GLP showing slightly higher fractions. Regarding heteroatoms, oxygen- and nitrogen-containing compounds predominate in both datasets (O: 82.5–84.6%, N: 72.5–76.5%), while sulfur, phosphorus, and halogens occur at lower but similar frequencies (Fig. 5D). Together, these comparisons highlight that although GLP is more diverse and larger in scale, its chemical space broadly overlaps with SGNN, ensuring that performance benchmarks on SGNN remain informative when evaluating models trained on GLP.

Fig. 5.

Structural composition of the GLP (blue) and SGNN (green) datasets, characterized by: (A) the number of non-hydrogen atoms NHA, (B) substance classes (aliphatic vs. aromatic), (C) distribution of functional groups (a—aromatic, A—H-bond acceptor, D—H-bond donor, H—hydrophobic, P—positive, N—negative) (D) and heteroatoms (O—oxygen, N—nitrogen, S—sulfur, P—phosphorous, Hal—halogens)

The logP values in this dataset range from − 9.6 to 9.98 (Fig. 6A), while molecular weights span from 80.03 g/mol to 847.13 g/mol (Fig. 6B). Among the published GNN-based approaches, the StructGNN model [34] has demonstrated strong predictive performance for logP using a publicly available dataset of 13 688 molecules (SGNN), which we adopt as a reference point in our study. The mutual distribution of chemical spaces of datasets was analyzed using Uniform Manifold Approximation and Projection (UMAP) [67] plot (Fig. 6C) applied to Morgan fingerprints generated with the Chython package [37]. This analysis revealed significant overlap between the chemical spaces of the GLP and SGNN datasets, indicating that both datasets share a substantial portion of common structural motifs, making them suitable for comparative benchmarking. At the same time, GLP dataset exhibits distinct clusters, reflecting unique chemical series present in this dataset but absent in the SGNN. Overall, the GLP dataset extends the chemical diversity of SGNN while maintaining a comparable distribution, thereby supporting its use as a complementary benchmark for lipophilicity prediction.

Fig. 6.

Distribution of logP values (A) and molecular weights (B) for the GLP and SGNN datasets. (C) UMAP plot of chemical spaces covered by the GLP and SGNN datasets

GraphormerLogP model

Hold-out test sets performance for both datasets is shown in Tables 2–3. For the models trained on the SGNN dataset (Table 2), Random Forest [41], Chemprop [42, 43], CheMeleon [44], StructGNN [34], and Attentive FP [31] were evaluated for comparison. Statistical significance of performance differences between models was assessed using the Tukey Honestly Significant Difference (HSD) test applied separately to each metric across five independent runs (see Supporting Materials, Table S1-S3). Among these models, StructGNN achieved the strongest overall performance, with R² = 0.941, MAE = 0.292, and RMSE = 0.456. This is to be expected as StructGNN takes advantage of both multitask learning and domain knowledge integration. Chemprop and Attentive FP were inferior to StructGNN. The RF model showed the worst performance, likely due to limited molecular descriptors. The pre-trained CheMeleon model demonstrated competitive performance, outperforming Chemprop and Attentive FP in terms of R² and RMSE; however, differences between CheMeleon and Chemprop were not statistically significant for these metrics (see Supporting Materials, Table S1-S2). Our proposed GraphormerLogP model achieved the best average performance across all three metrics (R² = 0.945, MAE = 0.269, RMSE = 0.446). According to the Tukey HSD test applied across five independent runs, GraphormerLogP significantly outperformed Chemprop, Attentive FP, CheMeleon, and RF for all metrics, while no statistically significant difference was observed between GraphormerLogP and StructGNN on the SGNN dataset (see Supporting Materials, Table S1-S3).

Table 2.

Model performances on the SGNN dataset*

Model	R2	MAE	RMSE
RF	0.8150 ± 0.0006	0.5658 ± 0.0007	0.8088 ± 0.0012
Attentive FP	0.9363 ± 0.0032	0.2763 ± 0.0062	0.4756 ± 0.0151
Chemprop	0.9379 ± 0.0015	0.2862 ± 0.0032	0.4677 ± 0.0059
CheMeleon	0.9355 ± 0.0036	0.2947 ± 0.0078	0.4748 ± 0.0141
StructGNN	0.9446 ± 0.0010	0.2667 ± 0.0022	0.4418 ± 0.0038
GraphormerLogP	0.9450 ± 0.0010	0.2689 ± 0.0021	0.4461 ± 0.0042

^*Mean and standard deviation of the 5 independent runs are reported

Table 3.

Model performances on the GLP dataset*

Model	R2	MAE	RMSE
RF	0.8357 ± 0.0005	0.5613 ± 0.0014	0.8627 ± 0.0015
Attentive FP	0.9424 ± 0.0005	0.3196 ± 0.0036	0.5108 ± 0.0023
Chemprop	0.9392 ± 0.0008	0.3160 ± 0.0029	0.5238 ± 0.0038
CheMeleon	0.9428 ± 0.0008	0.2991 ± 0.0034	0.5068 ± 0.0035
StructGNN	0.9462 ± 0.0008	0.2954 ± 0.0019	0.4934 ± 0.0031
GraphormerLogP	0.9578 ± 0.0013	0.2514 ± 0.0052	0.4402 ± 0.0075

^*Mean and standard deviation of the 5 independent runs are reported

For the models trained on the GLP dataset, RF model continues to lag behind the others, achieving the lowest R² (0.834) and the highest error rates (MAE = 0.562, RMSE = 0.863). Attentive FP and StructGNN achieved comparable performance, with both models providing moderate improvements in MAE and RMSE compared to Chemprop. The pre-trained CheMeleon model demonstrated competitive performance on the GLP dataset. According to the Tukey HSD test, CheMeleon significantly outperformed Chemprop across all three metrics (see Supporting Materials, Table S4-S6). Compared to Attentive FP, CheMeleon achieved significantly lower MAE, while no statistically significant differences were observed in terms of R² and RMSE. In addition, CheMeleon showed no statistically significant difference from StructGNN in terms of MAE, although StructGNN remained superior in R² and RMSE. GraphormerLogP achieved the best performance across all three metrics, with an R² of 0.958, MAE of 0.244, and RMSE of 0.432 when to the experimental error in the range of 0.2–0.4 log units. Tukey HSD analysis confirmed that GraphormerLogP significantly outperformed all other models for each metric on the GLP dataset (see Supporting Materials, Table S4-S6).

In Fig. 7, to identify the deficiencies of our proposed GraphormerLogP model trained on the GLP dataset, we listed the compounds in test set with large prediction errors of logP. Inspection of the largest prediction errors revealed that most outliers fall into two main categories. First, the model tends to overestimate logP for molecules with bulky hydrophobic fragments (multiple aromatic rings, long alkyl chains) combined with strongly polar or ionizable groups such as quaternary ammonium cations, carboxylates, or multiple hydroxyl groups. In these cases, the presence of charged or highly polar moieties significantly reduces the experimental logP, but the model appears to underweight their contribution to hydrophilicity. Second, the model often underestimates logP for compact, highly lipophilic structures such as long-chain alkanes, lipophilic esters, and polycyclic aromatic hydrocarbons. For these compounds, the very large nonpolar surface area or intramolecular hydrogen bonding can lead to experimentally high logP values, which the model does not fully capture. A likely cause of these errors is the limited representation of such structural motifs in the training data, leading to poor generalization on rare chemotypes. Additionally, the model’s 2D graph-based representation may inadequately capture effects such as conformational shielding of polar groups, tautomeric or protonation states, and intramolecular hydrogen bonding.

Fig. 7.

Outliers (absolute error > 2) in the test set predicted by GraphormerLogP trained on the GLP dataset

We further evaluated the performance of the proposed GraphormerLogP model using the external benchmark dataset introduced by Martel et al. [48], which contains experimentally measured logP values for 707 compounds derived from the ZINC database. The GraphormerLogP model, trained on the GLP dataset and applied to this benchmark, achieved an RMSE of 1.33. For comparison, previously reported results on the same dataset include COSMO-RS (RMSE = 0.93), DNN_taut (RMSE = 1.23), JChem (RMSE = 1.23), ALOGPS (RMSE = 1.25), OCHEM (RMSE = 1.32), DNN_mono (RMSE = 1.35), KOWWIN (RMSE = 1.38), ACD/GALAS (RMSE = 1.44), and DataWarrior (RMSE = 1.61) as summarized in the study of Ulrich N. et al. [13]. Thus, the predictive accuracy of GraphormerLogP on the Martel et al. dataset [48] is comparable to that of several existing data-driven approaches reported in the literature.

The results demonstrate the benefit of transfer learning from reaction data in the context of lipophilicity prediction. On the SGNN dataset, initializing the GraphormerLogP model with the pre-trained GraphormerMapper encoder resulted in a substantial performance improvement compared to training from scratch, reducing RMSE from 0.534 to 0.449 and increasing R² from 0.919 to 0.943. A similar trend was observed on the larger GLP dataset, where RMSE decreased from 0.551 to 0.430 and R² increased from 0.932 to 0.960. We hypothesize that the observed performance gains are due to the transfer of chemically relevant representations learned from reaction prediction tasks. Reaction datasets provide diverse examples of functional groups and substitution patterns, enabling the encoder to capture subtle steric and electronic effects. These effects are also critical determinants of lipophilicity. By initializing the GraphormerLogP model with a reaction-pretrained encoder, the model benefits from a chemically informed feature space, leading to improved generalization, especially for rare chemotypes and molecules with complex substituent patterns.

Conclusions

In this work, we address the challenge of reliable lipophilicity prediction by combining systematic data curation with recent advances in graph-based transformer architectures. We compile and release the GLP dataset, a large-scale and openly accessible collection of 42 006 experimentally reported logP values, which is available in the GitHub repository https://github.com/cimm-kzn/GraphormerLogP/tree/main/data.

We also introduce GraphormerLogP, a transformer-based model fine-tuned from the pre-trained GraphormerMapper encoder. Across both datasets, test set errors decrease in the order Random Forest > Chemprop ≈ Attentive FP > StructGNN > GraphormerLogP. Test set errors are consistently lower for models trained and evaluated on the GLP dataset than on the SGNN dataset, which reflects differences in training set size (29 404 vs 9 581), chemical diversity, and test set sizes (6 301 vs 2 053).

The benefits of pretraining on reaction data are evident in the superior performance of GraphormerLogP compared to training the same architecture from scratch, highlighting the value of transfer learning in molecular property prediction.

Abbreviations

LogP

Lipophilicity

QSPR

Quantitative Structure–Property Relationship

GNN

Graph neural networks

MPNN

Message passing neural networks

D-MPNN

Directed edges message passing neural networks

Attentive FP

Attentive Fingerprint model based on attention-guided message passing

StructGNN

D-MPNN with a substructure encoder

RF

Random forest

SGNN

Dataset of logP reported in the publication [34]

GLP

Dataset of logP compiled by us from publicly available sources

GraphormerLogP

Our model

UMAP

Uniform Manifold Approximation and Projection

Author contributions

Conceptualization, TG and PS; methodology, TG; software, TG and VG; validation, VG and AP; investigation, VG and AP; data curation, VG; writing-original draft preparation, AP and VG; writing-review and editing, TG, PS and NS; visualization AP and VG; project supervision, TG, funding acquisition, AP, TG and NS. All authors have read and agreed to the published version of the manuscript.

Funding

The work of Gimadiev T., Serov N. and Poyezzhayeva A. was funded by financial support from the government assignment for FRC Kazan Scientific Center of RAS. P.S. thanks the financial support of the Institute for Chemical Reaction Design and Discovery (ICReDD), which was established by the World Premier International Research Initiative (WPI), MEXT, Japan, List Sustainable Digital Transformation Catalyst Collaboration Research Platform offered by Hokkaido University, and JSPS KAKENHI grant 23H03807.

Data availability

The dataset used for the generation of the GraphormerLogP model are available at.https://github.com/cimm-kzn/GraphormerLogP/tree/main/dataP

Code availability

The full code for the GraphormerLogP development is given at the GIT repository https://github.com/cimm-kzn/GraphormerLogP.

Declarations

Competing interest

None