rcsb-embedding-model 0.0.1__tar.gz

rcsb_embedding_model-0.0.1/.gitignore

@@ -0,0 +1,3 @@
+/.idea
+/rcsb-embedding-model.iml
+/dist/

rcsb_embedding_model-0.0.1/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, RCSB Protein Data Bank, UC San Diego
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

rcsb_embedding_model-0.0.1/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: rcsb-embedding-model
+Version: 0.0.1
+Summary: Protein Embedding Model for Structure Search
+Project-URL: Homepage, https://github.com/rcsb/rcsb-embedding-model
+Project-URL: Issues, https://github.com/rcsb/rcsb-embedding-model/issues
+Author-email: Joan Segura <joan.segura@rcsb.org>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: esm>=3.2.0
+Requires-Dist: torch>=2.6.0
+Description-Content-Type: text/markdown
+
+# RCSB Embedding Model: A Deep Learning Approach for 3D Structure Embeddings
+
+## Overview
+RCSB Embedding Model is a PyTorch-based neural network that transforms macromolecular 3D structures into vector embeddings.
+
+Preprint: [Multi-scale structural similarity embedding search across entire proteomes](https://www.biorxiv.org/content/10.1101/2025.02.28.640875v1).
+
+A web-based implementation using this model for structure similarity search is available at [rcsb-embedding-search](http://embedding-search.rcsb.org).
+
+If you are interested in training the model with a new dataset, visit the [rcsb-embedding-search repository](https://github.com/bioinsilico/rcsb-embedding-search), which provides scripts and documentation for training.
+
+---
+
+## Embedding Model
+The embedding model is trained to predict structural similarity by approximating TM-scores using cosine distances between embeddings. It consists of two main components:
+
+- **Protein Language Model (PLM)**: Computes residue-level embeddings from a given 3D structure.
+- **Residue Embedding Aggregator**: A transformer-based neural network that aggregates these residue-level embeddings into a single vector.
+
+![Embedding model architecture](assets/embedding-model-architecture.png)
+
+### **Protein Language Model (PLM)**
+Residue-wise embeddings of protein structures are computed using the [ESM3](https://www.evolutionaryscale.ai/) generative protein language model.
+
+### **Residue Embedding Aggregator**
+The aggregation component consists of six transformer encoder layers, each with a 3,072-neuron feedforward layer and ReLU activations. After processing through these layers, a summation pooling operation is applied, followed by 12 fully connected residual layers that refine the embeddings into a single 1,536-dimensional vector.
+
+---
+
+## How to Use the Model
+This repository provides the tools to compute embeddings for 3D macromolecular structure data.
+
+### **Installation**
+`pip install `
+
+### **Requirements**
+Ensure you have the following dependencies installed:
+- `python >= 3.10`
+- `esm`
+- `torch`
+
+### **Generating Residue Embeddings**
+ESM3 embeddings for the 3D structures can be calculated as:
+
+```python
+from rcsb_embedding_model import RcsbStructureEmbedding
+
+mmcif_file = "<path_to_file>/<name>.cif"
+model = RcsbStructureEmbedding()
+res_embedding = model.residue_embedding(
+    structure_src=mmcif_file,
+    format="mmcif",
+    chain_id='A'
+)
+```
+
+### **Generating Protein Structure**
+Protein 3D structure embedding can be calculated as:
+
+```python
+from rcsb_embedding_model import RcsbStructureEmbedding
+
+mmcif_file = "<path_to_file>/<name>.cif"
+model = RcsbStructureEmbedding()
+res_embedding = model.residue_embedding(
+    structure_src=mmcif_file,
+    format="mmcif",
+    chain_id='A'
+)
+structure_embedding = model.aggregator_embedding(
+    res_embedding
+)
+```
+
+### **Pretrained Model**
+You can download a pretrained Residue Embedding Aggregator model from [Hugging Face](https://huggingface.co/jseguramora/rcsb-embedding-model/resolve/main/rcsb-embedding-model.pt).
+
+---
+
+## Questions & Issues
+For any questions or comments, please open an issue on this repository.
+
+---
+
+## License
+This software is released under the BSD 3-Clause License. See the full license text below.
+
+### BSD 3-Clause License
+
+Copyright (c) 2024, RCSB Protein Data Bank, UC San Diego
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

rcsb_embedding_model-0.0.1/README.md

@@ -0,0 +1,99 @@
+# RCSB Embedding Model: A Deep Learning Approach for 3D Structure Embeddings
+
+## Overview
+RCSB Embedding Model is a PyTorch-based neural network that transforms macromolecular 3D structures into vector embeddings.
+
+Preprint: [Multi-scale structural similarity embedding search across entire proteomes](https://www.biorxiv.org/content/10.1101/2025.02.28.640875v1).
+
+A web-based implementation using this model for structure similarity search is available at [rcsb-embedding-search](http://embedding-search.rcsb.org).
+
+If you are interested in training the model with a new dataset, visit the [rcsb-embedding-search repository](https://github.com/bioinsilico/rcsb-embedding-search), which provides scripts and documentation for training.
+
+---
+
+## Embedding Model
+The embedding model is trained to predict structural similarity by approximating TM-scores using cosine distances between embeddings. It consists of two main components:
+
+- **Protein Language Model (PLM)**: Computes residue-level embeddings from a given 3D structure.
+- **Residue Embedding Aggregator**: A transformer-based neural network that aggregates these residue-level embeddings into a single vector.
+
+![Embedding model architecture](assets/embedding-model-architecture.png)
+
+### **Protein Language Model (PLM)**
+Residue-wise embeddings of protein structures are computed using the [ESM3](https://www.evolutionaryscale.ai/) generative protein language model.
+
+### **Residue Embedding Aggregator**
+The aggregation component consists of six transformer encoder layers, each with a 3,072-neuron feedforward layer and ReLU activations. After processing through these layers, a summation pooling operation is applied, followed by 12 fully connected residual layers that refine the embeddings into a single 1,536-dimensional vector.
+
+---
+
+## How to Use the Model
+This repository provides the tools to compute embeddings for 3D macromolecular structure data.
+
+### **Installation**
+`pip install `
+
+### **Requirements**
+Ensure you have the following dependencies installed:
+- `python >= 3.10`
+- `esm`
+- `torch`
+
+### **Generating Residue Embeddings**
+ESM3 embeddings for the 3D structures can be calculated as:
+
+```python
+from rcsb_embedding_model import RcsbStructureEmbedding
+
+mmcif_file = "<path_to_file>/<name>.cif"
+model = RcsbStructureEmbedding()
+res_embedding = model.residue_embedding(
+    structure_src=mmcif_file,
+    format="mmcif",
+    chain_id='A'
+)
+```
+
+### **Generating Protein Structure**
+Protein 3D structure embedding can be calculated as:
+
+```python
+from rcsb_embedding_model import RcsbStructureEmbedding
+
+mmcif_file = "<path_to_file>/<name>.cif"
+model = RcsbStructureEmbedding()
+res_embedding = model.residue_embedding(
+    structure_src=mmcif_file,
+    format="mmcif",
+    chain_id='A'
+)
+structure_embedding = model.aggregator_embedding(
+    res_embedding
+)
+```
+
+### **Pretrained Model**
+You can download a pretrained Residue Embedding Aggregator model from [Hugging Face](https://huggingface.co/jseguramora/rcsb-embedding-model/resolve/main/rcsb-embedding-model.pt).
+
+---
+
+## Questions & Issues
+For any questions or comments, please open an issue on this repository.
+
+---
+
+## License
+This software is released under the BSD 3-Clause License. See the full license text below.
+
+### BSD 3-Clause License
+
+Copyright (c) 2024, RCSB Protein Data Bank, UC San Diego
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

rcsb_embedding_model-0.0.1/examples/esm_embeddings.py

@@ -0,0 +1,77 @@
+import argparse
+
+import torch
+from biotite.structure import chain_iter, get_residues, filter_amino_acids
+from biotite.structure.io.pdb import PDBFile
+from biotite.structure.io.pdbx import CIFFile, get_structure, BinaryCIFFile
+from esm.models.esm3 import ESM3, ESM3_OPEN_SMALL, ESM3InferenceClient
+from esm.sdk.api import ESMProtein, SamplingConfig
+from esm.utils.structure.protein_chain import ProteinChain
+
+
+def get_structure_from_file(file_name, format="pdb", chain_id=None):
+    try:
+        if format == "pdb":
+            structure = PDBFile.read(file_name).get_structure(
+                model=1
+            )
+        elif format == "mmcif":
+            cif_file = CIFFile.read(file_name)
+            structure = get_structure(
+                cif_file,
+                model=1,
+                use_author_fields=False
+            )
+        elif format == "binarycif":
+            cif_file = BinaryCIFFile.read(file_name)
+            structure = get_structure(
+                cif_file,
+                model=1,
+                use_author_fields=False
+            )
+
+        if chain_id:
+            structure = structure[structure.chain_id == chain_id]
+        return structure
+    except:
+        return None
+
+
+esm3_model = ESM3.from_pretrained(ESM3_OPEN_SMALL)
+
+
+def compute_embeddings(structure):
+    embedding_ch = []
+    for atom_ch in chain_iter(structure):
+        atom_res = atom_ch[filter_amino_acids(atom_ch)]
+        if len(atom_res) == 0 or len(get_residues(atom_res)[0]) < 10:
+            continue
+        protein_chain = ProteinChain.from_atomarray(atom_ch)
+        protein = ESMProtein.from_protein_chain(protein_chain)
+        protein_tensor = esm3_model.encode(protein)
+        embedding_ch.append( esm3_model.forward_and_sample(
+            protein_tensor, SamplingConfig(return_per_residue_embeddings=True)
+        ).per_residue_embedding)
+    return torch.cat(
+        embedding_ch,
+        dim=0
+    )
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--file', type=str, required=True)
+    parser.add_argument('--file_format', type=str)
+    parser.add_argument('--chain', type=str)
+    args = parser.parse_args()
+
+    structure = get_structure_from_file(
+        args.file,
+        "pdb" if not args.file_format else args.file_format,
+        chain_id=args.chain
+    )
+
+    embeddings = compute_embeddings(structure)
+
+    print(embeddings.shape)

rcsb_embedding_model-0.0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "rcsb-embedding-model"
+version = "0.0.1"
+authors = [
+    { name="Joan Segura", email="joan.segura@rcsb.org" },
+]
+description = "Protein Embedding Model for Structure Search"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "BSD-3-Clause"
+license-files = ["LICEN[CS]E*"]
+dependencies=[
+    "esm >= 3.2.0",
+    "torch >= 2.6.0"
+]
+[project.urls]
+Homepage = "https://github.com/rcsb/rcsb-embedding-model"
+Issues = "https://github.com/rcsb/rcsb-embedding-model/issues"
+
+[build-system]
+requires = [
+    "hatchling >= 1.14.1"
+]
+
+build-backend = "hatchling.build"

rcsb_embedding_model-0.0.1/src/rcsb_embedding_model/__init__.py

@@ -0,0 +1,4 @@
+
+from rcsb_embedding_model.rcsb_structure_embedding import RcsbStructureEmbedding
+
+__all__ = ["RcsbStructureEmbedding"]

rcsb_embedding_model-0.0.1/src/rcsb_embedding_model/model/layers.py

@@ -0,0 +1,28 @@
+
+import torch.nn as nn
+
+
+class ResBlock(nn.Module):
+    def __init__(self, in_dim, out_dim, dropout=0.1):
+        super().__init__()
+        if in_dim != out_dim:
+            self.residual = nn.Linear(in_dim, out_dim)
+        else:
+            self.residual = nn.Identity()
+
+        self.block = nn.Sequential(
+            nn.LayerNorm(in_dim),
+            nn.Dropout(p=dropout),
+            nn.Linear(in_dim, out_dim),
+            nn.ReLU(),
+            nn.LayerNorm(out_dim),
+            nn.Dropout(p=dropout),
+            nn.Linear(out_dim, out_dim),
+        )
+        self.activate = nn.ReLU()
+
+    def forward(self, x):
+        residual = self.residual(x)
+        x = self.block(x)
+        x = self.activate(x + residual)
+        return x

rcsb_embedding_model-0.0.1/src/rcsb_embedding_model/model/residue_embedding_aggregator.py

@@ -0,0 +1,53 @@
+
+import torch.nn as nn
+from collections import OrderedDict
+
+from rcsb_embedding_model.model.layers import ResBlock
+
+
+class ResidueEmbeddingAggregator(nn.Module):
+    dropout = 0.1
+
+    def __init__(
+            self,
+            input_features=1536,
+            dim_feedforward=3072,
+            hidden_layer=1536,
+            nhead=12,
+            num_layers=6,
+            res_block_layers=12
+    ):
+        super().__init__()
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=input_features,
+            nhead=nhead,
+            dim_feedforward=dim_feedforward,
+            dropout=self.dropout,
+            batch_first=True
+        )
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        if res_block_layers == 0:
+            self.embedding = nn.Sequential(OrderedDict([
+                ('norm', nn.LayerNorm(input_features)),
+                ('dropout', nn.Dropout(p=self.dropout)),
+                ('linear', nn.Linear(input_features, hidden_layer)),
+                ('activation', nn.ReLU())
+            ]))
+        else:
+            res_block = OrderedDict([(
+                f'block{i}',
+                ResBlock(input_features, hidden_layer, self.dropout)
+            ) for i in range(res_block_layers)])
+            res_block.update([
+                ('dropout', nn.Dropout(p=self.dropout)),
+                ('linear', nn.Linear(input_features, hidden_layer)),
+                ('activation', nn.ReLU())
+            ])
+            self.embedding = nn.Sequential(res_block)
+
+    def forward(self, x, x_mask=None):
+        if x.dim() == 2:
+            return self.embedding(self.transformer(x, src_key_padding_mask=x_mask).sum(dim=0))
+        if x.dim() == 3:
+            return self.embedding(self.transformer(x, src_key_padding_mask=x_mask).sum(dim=1))
+        raise RuntimeError("Tensor dimension error. Allowed shapes (batch, sequence, residue_embeddings) or (sequence, residue_embeddings)")

rcsb_embedding_model-0.0.1/src/rcsb_embedding_model/rcsb_structure_embedding.py

@@ -0,0 +1,148 @@
+import torch
+from biotite.structure import get_residues, chain_iter, filter_amino_acids
+from biotite.structure.io.pdb import PDBFile, get_structure as get_pdb_structure, get_assembly as get_pdb_assembly
+from biotite.structure.io.pdbx import CIFFile, get_structure, get_assembly, BinaryCIFFile
+from esm.models.esm3 import ESM3
+from esm.sdk.api import ESMProtein, SamplingConfig
+from esm.utils.constants.models import ESM3_OPEN_SMALL
+from esm.utils.structure.protein_chain import ProteinChain
+from huggingface_hub import hf_hub_download
+
+from rcsb_embedding_model.model.residue_embedding_aggregator import ResidueEmbeddingAggregator
+
+
+class RcsbStructureEmbedding:
+
+    MIN_RES = 10
+    REPO_ID = "rcsb/rcsb-embedding-model"
+    FILE_NAME = "rcsb-embedding-model.pt"
+    VERSION = "2d71cf6"
+
+    def __init__(self):
+        self.__residue_embedding = None
+        self.__aggregator_embedding = None
+
+    def load_models(self, device=None):
+        self.load_residue_embedding(device)
+        self.load_aggregator_embedding(device)
+
+    def load_residue_embedding(self, device=None):
+        if not device:
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.__residue_embedding = ESM3.from_pretrained(
+            ESM3_OPEN_SMALL,
+            device
+        )
+
+    def load_aggregator_embedding(self, device=None):
+        if not device:
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.__aggregator_embedding = _load_model(
+            _download_model(
+                RcsbStructureEmbedding.REPO_ID,
+                RcsbStructureEmbedding.FILE_NAME,
+                RcsbStructureEmbedding.VERSION
+            ),
+            device
+        )
+
+    def structure_embedding(self, structure_src, format="pdb", chain_id=None, assembly_id=None):
+        res_embedding = self.residue_embedding(structure_src, format, chain_id, assembly_id)
+        return self.aggregator_embedding(res_embedding)
+
+    def residue_embedding(self, structure_src, format="pdb", chain_id=None, assembly_id=None):
+        self.__check_residue_embedding()
+        structure = _get_structure_from_src(structure_src, format, chain_id, assembly_id)
+        embedding_ch = []
+        for atom_ch in chain_iter(structure):
+            atom_res = atom_ch[filter_amino_acids(atom_ch)]
+            if len(atom_res) == 0 or len(get_residues(atom_res)[0]) < RcsbStructureEmbedding.MIN_RES:
+                continue
+            protein_chain = ProteinChain.from_atomarray(atom_ch)
+            protein = ESMProtein.from_protein_chain(protein_chain)
+            protein_tensor = self.__residue_embedding.encode(protein)
+            embedding_ch.append(self.__residue_embedding.forward_and_sample(
+                protein_tensor, SamplingConfig(return_per_residue_embeddings=True)
+            ).per_residue_embedding)
+        return torch.cat(
+            embedding_ch,
+            dim=0
+        )
+
+    def aggregator_embedding(self, residue_embedding):
+        self.__check_aggregator_embedding()
+        return self.__aggregator_embedding(residue_embedding)
+
+    def __check_residue_embedding(self):
+        if self.__residue_embedding is None:
+            self.load_residue_embedding()
+
+    def __check_aggregator_embedding(self):
+        if self.__aggregator_embedding is None:
+            self.load_aggregator_embedding()
+
+
+def _get_structure_from_src(structure_src, format="pdb", chain_id=None, assembly_id=None):
+    if format == "pdb":
+        pdb_file = PDBFile.read(structure_src)
+        structure = _get_pdb_structure(pdb_file, assembly_id)
+    elif format == "mmcif":
+        cif_file = CIFFile.read(structure_src)
+        structure = _get_structure(cif_file, assembly_id)
+    elif format == "binarycif":
+        cif_file = BinaryCIFFile.read(structure_src)
+        structure = _get_structure(cif_file, assembly_id)
+    else:
+        raise RuntimeError(f"Unknown file format {format}")
+
+    if chain_id is not None:
+        structure = structure[structure.chain_id == chain_id]
+
+    return structure
+
+
+def _get_pdb_structure(pdb_file, assembly_id = None):
+    return get_pdb_structure(
+        pdb_file,
+        model=1
+    ) if assembly_id is None else get_pdb_assembly(
+        pdb_file,
+        assembly_id=assembly_id,
+        model=1
+    )
+
+
+def _get_structure(cif_file, assembly_id = None):
+    return get_structure(
+        cif_file,
+        model=1,
+        use_author_fields=False
+    ) if assembly_id is None else get_assembly(
+        cif_file,
+        assembly_id=assembly_id,
+        model=1,
+        use_author_fields=False
+    )
+
+
+def _download_model(
+        repo_id,
+        filename,
+        revision
+):
+    return hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        revision=revision
+    )
+
+
+def _load_model(model_path, device=None):
+    if not device:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    weights = torch.load(model_path, weights_only=True, map_location=device)
+    aggregator_model = ResidueEmbeddingAggregator()
+    aggregator_model.load_state_dict(weights)
+    aggregator_model.to(device)
+    aggregator_model.eval()
+    return aggregator_model