Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,12 @@
+**/.DS_store
+**/*~
+**/.ipynb_checkpoints
+**/__pycache__/
+*.raysync.downloading
+conf/legacy/
+*.csv
+*.ipynb
+backup
+env
+gitcommands.sh
+run_ephod.sh

.ms_upload_cache

@@ -0,0 +1 @@
+{"version": 3, "repo_id": "OneScience/EpHod", "files": {"LICENSE|1745926779.0|1113": {"hash": "7088340822ab1d59337486f42582157f21e9c01d631a72378ef2b0f5df35bf47", "size": 1113, "status": "c"}, ".gitignore|1788505890.0|145": {"hash": "2e08a2109129a673065d4e6c278c1799f3eda4e5b4fb4a46a6313866ea96ddbc", "size": 145, "status": "c"}, "README.md|1788509463.0|5489": {"hash": "f21262ef5644f23873bfee8a48c488fc3424a713ecd678fef2e88bb239a2afb2", "size": 5489, "status": "c"}, "conf/README_upstream.rst|1745926779.0|2192": {"hash": "8f20109be8d078549478fc9d78391bf1c5688b283ba9c71d6de9c3393cfb3d8e", "size": 2192, "status": "c"}, "conf/data/smoke.fasta|1785314913.0|478": {"hash": "3f51b4e6e0539b9c2cf12187079347eeab7b6b576d8e540748bc38b788707149", "size": 478, "status": "c"}, "conf/environment.yml|1788505779.0|319": {"hash": "7905dabc117ac4470028ac081032ba1d80a1220d5d60cb0d0184867168013ca6", "size": 319, "status": "c"}, "conf/config.json|1788509352.0|401": {"hash": "f7f882853f9894dc50b8ff6d28b271d1e33476039ba4aa1783268ed65465e556", "size": 401, "status": "c"}, "conf/environment_upstream.yml|1745926779.0|377": {"hash": "7f96c08d7f0847c56eb304c995d8039352ce2dc551821dc217b6fc090cb37b9f", "size": 377, "status": "c"}, "conf/legacy/P2PXML_dataset/.DS_Store|1718042675.0|10244": {"hash": "6ef986c0eb217beff0ddde6a2d0e5d8e6e7d2b551fdb0bbadf3057a90e2d97da", "size": 10244, "status": "c"}, "conf/data/test_sequences.fasta|1745926779.0|952751": {"hash": "ce370ce7e28bb980c54d95b0e047353161b14d372ec56ad66c66ad20d8e0b6db", "size": 952751, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML-Seq/README.md|1718042430.0|7641": {"hash": "2ffeab6133e1b7ae185376e46a0325f4a50b9663a3429faf2943655f20edc7fa", "size": 7641, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/.DS_Store|1718042683.0|14340": {"hash": "4bcefc3ae092c4bc279d20dddcd25275ded26e64b93c1ac23502a6b924c54f2a", "size": 14340, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/README.md|1718042468.0|5144": {"hash": "8867f3ce2f69d9ea1c937db9dc20bbb6a943a57e1891fe6d2b0488d41c8b92d1", "size": 5144, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/P2PXML_structure.csv|1715691738.0|307194": {"hash": "cb0d5c4da7506cebaaecdd2893c22ceed4b073d37c5aaabddab6ca97530d9ee4", "size": 307194, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antibodies_0.5γ.pt|1785382868.0|806844": {"hash": "93ef94df9521ab9fbf988d5c47007e46297325a02c78e24c99fc990d4d610a9d", "size": 806844, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_AC10_29.pt.raysync.downloading|1788504346.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_AC10_29.pt|1785383395.0|65536": {"hash": "c389b1f225c783bb7e3dc99fc0ca2612709fff29c348228a5a2536b92a509296", "size": 65536, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antibodies_10-1074.pt|1785382861.0|1587531": {"hash": "d4f91d4681b79ec48f23f7888e6cb15a59db7ff68da879355ae3b0dee7295b50", "size": 1587531, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_0815_V3_C3.pt|1785382984.0|2013784": {"hash": "970fe055e85973b871814101bf5e136f0ebed848816ad9c7a3a7e202da4203b0", "size": 2013784, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_0013095_2_11.pt|1785383207.0|2016242": {"hash": "ac2432509e5dec3f719fcbe459845a99cd148f97ff2be0007cc986f6e9aa7a60", "size": 2016242, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_6535_3.pt|1785383057.0|2020324": {"hash": "8686544b6804f247e5333438b947f627a2c44e20b0915f4c7353ac4e8ced528f", "size": 2020324, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_JRFL.pt|1785383245.0|2009226": {"hash": "b765659c9a03c6fe870a233ad754a08633bb0366011271c605d0c209fef4c188", "size": 2009226, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML-Seq/P2PXML_seq_dataset.csv|1715518479.0|48192766": {"hash": "30f560849e7ce3de50c00f3e2e8db9b62062415099286ba7a18119062644be36", "size": 48192766, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_PVO_4.pt|1785383020.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_PVO_4.pt.raysync.downloading|1788504346.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_QH0692_42.pt|1785382905.0|2013515": {"hash": "f270e2661f8e79b1e9355cbc253271adbbc2ad7f8801412ec04250fd7e9307d1", "size": 2013515, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_REJO4541_67.pt|1785383356.0|1638400": {"hash": "d2485678396d8d4312c4afbf415548fd238cdedd952778ea4623f8c81c9aa06b", "size": 1638400, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_REJO4541_67.pt.raysync.downloading|1788504346.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_RHPA4259_7.pt|1785382948.0|2016280": {"hash": "67ef316708b16aa7638b78839110234f3d2806b19a831fff61bd61a3b5e2a578", "size": 2016280, "status": "c"}, "conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_WITO4160_33.pt|1785383170.0|2018213": {"hash": "3f9e20fbe89397f45a86378d92a48edd995e342a2abe99ff94c8234c39f6ec4d", "size": 2018213, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/._.DS_Store|1718042675.0|120": {"hash": "2f380f4a3d05a8d90c2106f50da75064e9ce57a598599dc5404f8f69a0223aa9", "size": 120, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/._P2PXML_Structure|1718042684.0|220": {"hash": "a29f0c4c35897cd46dffd9fa873543b1703137fd5156e5857a7c991581e9f073", "size": 220, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/P2PXML-Seq/._P2PXML_seq_dataset.csv|1715518479.0|332": {"hash": "0198d50e52c224afb5e1d07e9ab6a29c0373102434e3457e717f57919eb6e904", "size": 332, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/P2PXML-Seq/._README.md|1718042430.0|476": {"hash": "aa78b13f28a4a239a8ca75ead6026d6c54144cf571577e3f7b3fb76dd7e33978", "size": 476, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/P2PXML_Structure/._.DS_Store|1718042683.0|120": {"hash": "2f380f4a3d05a8d90c2106f50da75064e9ce57a598599dc5404f8f69a0223aa9", "size": 120, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/P2PXML_Structure/._P2PXML_structure.csv|1715691738.0|332": {"hash": "77635c3e6c6e066eb3feca5e03cd62b1b56f263f017ef1dc41ac27c530ac4d7a", "size": 332, "status": "c"}, "conf/legacy/__MACOSX/P2PXML_dataset/P2PXML_Structure/._README.md|1718042468.0|476": {"hash": "b503f826be7493b5b062a03b046218e41ce1586725f8b9df05f3984e86086af6", "size": 476, "status": "c"}, "conf/legacy/incomplete_transfers/ESM1v-SVR.pkl.raysync.downloading|1788504333.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/incomplete_transfers/checkpoint_markers/ESM1v-RLATtr.pt.raysync.downloading|1788504333.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/incomplete_transfers/checkpoint_markers/esm1v_t33_650M_UR90S_1.pt.raysync.downloading|1788504332.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/python_cache/ephod/__init__.cpython-310.pyc|1788505655.0|281": {"hash": "37fbf003861a9d145a91702d485fce4516db22084bcab88e146dc93bb32d31da", "size": 281, "status": "c"}, "conf/legacy/python_cache/ephod/__init__.cpython-311.pyc|1785314929.0|327": {"hash": "697fbf112d24aebb04eed7058a22839e88bbc119a1c2acb94a1728189e5ee3a1", "size": 327, "status": "c"}, "conf/legacy/python_cache/model/__init__.cpython-310.pyc|1788505655.0|173": {"hash": "5c0858ec07fac50f5fdfdd3504dba8f4c0d634e9f44435841114a431e7270500", "size": 173, "status": "c"}, "conf/legacy/python_cache/training/__init__.cpython-310.pyc|1788505655.0|149": {"hash": "7e97bde86f4bda71b6fa9599e3fc45a43a99b99961f2a68e362159829d89708b", "size": 149, "status": "c"}, "conf/legacy/python_cache/training/__init__.cpython-311.pyc|1785314929.0|179": {"hash": "efa2f7b9665a0fbca86e1898e394363e6e222c4d90391f169132329082771e3c", "size": 179, "status": "c"}, "conf/legacy/python_cache/training/nn_models.cpython-311.pyc|1785314929.0|30534": {"hash": "a19872f5876ba92a0c995f785cfb70ce2fb11e02972c4bd657ed5ad5a68f28bf", "size": 30534, "status": "c"}, "conf/legacy/torch_cache/hub/checkpoints/ESM1v-RLATtr.pt.raysync.downloading|1788504339.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "conf/legacy/torch_cache/hub/checkpoints/esm1v_t33_650M_UR90S_1.pt|1624653201.0|12058624": {"hash": "f3d7c4c868045cbea65b47debb9764d8f55dcaea63854a169c7442a5d084df2b", "size": 12058624, "status": "c"}, "conf/legacy/torch_cache/hub/checkpoints/ESM1v-RLATtr.pt|1785314088.0|19726336": {"hash": "5a8d2ce39e4d0e8c584172301cc1fd7942f919994266cb4875feeb3e165f6b89", "size": 19726336, "status": "c"}, "conf/legacy/incomplete_transfers/ESM1v-SVR.partial.pkl|1745926779.0|45678592": {"hash": "6a6022211516ca9375e3266fbee9f6639e16bb4c0f8d3977f1f8fcb219bfefdd", "size": 45678592, "status": "c"}, "conf/legacy/torch_cache/hub/checkpoints/esm1v_t33_650M_UR90S_1.pt.raysync.downloading|1788504339.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "configuration.json|1788505517.0|424": {"hash": "86c89c44bfbc9cf0f437c66648625c1af3cf7ccfbb34a57e0d12328572cb7a42", "size": 424, "status": "c"}, "model/__init__.py|1788505512.0|34": {"hash": "e4ceae57dace284d2b2513bdb2494eef6f3b0a381d7cc81ec4456df999526623", "size": 34, "status": "c"}, "model/__pycache__/__init__.cpython-311.pyc|1788508905.0|202": {"hash": "bc03c11bb12db0bab0d8601d1c11868beeb41fc42188a8691a456d5cb5f5740e", "size": 202, "status": "c"}, "model/ephod/__init__.py|1745926779.0|124": {"hash": "40f97e8cfcc7db2837669605c964c0f0eb03621da2dfb26f5f7afae9e1b6acbf", "size": 124, "status": "c"}, "model/ephod/__pycache__/__init__.cpython-311.pyc|1788508905.0|324": {"hash": "5003481c57668c0717ebf6811676e9101154b833c7165cd2f78c771eceac93cd", "size": 324, "status": "c"}, "model/ephod/training/__init__.py|1745926779.0|0": {"hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "size": 0, "status": "c"}, "model/ephod/training/__pycache__/__init__.cpython-311.pyc|1788508905.0|176": {"hash": "e4eaa4a80e0221902c83f563bf6be756dac142281e775b30792986818d752f64", "size": 176, "status": "c"}, "model/ephod/training/__pycache__/nn_models.cpython-311.pyc|1788508905.0|30531": {"hash": "646013618ac14c439dc07951ee7f27d452a2553b6db6a6ef40f738fdff6f1846", "size": 30531, "status": "c"}, "model/ephod/training/nn_models.py|1745926779.0|22876": {"hash": "7301be27ea56a7bd46068223abb8569c9e20bb3b3a6b52acd01dee3ff757f427", "size": 22876, "status": "c"}, "model/ephod/training/trainutils.py|1745926779.0|6515": {"hash": "ea7f1ef9397f5bde90b374ddb2b0e30ac0fbb3c6417125db30a39bb4623d0cc5", "size": 6515, "status": "c"}, "requirements.txt|1788505519.0|915": {"hash": "40ef350e0c0ca26d67591e2841b4a181e319698dcb0fac104009995dcc01d568", "size": 915, "status": "c"}, "scripts/inference.py|1788509363.0|11853": {"hash": "2f55e15e9191fa97646a739c1ec1e17951bed77f5220bf0298594c828699e8cf", "size": 11853, "status": "c"}, "scripts/train_ml_models.py|1788505801.0|6687": {"hash": "561602f5daf2a371fe629a2a4191aaa5514f1a022a40a4e4cd1a1f9c3fd6c357", "size": 6687, "status": "c"}, "scripts/train_nnmodels.py|1788505507.0|17738": {"hash": "2bdfcce38c4f64bac61ba3c5d80dbf7a2a131956e91db04c398171ee00af51ad", "size": 17738, "status": "c"}, "weight/ESM1v-SVR.pkl|1788507694.0|62751459": {"hash": "629723a22b3691d8b177abb8d8c8c36d8e36b4a16d2bf7eec616ea2afef16bdb", "size": 62751459, "status": "c"}, "weight/ESM1v-RLATtr.pt|1788507542.0|196888312": {"hash": "dd46a328e0d3ccba1fb0515dbffbe014247a6752a21b30d6432f604bbb658b9c", "size": 196888312, "status": "c"}, "weight/smoke_training/rla_smoke_model.pt|1785380632.0|146564": {"hash": "c0654eca82f57b8ca06d99376724543b1ba83ce362292049b77f2ccd4b338778", "size": 146564, "status": "c"}, "weight/smoke_training/svr_smoke_model.pkl|1785380693.0|186051": {"hash": "a11e9a7e2156c4cbdbc157fa1d469ef495d7a483333f1dc5b5d6881fd2aa14cc", "size": 186051, "status": "c"}, "weight/esm1v_t33_650M_UR90S_1.pt|1788507559.0|7828635339": {"hash": "9519ee60f1cddad3c101afb1f42612499e188534969c3f682e94850870f70433", "size": 7828635339, "status": "c"}}}

LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2023, Japheth Gado, National Renewable Energy Laboratory.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,215 @@
+---
+frameworks:
+- PyTorch
+language:
+- en
+license: mit
+tags:
+- OneScience
+- bioscience
+- enzyme-optimum-pH-prediction
+- protein-language-model
+- EpHod
+tasks:
+- regression
+---
+
+<p align="center">
+  <strong>
+    <span style="font-size: 30px;">EpHod</span>
+  </strong>
+</p>
+
+# Model Introduction
+
+EpHod is an ensemble model for predicting the catalytic optimum pH (`pHopt`) of enzymes.
+
+The model first uses ESM-1v to encode amino acid sequences into protein representations and then combines predictions from a Residual Lightweight Attention network (RLATtr) and a Support Vector Regression model (SVR).
+
+Paper: [Machine learning prediction of enzyme optimum pH](https://doi.org/10.1038/s42256-025-01026-6)
+
+# Model Description
+
+The EpHod inference pipeline contains three main prediction components:
+
+- **ESM-1v:** Encodes enzyme sequences into 1280-dimensional residue-level protein representations;
+- **RLATtr:** Uses a residual lightweight attention network to predict `pHopt` and can optionally output residue-level attention weights and a 2560-dimensional EpHod protein representation;
+- **SVR:** Performs support vector regression using pooled and standardized ESM-1v representations;
+- **Ensemble:** Uses the average of the RLATtr and SVR predictions as the final `pHopt` prediction.
+
+The official RLATtr model was first pretrained on approximately 1.9 million proteins labeled with optimum environmental pH (`pHenv`) and was then fine-tuned on 9,855 enzymes labeled with catalytic optimum pH (`pHopt`).
+
+Input sequences longer than 1022 residues are truncated.
+
+To avoid pooling-related bias, the current inference entry point uses a fixed batch size of 1.
+
+# Use Cases
+
+| Use Case | Description |
+| --- | --- |
+| Enzyme optimum pH prediction | Predict catalytic optimum pH from an enzyme amino acid sequence. |
+| Enzyme candidate screening | Compare multiple candidate enzyme sequences based on predicted optimum pH. |
+| Attention analysis | Optionally save residue-level RLATtr attention weights. |
+| Protein representation extraction | Optionally save the final 2560-dimensional RLATtr protein representation. |
+
+# Usage
+
+## 1. OneCode
+
+You can use the OneCode online environment for an intelligent one-click AI4S programming experience:
+
+[Try OneCode for AI4S Programming](https://web-2069360198568017922-iaaj.ksai.scnet.cn:58043/home)
+
+## 2. Manual Installation
+
+### Hardware Requirements
+
+- Supports CPU and accelerator devices supported by PyTorch;
+- GPU or SCNet DCU is recommended for ESM-1v inference;
+- CPU execution is supported but is significantly slower;
+- ESM-1v contains approximately 650 million parameters;
+- Device memory usage depends on sequence length. If device memory is insufficient, reduce the input sequence length or process sequences individually.
+
+### Download the Model Package
+
+Install the Hugging Face command-line tool and download the model repository:
+
+```bash
+
+python -m pip install -U huggingface_hub
+
+hf download OneScience-Group/EpHod --local-dir ./EpHod
+cd EpHod
+```
+
+### Install the Runtime Environment
+
+**DCU Environment**
+
+```bash
+# Activate DTK and Conda first
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+
+python -m pip install "onescience[bio-dcu]" \
+  -i http://mirrors.onescience.ai:3141/pypi/simple/ \
+  --trusted-host mirrors.onescience.ai
+```
+**GPU Environment**
+
+```bash
+# Activate Conda first
+conda create -n onescience311 python=3.11 -y
+conda activate onescience311
+
+python -m pip install "onescience[bio-gpu]" \
+  -i http://mirrors.onescience.ai:3141/pypi/simple/ \
+  --trusted-host mirrors.onescience.ai
+```
+
+Install the additional dependencies required by EpHod:
+
+```bash
+python -m pip install --no-deps -r requirements.txt
+```
+
+### Weight Preparation
+
+Inference requires all three of the following assets:
+
+| Asset | Relative Path | Purpose |
+| --- | --- | --- |
+| ESM-1v 650M weights | `weight/esm1v_t33_650M_UR90S_1.pt` | Generate residue-level protein representations |
+| RLATtr weights | `weight/ESM1v-RLATtr.pt` | Neural-network prediction branch |
+| SVR model and normalization statistics | `weight/ESM1v-SVR.pkl` | Support Vector Regression prediction branch |
+
+Official sources:
+
+- [ESM-1v main checkpoint](https://dl.fbaipublicfiles.com/fair-esm/models/esm1v_t33_650M_UR90S_1.pt)
+- [EpHod RLATtr weights and training data](https://doi.org/10.5281/zenodo.14252615)
+- `ESM1v-SVR.pkl` is distributed with the official EpHod repository.
+
+### Quick Inference
+
+The following command uses a validated smoke-test sequence:
+
+```bash
+python scripts/inference.py \
+  --fasta_path conf/data/smoke.fasta \
+  --output_path output/smoke/prediction.csv \
+  --verbose 1 \
+  --save_attention_weights 0 \
+  --save_embeddings 0
+```
+
+A complete example using the provided test sequences:
+
+```bash
+python scripts/inference.py \
+  --fasta_path conf/data/test_sequences.fasta \
+  --output_path output/inference/prediction.csv \
+  --verbose 1 \
+  --save_attention_weights 0 \
+  --save_embeddings 0
+```
+
+The output CSV contains three prediction columns:
+
+```text
+RLATtr,SVR,Ensemble
+```
+
+Their meanings are:
+
+- `RLATtr`: optimum-pH prediction from the neural-network branch;
+- `SVR`: optimum-pH prediction from the support vector regression branch;
+- `Ensemble`: arithmetic mean of the RLATtr and SVR predictions and the recommended final EpHod prediction.
+
+The `--output_path` argument directly specifies the complete output CSV path and automatically creates its parent directory when required.
+
+The original `--save_dir` and `--csv_name` options remain available.
+
+If `--output_path` is not specified, the output path is generated from `--save_dir` and `--csv_name`.
+
+### Save Attention Weights and Protein Representations
+
+Set the corresponding options to `1`:
+
+```bash
+python scripts/inference.py \
+  --fasta_path conf/data/smoke.fasta \
+  --output_path output/features/prediction.csv \
+  --save_attention_weights 1 \
+  --save_embeddings 1
+```
+
+The output includes:
+
+```text
+output/features/
+├── attention_weights/
+├── embeddings.csv
+└── prediction.csv
+```
+
+`attention_weights/` stores residue-level RLATtr attention information.
+
+`embeddings.csv` stores the extracted EpHod protein representations.
+
+`prediction.csv` stores the RLATtr, SVR, and ensemble optimum-pH predictions.
+
+# OneScience Official Resources
+
+| Platform | OneScience Main Repository | Skills Repository |
+| --- | --- | --- |
+| Gitee | https://gitee.com/onescience-ai/onescience | https://gitee.com/onescience-ai/oneskills |
+| GitHub | https://github.com/onescience-ai/OneScience | https://github.com/onescience-ai/oneskills |
+
+# Citation and License
+
+- EpHod paper: [Machine learning prediction of enzyme optimum pH](https://doi.org/10.1038/s42256-025-01026-6)
+- Official implementation: https://github.com/jafetgado/EpHod
+- EpHod model and data: [Machine learning prediction of enzyme optimal pH](https://doi.org/10.5281/zenodo.14252615)
+- The upstream EpHod implementation is distributed under the MIT License.
+- This model package provides SCNet/DCU runtime adaptation and directory organization based on the official implementation.
+- The adaptation does not modify the copyright status, licenses, or terms of use of the original paper, source code, model weights, datasets, ESM-1v assets, or other third-party resources.

conf/README_upstream.rst

@@ -0,0 +1,52 @@
+**EpHod**
+===============
+
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.15015124.svg
+   :target: https://doi.org/10.5281/zenodo.15015124
+   :alt: DOI
+
+EpHod is a deep-learning model to predict the optimum pH of enzymes (pHopt). The model is of an ensemble of a neural network (residual light attention or RLAT) and a support vector regression (SVR) model both trained on top of ESM-1v embeddings. The neural network (RLATtr) was first pretrained using 1.9 million proteins with optimal environment pH (pHenv) labels, followed by fine tuning using 9,855 enzyme with catalytic optimum pH labels (pHopt).
+
+We recommend using a conda environment. Dependencies are in `env.yml`. The code was successfully run with PyTorch v1.7.0 and CUDA v 11.7.
+Weights of EpHod model and training datasets are available at `Zenodo <https://doi.org/10.5281/zenodo.14252615>`__.
+
+
+
+Usage 
+-------------
+
+1. Clone repository and install conda environment. Installation with the 
+required environment takes roughly four minutes.
+
+.. code:: shell-session
+
+    git clone https://github.com/jafetgado/EpHod.git
+    cd EpHod
+    conda env create -f ./env.yml -p ./env
+    conda activate ./env
+..
+    	
+2. Predict pHopt with EpHod. Predicted pHopt values, and attention weights from the RLATtr model, as well as the embeddings from the final RLATtr layer (2560-dim) are saved in ``./example/``. Pass 0 to ``--save_attention_weights`` 
+and ``--save_embeddings`` to avoid writing the weights and embeddings output. 
+Besides downloading model weights, which may take several minutues, with a batch size of 1, prediction takes ~7 seconds/sequence on a CPU and ~0.1 seconds/sequence on a GPU.
+
+.. code:: shell-session
+
+    python ./ephod/run.py \
+        --fasta_path "./example/test_sequences.fasta" \
+        --save_dir ./example \
+        --csv_name prediction.csv \
+        --verbose 1 \
+        --save_attention_weights 0 \
+        --save_embeddings 0 
+..
+
+
+
+
+Citation
+----------
+If you find EpHod useful, please cite the following:
+
+Gado J.E., Knotts M., Shaw A.Y., et al, 2025. "Machine learning prediction of enzyme optimum pH". `Nature Machine Intelligence <https://doi.org/10.1038/s42256-025-01026-6>`__.
+

conf/config.json

@@ -0,0 +1,12 @@
+{
+  "input_fasta": "conf/data/test_sequences.fasta",
+  "smoke_fasta": "conf/data/smoke.fasta",
+  "output_dir": "scripts/output",
+  "output_path": "scripts/output/prediction.csv",
+  "esm1v_checkpoint": "weight/esm1v_t33_650M_UR90S_1.pt",
+  "rlattr_checkpoint": "weight/ESM1v-RLATtr.pt",
+  "svr_checkpoint": "weight/ESM1v-SVR.pkl",
+  "max_sequence_length": 1022,
+  "batch_size": 1,
+  "device": "auto"
+}

conf/data/smoke.fasta

@@ -0,0 +1,2 @@
+>Q2YPV0 | Brucella abortus | 4.2.1.11 | 8.5 | 0.366
+MTAIIDIVGREILDSRGNPTVEVDVVLEDGSFGRAAVPSGASTGAHEAVELRDGGSRYLGKGVEKAVEVVNGKIFDAIAGMDAESQLLIDQTLIDLDGSANKGNLGANAILGVSLAVAKAAAQASGLPLYRYVGGTNAHVLPVPMMNIINGGAHADNPIDFQEFMILPVGATSIREAVRYGSEVFHTLKKRLKDAGHNTNVGDEGGFAPNLKNAQAALDFIMESIEKAGFKPGEDIALGLDCAATEFFKDGNYVYEGERKTRDPKAQAKYLAKLASDYPIVTIEDGMAEDDWEGWKYLTDLIGNKCQLVGDDLFVTNSARLRDGIRLGVANSILVKVNQIGSLSETLDAVETAHKAGYTAVMSHRSGETEDSTIADLAVATNCGQIKTGSLARSDRTAKYNQLIRIEEELGKQARYAGRSALKLL

conf/environment.yml

@@ -0,0 +1,10 @@
+name: onescience311
+channels:
+  - defaults
+dependencies:
+  - python=3.11
+  - pip
+
+# Install the OneScience DTK/DCU stack first, then install requirements.txt.
+# The upstream Python 3.8 / PyTorch 1.7 environment is preserved separately as
+# conf/environment_upstream.yml and must not replace the OneScience environment.

conf/environment_upstream.yml

@@ -0,0 +1,25 @@
+name: env
+channels:
+  - conda-forge
+  - bioconda
+  - pytorch
+  - defaults
+dependencies:
+  - python=3.8.8
+  - pytorch=1.7.0
+  - wget
+  - pip
+  - pip:
+    - fair-esm==1.0.2
+    - transformers
+    - sentencepiece
+    - h5py
+    - scikit-learn==0.23.2
+    - numpy==1.19.1
+    - biopython==1.79
+    - pandas==1.1.3
+    - xlrd
+    - openpyxl
+    - matplotlib
+    - ipython
+    - tqdm

conf/legacy/P2PXML_dataset/P2PXML-Seq/README.md

@@ -0,0 +1,66 @@
+# P2PXML-Seq Dataset
+
+To support the development of antibody-antigen binding affinity prediction frameworks, we curated the largest and most generalized datasets for antibody-antigen binding affinity prediction in the literature. To this end, P2PXML-Seq is the curated protein sequence dataset. 
+
+## Abstract from the accompanied paper [https://www.biorxiv.org/content/early/2024/06/10/2024.06.09.598103](Paper):
+
+In the context of drug development, the efficacy of drugs designed using biologics depends on the strength of the interactions between the biologics and the target molecule. In practise, these strengths of the interactions are measured using binding affinity and thus, understanding the binding affinity between an engineered antibody and its target antigen is a critical aspect of antibody engineering as it reflects the overall effectiveness of the antibody in inhibiting the activity of the target antigen. In theory, potential candidate antibodies have a higher binding affinity towards the target antigen. Currently, techniques such as Molecular docking and Molecular dynamics are utilized in quantifying the binding affinity. However, owing to the computational complexity of the aforementioned techniques, running simulations for large antibodies/antigens remains a daunting task. Despite the commendable improvements in deep learning-based binding affinity prediction, such approaches are highly dependent on the quality of the antibody-antigen structures and they tend to overlook the importance of capturing the evolutionary details of proteins upon mutation. Further, most of the existing datasets for the task only include antibody-antigen pairs related to one antigen variant and thus, not suitable for developing comprehensive data-driven approaches. To circumvent the said complexities, we first curate the largest and most generalized datasets for antibody-antigen binding affinity prediction, consisting both protein sequences and structures, in the literature and then propose a deep geometric neural network comprising a structure-based model and a sequence-based model that considers both atomistic and evolutionary details when predicting the binding affinity. The proposed framework exhibited a $10\%$ improvement in mean absolute error compared to the state-of-the-art models while showing a very strong correlation between the predictions and target values. We release the datasets and code publicly [https://drug-discovery-entc.github.io/p2pxml/](web-page) to support the development of antibody-antigen binding affinity prediction frameworks for the benefit of science and society.
+
+## Dataset Overview
+
+  Data include binding affinity values between a diverse sets of antibodies and antigens.  To our knowledge, this dataset is the most-generalized publicly-available dataset that contains antibody sequences, antigen sequences and quantitative measurements and provides an opportunity to serve as a benchmark to evaluate generalized and data-driven antibody-antigen binding affinity prediction frameworks.
+
+P2PXML-Seq dataset has a csv file with the following columns entries:
+
+| **Variable Name**        | **Description**    |
+| ------------------------ | ------------- | 
+| Ab_Sequence     | Antibody amino-acid sequence (PS: When the heavy and light chains were given, in the primary data sources, instead of the complete antibody sequence, we concatenate the light and heavy sequences, in that order, to create the complete sequence) | 
+| Ag_Sequence      | Antigen amino-acid sequence (PS: If the antigen sequence is marked as "0", it refers to the SARS-CoV-2 antigen sequence)*   |  
+| Pred_Affinity | The retrieved binding affinity between the corresponding antibody and antigen (PS: In this column, the experimental values with different measurement parameters are shown) | 
+| Unit_Type   | The type of measurement parameter in which the "Pred_Affinity" is expressed: 0 - Kd, 1 - IC50, 2 - ddG|
+| Estimated_Pred_Affinity | The estimated binding affinity between the corresponding antibody and antigen using several assumptions (PS: Refer the accompanied paper for more on this) |  
+| Processed | Whether the amino-acid sequences or affinity values from primary data sources have modified or estimated in this dataset: 0 - not modified, 1 - modified |
+| If_not_Ab_heavy | When the complete sequence is not given in the primary data source, the given heavy chain of the amino-acid sequence |
+| If_not_Ab_light | When the complete sequence is not given in the primary data source, the given light chain of the amino-acid sequence | 
+| Additional_Info_1 | Additional information such as the corresponding PDB ID | 
+| Additional_Info_2 | Additional information such as the corresponding PDB ID | 
+| Ag_type | The common name of the antigen variant which the antigen sequence is part of | 
+
+* Utilized amino-acid sequence for SARS-CoV-2: 'MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSSVLHSTQDLFLPFFSNVTWFHAIHVSGTNGTKRFDNPVLPFNDGVYFASTEKSNIIRGWIFGTTLDSKTQSLLIVNNATNVVIKVCEFQFCNDPFLGVYYHKNNKSWMESEFRVYSSANNCTFEYVSQPFLMDLEGKQGNFKNLREFVFKNIDGYFKIYSKHTPINLVRDLPQGFSALEPLVDLPIGINITRFQTLLALHRSYLTPGDSSSGWTAGAAAYYVGYLQPRTFLLKYNENGTITDAVDCALDPLSETKCTLKSFTVEKGIYQTSNFRVQPTESIVRFPNITNLCPFGEVFNATRFASVYAWNRKRISNCVADYSVLYNSASFSTFKCYGVSPTKLNDLCFTNVYADSFVIRGDEVRQIAPGQTGKIADYNYKLPDDFTGCVIAWNSNNLDSKVGGNYNYLYRLFRKSNLKPFERDISTEIYQAGSTPCNGVEGFNCYFPLQSYGFQPTNGVGYQPYRVVVLSFELLHAPATVCGPKKSTNLVKNKCVNFNFNGLTGTGVLTESNKKFLPFQQFGRDIADTTDAVRDPQTLEILDITPCSFGGVSVITPGTNTSNQVAVLYQDVNCTEVPVAIHADQLTPTWRVYSTGSNVFQTRAGCLIGAEHVNNSYECDIPIGAGICASYQTQTNSPRRARSVASQSIIAYTMSLGAENSVAYSNNSIAIPTNFTISVTTEILPVSMTKTSVDCTMYICGDSTECSNLLLQYGSFCTQLNRALTGIAVEQDKNTQEVFAQVKQIYKTPPIKDFGGFNFSQILPDPSKPSKRSFIEDLLFNKVTLADAGFIKQYGDCLGDIAARDLICAQKFNGLTVLPPLLTDEMIAQYTSALLAGTITSGWTFGAGAALQIPFAMQMAYRFNGIGVTQNVLYENQKLIANQFNSAIGKIQDSLSSTASALGKLQDVVNQNAQALNTLVKQLSSNFGAISSVLNDILSRLDKVEAEVQIDRLITGRLQSLQTYVTQQLIRAAEIRASANLAATKMSECVLGQSKRVDFCGKGYHLMSFPQSAPHGVVFLHVTYVPAQEKNFTTAPAICHDGKAHFPREGVFVSNGTHWFVTQRNFYEPQIITTDNTFVSGNCDVVIGIVNNTVYDPLQPELDSFKEELDKYFKNHTSPDVDLGDISGINASVVNIQKEIDRLNEVAKNLNESLIDLQELGKYEQYIKWPWYIWLGFIAGLIAIVMVTIMLCCMTSCCSCLKGCCSCGSCCKFDEDDSEPVLKGVKLHYT'
+
+## Citation
+
+@article {Bandara2024.06.09.598103,
+	author = {Bandara, Nuwan Sriyantha and Premathilaka, Dasun and Chandanayake, Sachini and Hettiarachchi, Sahan and Varenthirarajah, Vithurshan and Munasinghe, Aravinda and Madhawa, Kaushalya and Charles, Subodha},
+	title = {Deep Geometric Framework to Predict Antibody-Antigen Binding Affinity},
+	elocation-id = {2024.06.09.598103},
+	year = {2024},
+	doi = {10.1101/2024.06.09.598103},
+	publisher = {Cold Spring Harbor Laboratory},
+	URL = {https://www.biorxiv.org/content/early/2024/06/10/2024.06.09.598103},
+	eprint = {https://www.biorxiv.org/content/early/2024/06/10/2024.06.09.598103.full.pdf},
+	journal = {bioRxiv}
+}
+
+## License
+
+Shield: [![CC BY-NC-SA 4.0][cc-by-nc-sa-shield]][cc-by-nc-sa]
+
+This work is licensed under a
+[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].
+
+[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]
+
+[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
+[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
+[cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg
+
+
+## Disclaimer
+
+DISTRIBUTION STATEMENT A. Approved for public release. Distribution is unlimited.
+
+Any opinions, findings, conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the affiliated institutions of the author(s). 
+
+© 2024 P2PXML Team.
+

conf/legacy/P2PXML_dataset/P2PXML_Structure/README.md

@@ -0,0 +1,61 @@
+# P2PXML-PDB Dataset
+
+To support the development of antibody-antigen binding affinity prediction frameworks, we curated the largest and most generalized datasets for antibody-antigen binding affinity prediction in the literature. To this end, P2PXML-PDB is the curated protein structure dataset. 
+
+## Abstract from the accompanied paper [https://www.biorxiv.org/content/early/2024/06/10/2024.06.09.598103](Paper):
+
+In the context of drug development, the efficacy of drugs designed using biologics depends on the strength of the interactions between the biologics and the target molecule. In practise, these strengths of the interactions are measured using binding affinity and thus, understanding the binding affinity between an engineered antibody and its target antigen is a critical aspect of antibody engineering as it reflects the overall effectiveness of the antibody in inhibiting the activity of the target antigen. In theory, potential candidate antibodies have a higher binding affinity towards the target antigen. Currently, techniques such as Molecular docking and Molecular dynamics are utilized in quantifying the binding affinity. However, owing to the computational complexity of the aforementioned techniques, running simulations for large antibodies/antigens remains a daunting task. Despite the commendable improvements in deep learning-based binding affinity prediction, such approaches are highly dependent on the quality of the antibody-antigen structures and they tend to overlook the importance of capturing the evolutionary details of proteins upon mutation. Further, most of the existing datasets for the task only include antibody-antigen pairs related to one antigen variant and thus, not suitable for developing comprehensive data-driven approaches. To circumvent the said complexities, we first curate the largest and most generalized datasets for antibody-antigen binding affinity prediction, consisting both protein sequences and structures, in the literature and then propose a deep geometric neural network comprising a structure-based model and a sequence-based model that considers both atomistic and evolutionary details when predicting the binding affinity. The proposed framework exhibited a $10\%$ improvement in mean absolute error compared to the state-of-the-art models while showing a very strong correlation between the predictions and target values. We release the datasets and code publicly [https://drug-discovery-entc.github.io/p2pxml/](web-page) to support the development of antibody-antigen binding affinity prediction frameworks for the benefit of science and society.
+
+## Dataset Overview
+
+  Data include binding affinity values (in terms of IC50 value) between a diverse sets of antibodies and antigens. To our knowledge, this dataset is the largest, publicly-available dataset that contains antibody structures, antigen structures and quantitative measurements and provides an opportunity to serve as a benchmark to evaluate generalized and data-driven antibody-antigen binding affinity prediction frameworks.
+
+P2PXML-PDB dataset has two folders, named "antibodies" and "antigens", and a csv file with the following columns entries:
+
+| **Variable Name**        | **Description**    |
+| ------------------------ | ------------- | 
+| Ab     | Antibody name | 
+| Ag      | Antigen name      |  
+| IC50| The binding affinity between the corresponding antibody and antigen  | 
+| log(IC50)     | Logarithmic (to base 10) value of the corresponding IC50 | 
+
+The antibody and antigen structures (in PDB format), which are corresponding to the names in the "Ab" and "Ag" columns, are in the respective folders.
+
+## Citation
+
+@article {Bandara2024.06.09.598103,
+	author = {Bandara, Nuwan Sriyantha and Premathilaka, Dasun and Chandanayake, Sachini and Hettiarachchi, Sahan and Varenthirarajah, Vithurshan and Munasinghe, Aravinda and Madhawa, Kaushalya and Charles, Subodha},
+	title = {Deep Geometric Framework to Predict Antibody-Antigen Binding Affinity},
+	elocation-id = {2024.06.09.598103},
+	year = {2024},
+	doi = {10.1101/2024.06.09.598103},
+	publisher = {Cold Spring Harbor Laboratory},
+	URL = {https://www.biorxiv.org/content/early/2024/06/10/2024.06.09.598103},
+	eprint = {https://www.biorxiv.org/content/early/2024/06/10/2024.06.09.598103.full.pdf},
+	journal = {bioRxiv}
+}
+
+
+## License
+
+
+Shield: [![CC BY-NC-SA 4.0][cc-by-nc-sa-shield]][cc-by-nc-sa]
+
+This work is licensed under a
+[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].
+
+[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]
+
+[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
+[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
+[cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg
+
+
+## Disclaimer
+
+DISTRIBUTION STATEMENT A. Approved for public release. Distribution is unlimited.
+
+Any opinions, findings, conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the affiliated institutions of the author(s). 
+
+© 2024 P2PXML Team.
+

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antibodies_0.5γ.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93ef94df9521ab9fbf988d5c47007e46297325a02c78e24c99fc990d4d610a9d
+size 806844

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antibodies_10-1074.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4f91d4681b79ec48f23f7888e6cb15a59db7ff68da879355ae3b0dee7295b50
+size 1587531

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_0013095_2_11.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac2432509e5dec3f719fcbe459845a99cd148f97ff2be0007cc986f6e9aa7a60
+size 2016242

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_0815_V3_C3.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:970fe055e85973b871814101bf5e136f0ebed848816ad9c7a3a7e202da4203b0
+size 2013784

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_6535_3.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8686544b6804f247e5333438b947f627a2c44e20b0915f4c7353ac4e8ced528f
+size 2020324

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_AC10_29.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c389b1f225c783bb7e3dc99fc0ca2612709fff29c348228a5a2536b92a509296
+size 65536

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_JRFL.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b765659c9a03c6fe870a233ad754a08633bb0366011271c605d0c209fef4c188
+size 2009226

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_QH0692_42.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f270e2661f8e79b1e9355cbc253271adbbc2ad7f8801412ec04250fd7e9307d1
+size 2013515

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_REJO4541_67.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2485678396d8d4312c4afbf415548fd238cdedd952778ea4623f8c81c9aa06b
+size 1638400

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_RHPA4259_7.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67ef316708b16aa7638b78839110234f3d2806b19a831fff61bd61a3b5e2a578
+size 2016280

conf/legacy/P2PXML_dataset/P2PXML_Structure/graph_data/antigens_WITO4160_33.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f9e20fbe89397f45a86378d92a48edd995e342a2abe99ff94c8234c39f6ec4d
+size 2018213

conf/legacy/incomplete_transfers/ESM1v-SVR.partial.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a6022211516ca9375e3266fbee9f6639e16bb4c0f8d3977f1f8fcb219bfefdd
+size 45678592

conf/legacy/torch_cache/hub/checkpoints/ESM1v-RLATtr.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a8d2ce39e4d0e8c584172301cc1fd7942f919994266cb4875feeb3e165f6b89
+size 19726336

conf/legacy/torch_cache/hub/checkpoints/esm1v_t33_650M_UR90S_1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3d7c4c868045cbea65b47debb9764d8f55dcaea63854a169c7442a5d084df2b
+size 12058624

configuration.json

@@ -0,0 +1,15 @@
+{
+  "model_name": "EpHod",
+  "framework": "PyTorch",
+  "task": "enzyme-optimum-ph-prediction",
+  "entry_points": {
+    "inference": "scripts/inference.py",
+    "predict": "scripts/inference.py",
+    "train_neural_network": "scripts/train_nnmodels.py",
+    "train_machine_learning": "scripts/train_ml_models.py"
+  },
+  "source_package": "model",
+  "config": "conf/config.json",
+  "weight_dir": "weight",
+  "license": "MIT"
+}

model/__init__.py

@@ -0,0 +1 @@
+"""EpHod model source package."""

model/ephod/__init__.py

@@ -0,0 +1,9 @@
+"""EpHod: A deep language model to predict enzyme optimum pH
+Author: Japheth Gado
+"""
+
+__version__ = 1.0
+from . import *
+
+
+

model/ephod/training/nn_models.py

@@ -0,0 +1,659 @@
+"""
+Neural network models
+"""
+
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+
+
+def torchActivation(activation='elu'):
+    '''Return an activation function from torch.nn'''
+
+    if activation == 'relu':
+        return nn.ReLU()
+    elif activation == 'leaky_relu':
+        return nn.LeakyReLU()
+    elif activation == 'elu':
+        return nn.ELU()
+    elif activation == 'selu':
+        return nn.SELU()
+    elif activation == 'gelu':
+        return nn.GELU()
+
+
+
+
+def count_parameters(model):
+    '''Return a count of parameters and tensor shape of PyTorch model''' 
+    
+    counted = {}
+    total = 0
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            count = param.numel()
+            total += count
+            counted[name] = count
+    counted['FULL_MODEL'] = total
+
+    return counted
+
+
+
+
+class ResidualDense(nn.Module):
+    '''A single dense layer with residual connection'''
+    
+    def __init__(self, dim=2560, dropout=0.1, activation='elu', random_seed=0):
+        
+        super(ResidualDense, self).__init__()
+        _ = torch.manual_seed(random_seed)
+        self.dense = nn.Linear(dim, dim)
+        self.batchnorm = nn.BatchNorm1d(dim)
+        self.activation = torchActivation(activation)
+        self.dropout = nn.Dropout(dropout)
+
+
+    def forward(self, x):
+
+        x0 = x
+        x = self.dense(x)
+        x = self.batchnorm(x)
+        x = self.activation(x)        
+        x = self.dropout(x)
+        x = x0 + x
+        
+        return x
+
+
+
+
+class LightAttention(nn.Module):
+    '''Convolution model with attention to learn pooled representations from embeddings'''
+
+    def __init__(self, dim=1280, kernel_size=7, random_seed=0):
+        
+        super(LightAttention, self).__init__()
+        _ = torch.manual_seed(random_seed)        
+        samepad = kernel_size // 2
+        self.values_conv = nn.Conv1d(dim, dim, kernel_size=kernel_size, padding=samepad)
+        self.weights_conv = nn.Conv1d(dim, dim, kernel_size=kernel_size, padding=samepad)
+        self.softmax = nn.Softmax(dim=-1)
+    
+    
+    def forward(self, x, mask=None):
+        if mask is None:
+            mask = torch.ones(x.shape[0], x.shape[2], dtype=torch.int32)  # Don't mask out
+        values = self.values_conv(x)
+        values = values.masked_fill(mask[:,None,:]==0, -1e6)
+        weights = self.weights_conv(x)
+        weights = weights.masked_fill(mask[:,None,:]==0, -1e6)
+        weights = self.softmax(weights)
+        x_sum = torch.sum(values * weights, dim=-1) # Attention-weighted pooling
+        x_max, _ = torch.max(values, dim=-1) # Max pooling
+        x = torch.cat([x_sum, x_max], dim=1)
+        
+        return x, weights
+
+
+
+
+class ResidualLightAttention(nn.Module):
+    '''Model consisting of light attention followed by residual dense layers'''
+    
+    def __init__(self, dim=1280, kernel_size=9, dropout=0.5,
+                 activation='relu', res_blocks=4, random_seed=0):
+
+        super(ResidualLightAttention, self).__init__()
+        torch.manual_seed(random_seed)
+        self.light_attention = LightAttention(dim, kernel_size, random_seed)
+        self.batchnorm = nn.BatchNorm1d(2 * dim)                
+        self.dropout = nn.Dropout(dropout)        
+        self.residual_dense = nn.ModuleList()        
+        for i in range(res_blocks):
+            self.residual_dense.append(
+                ResidualDense(2 * dim, dropout, activation, random_seed)
+                )
+        self.output = nn.Linear(2 * dim, 1)
+        
+        
+    def forward(self, x, mask=None):
+
+        x, weights = self.light_attention(x, mask)
+        x = self.batchnorm(x)
+        x = self.dropout(x)
+        for layer in self.residual_dense:
+            x = layer(x)
+        y = self.output(x).flatten()
+        
+        return [y, x, weights]
+
+
+
+
+class FeedForwardNetwork(nn.Module):
+    '''A feed-forward neural network (fully-connected)'''
+    
+    def __init__(self, input_dim=1280, hidden_dim=128, num_layers=1, dropout=0.25, activation='relu', 
+                 residual=False):
+        
+        super().__init__()
+        self.num_layers = num_layers
+        self.residual = residual
+
+        # First dense layer
+        # Separate first dense layer from the other dense layers to allow residual connection
+        self.first_dense = nn.ModuleList(
+            [
+                nn.Linear(input_dim, hidden_dim),
+                nn.BatchNorm1d(hidden_dim),                                         
+                torchActivation(activation),
+                nn.Dropout(dropout) if activation != 'selu' else nn.AlphaDropout(dropout)
+            ]
+        )
+        
+        # Other dense layers after first dense and residual connection
+        if num_layers > 1:
+            self.other_dense = nn.ModuleList()
+            for i in range(1, num_layers):
+                self.other_dense.extend(
+                    [
+                        nn.Linear(hidden_dim, hidden_dim),
+                        nn.BatchNorm1d(hidden_dim),
+                        torchActivation(activation),
+                        nn.Dropout(dropout) if activation != 'selu' else nn.AlphaDropout(dropout)
+                    ]
+                )
+        # Output layer
+        self.output_layer = nn.Linear(hidden_dim, 1)
+
+
+    def forward(self, x):
+
+        # First dense layer
+        for layer in self.first_dense:
+            x = layer(x) 
+            
+        # Other dense layers
+        if self.num_layers > 1:
+            x0 = x
+            for layer in self.other_dense:
+                x = layer(x)  
+            # Residual connection
+            if self.residual:
+                x = x0 + x 
+        # Output layer
+        y = self.output_layer(x).flatten()
+        
+        return y
+
+
+
+
+class CNN(nn.Module):
+
+    def __init__(self, input_channel=20, input_length=1024, start_conv_channel=32, kernel_size=3,
+                 num_conv_layers=8, conv_dropout=0.25, pooltype='max', dense_dim=128, num_dense_layers=1,
+                 dense_dropout=0.25, activation='relu'):
+        
+        super().__init__()
+        # Conv layers
+        self.conv_layers = nn.ModuleList() 
+        for i in range(num_conv_layers):
+            in_channel = input_channel if i==0 else out_channel
+            out_channel = start_conv_channel * (2 ** i)
+            self.conv_layers.append(nn.Conv1d(in_channel, out_channel, kernel_size=kernel_size, 
+                                              padding=(kernel_size // 2)))
+            self.conv_layers.append(nn.BatchNorm1d(out_channel))
+            self.conv_layers.append(torchActivation(activation))
+            if pooltype=='max' and i>0:
+                self.conv_layers.append(nn.MaxPool1d(kernel_size=2, stride=2))
+            elif pooltype=='average' and i>0:
+                self.conv_layers.append(nn.AvgPool1d(kernel_size=2, stride=2))
+            self.conv_layers.append(nn.Dropout(conv_dropout))
+        # FNN layers
+        self.flatsize = start_conv_channel * input_length
+        self.fnn = FeedForwardNetwork(input_dim=self.flatsize, hidden_dim=dense_dim, num_layers=num_dense_layers, 
+                                      dropout=dense_dropout, activation=activation, residual=True)
+
+    def forward(self, x):
+
+        for layer in self.conv_layers:
+            x = layer(x)
+        x = x.view(-1, self.flatsize)
+        y = self.fnn(x)
+        
+        return y
+
+
+
+
+class CausalConv1d(nn.Module):
+    '''Causal convolution'''
+    
+    def __init__(self, in_channels, out_channels, kernel_size, dilation=1):
+
+        super().__init__()
+
+        self.pad = int(np.ceil(dilation * (kernel_size - 1) / 2)) # Padding to ensure causal convolution
+        self.conv_layer = nn.Conv1d(in_channels, out_channels, padding=0,kernel_size=kernel_size, 
+                                    dilation=dilation)
+    
+    def forward(self, x):
+        
+        len1 = x.shape[-1]
+        x = F.pad(x, (self.pad * 2, 0))
+        x = self.conv_layer(x)
+        len2 = x.shape[-1]
+        start = len2 - len1
+        x = x[:,:,start:len2]
+
+        return x
+
+
+
+
+class DCNNBlock(nn.Module):
+
+    def __init__(self,channel_size=32, num_layers=6,dropout=0.5, activation='elu'):
+        
+        super().__init__()
+        dilation_rates = (2. ** np.arange(num_layers)).astype(np.int32)
+        self.layers = nn.ModuleList()
+        for d in dilation_rates:
+            self.layers.append(CausalConv1d(channel_size, channel_size, kernel_size=2, dilation=d))
+            self.layers.append(nn.BatchNorm1d(channel_size))
+            self.layers.append(torchActivation(activation))
+        self.layers.append(nn.Dropout(dropout))
+        
+    def forward(self, x):
+        
+        x0 = x
+        for layer in self.layers:
+            x = layer(x)
+        x = x0 + x
+
+        return x
+
+
+
+
+class DCNN(nn.Module):
+
+    def __init__(self, input_channel=20, conv_channel=48, num_blocks=6, layers_per_block=10,
+                 block_dropout=0.5, dense_dim=128, num_dense_layers=2, dense_dropout=0.25,
+                 activation='elu'):
+        
+        super().__init__()
+        self.embed_layer = nn.Conv1d(input_channel, conv_channel, kernel_size=1, bias=False)
+        
+        # DCNN blocks
+        self.dcnn_blocks = nn.ModuleList()    
+        for block in range(num_blocks):
+            self.dcnn_blocks.append(DCNNBlock(channel_size=conv_channel, num_layers=layers_per_block,
+                                              dropout=block_dropout, activation=activation))
+        
+        self.fnn = FeedForwardNetwork(input_dim=conv_channel, hidden_dim=dense_dim, 
+                                      num_layers=num_dense_layers, dropout=dense_dropout, 
+                                      activation=activation, residual=True)
+    
+    def forward(self, x, mask=None):
+
+        x = self.embed_layer(x)
+        # Dilated convolutions
+        for layer in self.dcnn_blocks:
+            x = layer(x)
+        if mask is None:
+            mask = torch.ones(x.shape[0], x.shape[2], dtype=torch.int32)
+        # Average pooling
+        x = x.masked_fill(mask[:,None,:] == 0, 0)
+        x = torch.divide(torch.sum(x, dim=-1), torch.sum(mask, dim=-1)[:,None])
+        
+        # FNN
+        y = self.fnn(x).flatten()
+        
+        return y
+
+
+
+
+class RNN(nn.Module):
+
+    def __init__(self, input_channel=20, input_length=1024, gru_dim=1024, conv_downsample=1, 
+                 conv_dropout=0.25, dense_dim=128, dense_dropout=0.25, activation='relu'):
+        
+        super().__init__()
+        
+        # Convolutional layers to downsample
+        self.conv_downsample = conv_downsample
+        self.conv_layers = nn.ModuleList() 
+        pad = (conv_downsample // 2 - 1)
+        pad = max(pad, 0)
+        self.conv_layers.append(nn.Conv1d(input_channel, gru_dim, kernel_size=conv_downsample, 
+                                          stride=conv_downsample, padding=pad))
+        self.conv_layers.append(nn.BatchNorm1d(gru_dim))
+        self.conv_layers.append(torchActivation(activation))
+        self.conv_layers.append(nn.Dropout(conv_dropout))
+        
+        # RNN layer
+        self.gru_layer = nn.GRU(gru_dim, gru_dim, batch_first=True, bidirectional=False)
+       
+        # Dense layer
+        self.dense_layers = nn.ModuleList()
+        self.dense_layers.extend(
+            [
+                nn.Linear(gru_dim, dense_dim),
+                nn.BatchNorm1d(dense_dim),                    
+                torchActivation(activation),
+                nn.Dropout(dense_dropout) if activation != 'selu' else nn.AlphaDropout(dense_dropout)
+            ]
+        )
+
+        # Output layer
+        self.output_layer = nn.Linear(dense_dim, 1) 
+
+
+
+    def forward(self, x, mask=None):
+        
+        if mask is None:
+            mask = torch.tensor(np.ones((x.shape[0], x.shape[-1])), dtype=torch.float32)
+
+        # Downsample with convolution
+        for layer in self.conv_layers:
+            x = layer(x)
+
+        # RNN
+        x = x.transpose(2, 1) # Transpose from [batch, feat, seqlen] to [batch, sequence, features]
+        x = self.gru_layer(x)[0]
+        lastind = torch.sum(mask, axis=1, dtype=int) # index of last residue in sequence
+        lastind = (lastind // self.conv_downsample) - 1  # index after conv. downsampling
+        x = [x[i][lastind[i]] for i in range(len(lastind))] # get hidden state of last residue for each sequence
+        x = torch.stack(x)
+        
+        # Dense layer
+        for layer in self.dense_layers:
+            x = layer(x)
+        
+        # Output layer
+        x = self.output_layer(x).flatten()
+
+        return x
+
+
+
+
+class AttentionTopModel(nn.Module):
+    '''
+    Class to implement a top model based on LAT architecture to predict a property from 
+    embeddings.
+    
+    Parameters
+    -----------
+    input_dim : int
+        Channel dimension of input embedding, 1280 for ESM-1b        
+    attention_dim : int
+        Channel dimension of transformed values and attention weights
+    kernel_size : int
+        Kernel size of convolution 
+    conv_dropout : float
+        Dropout applied to values embedding after convolution 
+    perceptive : bool
+        If True, concatenate input embedding with average pooled embedding to derive 
+        a perceptive embedding.        
+    dense_dim : int
+        Number of units in hidden dense layer
+    dense_dropout : float
+        Dropout of dense hidden layers.
+    activation : str
+        Activation function of dense hidden layer.
+    random_seed : int
+        Random seed for reproducibillity
+     
+     '''
+
+
+    def __init__(self, 
+                 input_dim=1280,
+                 attention_dim=1280,
+                 kernel_size=9,
+                 conv_dropout=0.25,
+                 perceptive=True,                 
+                 dense_dim=512,
+                 dense_dropout=0.25,
+                 num_layers=1, 
+                 residual=False,
+                 activation='relu',
+                 random_seed=0):
+        
+
+        super(AttentionTopModel, self).__init__()
+
+
+        # Initialize class parameters  
+        self.input_dim = input_dim            
+        self.attention_dim = attention_dim   
+        self.kernel_size = kernel_size       
+        self.conv_dropout = conv_dropout    
+        self.perceptive = perceptive                 
+        self.dense_dim = dense_dim           
+        self.dense_dropout = dense_dropout   
+        self.num_layers = num_layers
+        self.residual = residual
+        self.activation = activation         
+        self.random_seed = random_seed       
+        _ = torch.manual_seed(self.random_seed)
+
+            
+        # A convolution layer to learn values from embeddings
+        self.values_conv = nn.Conv1d(
+            2 * self.input_dim if perceptive else self.input_dim,
+            self.attention_dim, 
+            kernel_size=self.kernel_size,
+            stride=1,
+            padding=(self.kernel_size // 2)
+            )
+        self.values_dropout = nn.Dropout(self.conv_dropout) 
+        
+        
+        # A convolution and softmax layer to learn attention weights that sum to 1
+        self.attn_conv = nn.Conv1d(
+            2 * self.input_dim if perceptive else self.input_dim,
+            self.attention_dim, 
+            kernel_size=self.kernel_size,
+            stride=1,
+            padding=(self.kernel_size // 2)
+            )
+        self.attn_softmax = nn.Softmax(dim=-1)
+        
+        # Dense(residual) layers on top of the attention-learned embeddings
+        self.dense_layers = FeedForwardNetwork(
+            input_dim=(2 * self.attention_dim), 
+            hidden_dims=[self.dense_dim] * self.num_layers, 
+            dropout=self.dense_dropout, 
+            activation=self.activation, 
+            residual=self.residual, 
+            random_seed=self.random_seed
+            )
+                                                     
+
+    def forward(self, x, mask=None):
+        '''
+        Forward pass of network. 
+
+        Parameters
+        ------------
+        x : torch.Tensor
+            Shape is [batch_size, embeddings_dim, seq_len]
+        mask : torch.Tensor or None
+            Boolean tensor indicating padded (0) and non-padded (1) positions. Shape is 
+            [batch_size, seq_len]. If mask is None, a tensor of ones is used, 
+            indicating that padded positions are not masked out in the forward 
+            computations.
+
+        Returns
+        -------
+        output: list
+            A list of predicted values (shape is [batch_size, 1]), embedding of the
+            hidden layer before the output layer (shape is [batch_size, dense_dim]), and
+            the masked attention weights (shape is [batch_size, attention_dim, seq_len])
+        '''
+        
+        # Masking for  padded positions
+        if mask is None:
+            # If mask is None, use all positions including padded positions
+            mask = torch.ones(x.shape[0], x.shape[2], dtype=torch.int32)
+        
+        # Derive a perceptive tensor by concatenating mean pooled embeddings to the input 
+        # Output shape of perceptive tensor is [batch_size, 2 * input_dim, seq_length]
+        if self.perceptive:
+            # Mask out padded positions
+            x_perc = x.masked_fill(mask[:,None,:] == 0, 0)  
+            # Average pooling over unpadded positions
+            x_perc = torch.divide(torch.sum(x_perc, dim=-1), 
+                                  torch.sum(mask, dim=1)[:,None]) 
+            # Repeat pooled tensor to match sequence length
+            x_perc = x_perc[:,:,None].repeat(1,1,x.shape[-1]) 
+            # Concatenate input embeddings and perceptive tensor along feature dimension
+            x = torch.cat((x, x_perc), axis=1) 
+        
+        # Derive values and attention weights from input embeddings with convolution
+        # Output shapes for values/weights is [batch_size, attention_dim, seq_length]
+        values = self.values_conv(x)
+        values = self.values_dropout(values)
+        values = values.masked_fill(mask[:,None,:] == 0, -1e6)  # Mask out for max pooling
+
+        # Attention weights that sum to 1
+        attn = self.attn_conv(x)   
+        attn = attn.masked_fill(mask[:,None,:] == 0, -1e6) # Mask out for average pooling
+        attn = self.attn_softmax(attn)
+        
+        # Derive attention-learned embeddings by multiplying values and attention weights
+        # Output shape is [batch_size, 2 * attention_dim]
+        z_sum = torch.sum(values * attn, dim=-1) 
+        z_max, _ = torch.max(values, dim=-1)
+        z = torch.cat([z_sum, z_max], dim=1)
+
+        # Dense layers
+        y, z = self.dense_layers(z)
+
+        
+        return [y, z, attn]
+
+
+
+
+class DilatedConvTopModel(nn.Module):
+
+    def __init__(self, 
+                 input_dim=1280,
+                 input_len=1024,
+                 attention_kernel_size=9,                 
+                 conv_dim=64,
+                 conv_kernel_size=3,
+                 conv_dropout=0.1,
+                 dilated_layers=9,                 
+                 dense_dim=512,
+                 dense_layers=1,                  
+                 dense_dropout=0.25,
+                 activation='relu',
+                 random_seed=0):
+        
+        super(DilatedConvTopModel, self).__init__()
+        _ = torch.manual_seed(random_seed)
+        
+        # A convolution layer to learn transformed values from embeddings
+        self.values_conv_layer = nn.Conv1d(
+            input_dim,
+            conv_dim, 
+            kernel_size=attention_kernel_size,
+            stride=1, 
+            dilation=1, 
+            padding=(attention_kernel_size // 2)
+            )        
+        
+        
+        # A convolution and softmax layer to learn attention weights that sum to 1
+        # Attention-weighted values are obtained by element-wise multiplication with weights
+        self.attention_conv_layer = nn.Conv1d(
+            input_dim,
+            conv_dim, 
+            kernel_size=attention_kernel_size,
+            stride=1, 
+            dilation=1, 
+            padding=(attention_kernel_size // 2)
+            )       
+        self.attention_softmax = nn.Softmax(dim=-1)
+        self.conv_dropout_layer = nn.Dropout(conv_dropout) if activation != 'selu' \
+                    else nn.AlphaDropout(conv_dropout)
+        
+        
+        # Convolutional layers with increasing dilation rates
+        self.dilated_conv_layers = nn.ModuleList()
+        dilations = np.power(2, np.arange(dilated_layers)) 
+
+        for d in dilations:
+
+            same_padding = self.get_same_padding_size(conv_kernel_size, d)
+            self.dilated_conv_layers.append(nn.Conv1d(conv_dim, 
+                                                      conv_dim,
+                                                      kernel_size=conv_kernel_size,
+                                                      padding=same_padding,
+                                                      dilation=d)
+                              )
+            self.dilated_conv_layers.append(nn.BatchNorm1d(conv_dim))
+            self.dilated_conv_layers.append(torchActivation(activation))
+            
+        
+        # Dense layers
+        self.dense_layers = FeedForwardNetwork(input_dim=(input_len * conv_dim), 
+                                               hidden_dims=[dense_dim] * dense_layers, 
+                                               dropout=dense_dropout, 
+                                               activation=activation, 
+                                               residual=(dense_layers > 1), 
+                                               random_seed=random_seed)
+
+    
+    def get_same_padding_size(self, k, d):
+
+        padsize = int(
+            np.ceil(
+                d * (k - 1) / 2
+                )
+            )
+        
+        return padsize
+    
+    
+    def forward(self, x, mask=None):
+        
+        # Masking for padded positions
+        if mask is None:
+            # If mask is None, use all positions including padded positions
+            mask = torch.ones(x.shape[0], x.shape[2], dtype=torch.int32)
+        
+        # Derive attention-weighted values from input embeddings
+        # Shapes for values/weights is [batch_size, attention_dim, seq_length]
+        x_values = self.values_conv_layer(x)
+        x_weights = self.attention_conv_layer(x)   
+        x_weights = x_weights.masked_fill(mask[:,None,:] == 0, -1e6) 
+        x_weights = self.attention_softmax(x_weights) # Weights sum to 1
+        x = (x_values * x_weights)  
+        x = self.conv_dropout_layer(x)
+        
+        # Dilated convolution layers
+        x0 = x
+        for layer in self.dilated_conv_layers:
+            x = layer(x)
+        x = x0 + x  # Residual connection
+        
+        # Dense layers
+        x = x.flatten(start_dim=1, end_dim=2)
+        y, z = self.dense_layers(x)
+        
+        return [y, z, x_weights]     
+

model/ephod/training/trainutils.py

@@ -0,0 +1,165 @@
+"""
+Utility functions for training
+"""
+
+
+import numpy as np
+import pandas as pd
+from scipy.stats import spearmanr, pearsonr
+from scipy.ndimage import convolve1d
+from scipy.ndimage import gaussian_filter1d
+from sklearn import metrics
+
+
+
+
+def label_distribution_smoothing(y, bins=None, ks=5, sigma=2, normalize=True):
+    """
+    Return a smoothed label distribution derived by convolving a symetric kernel
+    to the empirical label distribution. If bins is None, split the data (y) into bins
+    such that each bin corresponds to 1.0 pH unit. Otherwise if bins is an integer, split
+    bins into as many bins as is specified.
+    See the paper,
+    Yang, Zha, Chen, et al, 2021. Delving into deep imbalanced regression.
+    Code adapted from https://github.com/YyzHarry/imbalanced-regression
+    """
+        
+    # First split the data into bins of equal width
+    if bins==None:
+        bins = int(np.ceil(np.max(y) - np.min(y)))  # No. of bins using a width of 1.0 pH units
+    bin_freqs, bin_borders = np.histogram(y, range=(min(y), max(y)), bins=bins)
+    y_binned = np.zeros(len(y))  # Initialize bin indices to 0s
+    for i in range(bins):
+        low, high = bin_borders[i], bin_borders[i+1] # Low and high boundaries of bin
+        locs = np.logical_and((y >= low), (y<= high)) # Location of values in y within bin
+        y_binned[locs] = i
+
+    # Compute kernel window
+    half_ks = (ks - 1) // 2
+    base_kernel = [0.] * half_ks + [1.] + [0.] * half_ks
+    kernel_window = gaussian_filter1d(base_kernel, sigma=sigma) 
+    kernel_window /= max(gaussian_filter1d(base_kernel, sigma=sigma))
+
+    # Derive Kernel estimation
+    bin_kde = convolve1d(np.array(bin_freqs), weights=kernel_window, mode='constant')
+    y_kde = np.array([bin_kde[int(item)] for item in y_binned])
+
+    # Normalize KDE
+    if normalize:
+        y_kde = y_kde / (np.min(y_kde))
+    
+    return y_kde
+
+
+
+
+def get_sample_weights(ydata, method='bin_inv', bin_borders=[5,9]):
+    """
+    Return an array of sample weights computed with different methods.
+    Methods:
+        'None': No reweighting, weights of ones for all samples
+        'bin_inv': Inverse of frequency of three main bins [y<=5, 5<y<9, y>=9]
+        'bin_inv_sqrt': Square root of bin_inverse
+        'LDS_inv': Inverse of Gaussian kernel density estimate 
+                   (label distribution smoothing) of target data derived with 
+                   kernel size of 5, standard deviation of 2, and 100 equidistant bins.
+        'LDS_inv_sqrt': Square root of LDS_inv
+        'LDS_extreme': LDS weights are rescaled so that rare values (y<=5, y>=9) are twice
+                       more likely to be selected than normal values (5<y<9).
+    """
+    
+    assert method in ['None', 'bin_inv', 'bin_inv_sqrt', 'LDS_inv', 'LDS_inv_sqrt',
+                      'LDS_extreme']
+    
+    if method == 'None':
+        # Non-uniform weights (no weighting, use data as is)
+        weights = np.ones(len(ydata))
+
+    elif method in ['bin_inv', 'bin_inv_sqrt']:
+        # Inverse frequency weights (1/n)
+        y_binned = np.digitize(ydata, bin_borders)  # Continuous targets binned into categorical
+        bin_class, bin_freqs = np.unique(y_binned, return_counts=True)
+        inv_freq_dict = dict(zip(bin_class, 1 / bin_freqs)) # Frequency of each bin as dictionary
+        weights = np.array([inv_freq_dict[value] for value in y_binned]) # Inverse of frequency as sample weights
+
+    elif method in ['LDS_inv', 'LDS_inv_sqrt', 'LDS_extreme']:
+        # Label distribution smoothing (LDS) weights, with Gaussian KDE
+        effdist = label_distribution_smoothing(ydata, bins=100) 
+        weights = 1 / effdist
+        if method == 'LDS_extreme':
+            # Scale weights so rare values have double weights
+            relevance = np.logical_or(ydata<=5, ydata>=9).astype(int) # Select rare values
+            relevance = relevance * (1 - 0.5) + 0.5  # Values to double rare weights
+            weights = weights * relevance
+            
+    if method in ['bin_inv_sqrt', 'LDS_inv_sqrt']:
+        weights = np.sqrt(weights)
+    
+    # Normalize so weights have a mean of 1
+    weights = weights / np.mean(weights)
+    
+    return weights
+
+
+
+
+def sample_hyperparameters(param_space, n=200):
+    """
+    Return hyperparmeters randomly sampled from a dictionary, where keys are hyperparameter names
+    and values are arrays of possible hyperparameters.
+    """
+    
+    params_list = []
+    maxsize = int(np.product([len(item) for item in param_space.values()]))
+    
+    while len(params_list) < min([n, maxsize]):
+        sampled_params = {}
+        for key,values in param_space.items():
+            sampled_params[key] = np.random.choice(values)
+        if sampled_params not in params_list:
+            params_list.append(sampled_params)
+    
+    return params_list
+
+
+
+
+def performance(ytrue, ypred, weights, bins=[5,9]):
+    '''Return a dictionary of performance metrics evaluated on predictions'''
+    
+    perf = {}
+    ytrue, ypred, weights = np.asarray(ytrue), np.asarray(ypred), np.asarray(weights)
+
+    # Correlation (use resampled data to capture sparse acidic/alkaline regions)
+    p = weights / np.sum(weights)
+    usize = len(weights)
+    rho, r = 0, 0
+    iters = 100
+    for _ in range(iters):
+        locs = np.random.choice(range(len(ytrue)), size=usize, p=p, replace=True) 
+        rho += float(spearmanr(ytrue[locs], ypred[locs])[0])
+        r += float(pearsonr(ytrue[locs], ypred[locs])[0])
+    perf['rho'] = rho / iters
+    perf['r'] = r / iters
+
+    # Sample-weighted metrics
+    perf['rmse'] = float(metrics.mean_squared_error(ytrue, ypred, sample_weight=weights, squared=False))
+    perf['r2'] = float(metrics.r2_score(ytrue, ypred, sample_weight=weights))
+                 
+    # Classification performance of binned data
+    ytrue_binned = np.digitize(ytrue, bins)
+    ypred_binned = np.digitize(ypred, bins)
+    perf['mcc'] = float(metrics.matthews_corrcoef(ytrue_binned, ypred_binned, sample_weight=weights))
+    f1score, auc = [], [], 
+    for val in set(ytrue_binned):
+        ytrue_sel = (ytrue_binned==val).astype(int)
+        ypred_sel = (ypred_binned==val).astype(int)
+        f1score.append(float(metrics.f1_score(ytrue_sel, ypred_sel, sample_weight=weights)))
+        auc.append(float(metrics.roc_auc_score(ytrue_sel, ypred_sel, sample_weight=weights)))
+        perf['f1score_per_bin'] = f1score
+        perf['f1score'] = np.mean(f1score)
+        perf['auc_per_bin'] = auc
+        perf['auc'] = np.mean(auc)
+        
+    return perf
+