cgcnn2 0.1.0__tar.gz

cgcnn2-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: cgcnn2
+Version: 0.1.0
+Summary: Crystal Graph Convolutional Neural Networks
+Home-page: https://github.com/jcwang587/cgcnn2/
+License: MIT
+Keywords: python,gnn,vasp,crystal
+Author: Jiacheng Wang
+Author-email: jiachengwang@umass.edu
+Maintainer: Jiacheng Wang
+Requires-Python: >=3.10,<3.12
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: ase (==3.23.0)
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pymatgen (==2024.10.3)
+Requires-Dist: pymatviz (==0.13.2)
+Requires-Dist: scikit-learn
+Requires-Dist: torch (==2.5.1)
+Project-URL: Repository, https://github.com/jcwang587/cgcnn2/
+Description-Content-Type: text/markdown
+
+# CGCNN2
+
+As the original Crystal Graph Convolutional Neural Networks (CGCNN) repository is no longer actively maintained, this repository is a reproduction of [CGCNN](https://github.com/txie-93/cgcnn) by Xie et al. It includes necessary updates for deprecated components and a few additional functions to ensure smooth operation. Despite its age, CGCNN remains a straightforward and fast deep learning framework that is easy to learn and use.
+
+The package provides following major functions:
+
+- **Training** a CGCNN model with a customized dataset.
+- **Predicting** material properties with a pre-trained CGCNN model.
+- **Fine-tuning** a pre-trained CGCNN model on a new dataset.
+
+## Installation
+
+Make sure you have a Python interpreter, preferably version 3.10 or higher. Then, you can simply install xdatbus from
+PyPI using `pip`:
+
+```bash
+pip install cgcnn2
+```
+
+If you'd like to use the latest unreleased version on the main branch, you can install it directly from GitHub:
+
+```bash
+pip install git+https://github.com/jcwang587/cgcnn2
+```
+
+## References
+
+The original paper describes the details of the CGCNN framework:
+
+```bibtex
+@article{PhysRevLett.120.145301,
+  title = {Crystal Graph Convolutional Neural Networks for an Accurate and Interpretable Prediction of Material Properties},
+  author = {Xie, Tian and Grossman, Jeffrey C.},
+  journal = {Phys. Rev. Lett.},
+  volume = {120},
+  issue = {14},
+  pages = {145301},
+  numpages = {6},
+  year = {2018},
+  month = {Apr},
+  publisher = {American Physical Society},
+  doi = {10.1103/PhysRevLett.120.145301},
+  url = {https://link.aps.org/doi/10.1103/PhysRevLett.120.145301}
+}
+```
+

cgcnn2-0.1.0/README.md

@@ -0,0 +1,45 @@
+# CGCNN2
+
+As the original Crystal Graph Convolutional Neural Networks (CGCNN) repository is no longer actively maintained, this repository is a reproduction of [CGCNN](https://github.com/txie-93/cgcnn) by Xie et al. It includes necessary updates for deprecated components and a few additional functions to ensure smooth operation. Despite its age, CGCNN remains a straightforward and fast deep learning framework that is easy to learn and use.
+
+The package provides following major functions:
+
+- **Training** a CGCNN model with a customized dataset.
+- **Predicting** material properties with a pre-trained CGCNN model.
+- **Fine-tuning** a pre-trained CGCNN model on a new dataset.
+
+## Installation
+
+Make sure you have a Python interpreter, preferably version 3.10 or higher. Then, you can simply install xdatbus from
+PyPI using `pip`:
+
+```bash
+pip install cgcnn2
+```
+
+If you'd like to use the latest unreleased version on the main branch, you can install it directly from GitHub:
+
+```bash
+pip install git+https://github.com/jcwang587/cgcnn2
+```
+
+## References
+
+The original paper describes the details of the CGCNN framework:
+
+```bibtex
+@article{PhysRevLett.120.145301,
+  title = {Crystal Graph Convolutional Neural Networks for an Accurate and Interpretable Prediction of Material Properties},
+  author = {Xie, Tian and Grossman, Jeffrey C.},
+  journal = {Phys. Rev. Lett.},
+  volume = {120},
+  issue = {14},
+  pages = {145301},
+  numpages = {6},
+  year = {2018},
+  month = {Apr},
+  publisher = {American Physical Society},
+  doi = {10.1103/PhysRevLett.120.145301},
+  url = {https://link.aps.org/doi/10.1103/PhysRevLett.120.145301}
+}
+```

cgcnn2-0.1.0/cgcnn2/__init__.py

@@ -0,0 +1,3 @@
+from .cgcnn_data import *
+from .cgcnn_model import *
+from .cgcnn_utils import *

cgcnn2-0.1.0/cgcnn2/cgcnn_data.py

@@ -0,0 +1,392 @@
+import csv
+import functools
+import json
+import os
+import random
+import warnings
+
+import numpy as np
+import torch
+from pymatgen.core.structure import Structure
+from torch.utils.data import Dataset
+
+
+def collate_pool(dataset_list):
+    """
+    Collate a list of data and return a batch for predicting crystal
+    properties.
+
+    Parameters
+    ----------
+
+    dataset_list: list of tuples for each data point.
+      (atom_fea, nbr_fea, nbr_fea_idx, target)
+
+      atom_fea: torch.Tensor shape (n_i, atom_fea_len)
+      nbr_fea: torch.Tensor shape (n_i, M, nbr_fea_len)
+      nbr_fea_idx: torch.LongTensor shape (n_i, M)
+      target: torch.Tensor shape (1, )
+      cif_id: str or int
+
+    Returns
+    -------
+    N = sum(n_i); N0 = sum(i)
+
+    batch_atom_fea: torch.Tensor shape (N, orig_atom_fea_len)
+      Atom features from atom type
+    batch_nbr_fea: torch.Tensor shape (N, M, nbr_fea_len)
+      Bond features of each atom's M neighbors
+    batch_nbr_fea_idx: torch.LongTensor shape (N, M)
+      Indices of M neighbors of each atom
+    crystal_atom_idx: list of torch.LongTensor of length N0
+      Mapping from the crystal idx to atom idx
+    target: torch.Tensor shape (N, 1)
+      Target value for prediction
+    batch_cif_ids: list
+    """
+    batch_atom_fea, batch_nbr_fea, batch_nbr_fea_idx = [], [], []
+    crystal_atom_idx, batch_target = [], []
+    batch_cif_ids = []
+    base_idx = 0
+    for i, ((atom_fea, nbr_fea, nbr_fea_idx), target, cif_id) in enumerate(
+        dataset_list
+    ):
+        n_i = atom_fea.shape[0]  # number of atoms for this crystal
+        batch_atom_fea.append(atom_fea)
+        batch_nbr_fea.append(nbr_fea)
+        batch_nbr_fea_idx.append(nbr_fea_idx + base_idx)
+        new_idx = torch.LongTensor(np.arange(n_i) + base_idx)
+        crystal_atom_idx.append(new_idx)
+        batch_target.append(target)
+        batch_cif_ids.append(cif_id)
+        base_idx += n_i
+    return (
+        (
+            torch.cat(batch_atom_fea, dim=0),
+            torch.cat(batch_nbr_fea, dim=0),
+            torch.cat(batch_nbr_fea_idx, dim=0),
+            crystal_atom_idx,
+        ),
+        torch.stack(batch_target, dim=0),
+        batch_cif_ids,
+    )
+
+
+class GaussianDistance(object):
+    """
+    Expands the distance by Gaussian basis.
+
+    Unit: angstrom
+    """
+
+    def __init__(self, dmin, dmax, step, var=None):
+        """
+        Parameters
+        ----------
+
+        dmin: float
+          Minimum interatomic distance
+        dmax: float
+          Maximum interatomic distance
+        step: float
+          Step size for the Gaussian filter
+        """
+        assert dmin < dmax
+        assert dmax - dmin > step
+        self.filter = np.arange(dmin, dmax + step, step)
+        if var is None:
+            var = step
+        self.var = var
+
+    def expand(self, distances):
+        """
+        Apply Gaussian distance filter to a numpy distance array
+
+        Parameters
+        ----------
+
+        distances: np.ndarray
+          A distance matrix of any shape
+
+        Returns
+        -------
+        expanded_distance: shape (n+1)-d array
+          Expanded distance matrix with the last dimension of length
+          len(self.filter)
+        """
+        return np.exp(-((distances[..., np.newaxis] - self.filter) ** 2) / self.var**2)
+
+
+class AtomInitializer(object):
+    """
+    Base class for initializing the vector representation for atoms.
+
+    !!! Use one AtomInitializer per dataset !!!
+    """
+
+    def __init__(self, atom_types):
+        self.atom_types = set(atom_types)
+        self._embedding = {}
+
+    def get_atom_fea(self, atom_type):
+        assert atom_type in self.atom_types
+        return self._embedding[atom_type]
+
+    def load_state_dict(self, state_dict):
+        self._embedding = state_dict
+        self.atom_types = set(self._embedding.keys())
+        self._decodedict = {
+            idx: atom_type for atom_type, idx in self._embedding.items()
+        }
+
+    def state_dict(self):
+        return self._embedding
+
+    def decode(self, idx):
+        if not hasattr(self, "_decodedict"):
+            self._decodedict = {
+                idx: atom_type for atom_type, idx in self._embedding.items()
+            }
+        return self._decodedict[idx]
+
+
+class AtomCustomJSONInitializer(AtomInitializer):
+    """
+    Initialize atom feature vectors using a JSON file, which is a python
+    dictionary mapping from element number to a list representing the
+    feature vector of the element.
+
+    Parameters
+    ----------
+
+    elem_embedding_file: str
+        The path to the .json file
+    """
+
+    def __init__(self, elem_embedding_file):
+        with open(elem_embedding_file) as f:
+            elem_embedding = json.load(f)
+        elem_embedding = {int(key): value for key, value in elem_embedding.items()}
+        atom_types = set(elem_embedding.keys())
+        super(AtomCustomJSONInitializer, self).__init__(atom_types)
+        for key, value in elem_embedding.items():
+            self._embedding[key] = np.array(value, dtype=float)
+
+
+class CIFData(Dataset):
+    """
+    The CIFData dataset is a wrapper for a dataset where the crystal structures
+    are stored in the form of CIF files. The dataset should have the following
+    directory structure:
+
+    root_dir
+    ├── id_prop.csv
+    ├── atom_init.json
+    ├── id0.cif
+    ├── id1.cif
+    ├── ...
+
+    id_prop.csv: a CSV file with two columns. The first column recodes a
+    unique ID for each crystal, and the second column recodes the value of
+    target property.
+
+    atom_init.json: a JSON file that stores the initialization vector for each
+    element.
+
+    ID.cif: a CIF file that recodes the crystal structure, where ID is the
+    unique ID for the crystal.
+
+    Parameters
+    ----------
+
+    root_dir: str
+        The path to the root directory of the dataset
+    max_num_nbr: int
+        The maximum number of neighbors while constructing the crystal graph
+    radius: float
+        The cutoff radius for searching neighbors
+    dmin: float
+        The minimum distance for constructing GaussianDistance
+    step: float
+        The step size for constructing GaussianDistance
+    random_seed: int
+        Random seed for shuffling the dataset
+
+    Returns
+    -------
+
+    atom_fea: torch.Tensor shape (n_i, atom_fea_len)
+    nbr_fea: torch.Tensor shape (n_i, M, nbr_fea_len)
+    nbr_fea_idx: torch.LongTensor shape (n_i, M)
+    target: torch.Tensor shape (1, )
+    cif_id: str or int
+    """
+
+    def __init__(
+        self, root_dir, max_num_nbr=12, radius=8, dmin=0, step=0.2, random_seed=123
+    ):
+        self.root_dir = root_dir
+        self.max_num_nbr, self.radius = max_num_nbr, radius
+        assert os.path.exists(root_dir), "root_dir does not exist!"
+        id_prop_file = os.path.join(self.root_dir, "id_prop.csv")
+        assert os.path.exists(id_prop_file), "id_prop.csv does not exist!"
+        with open(id_prop_file) as f:
+            reader = csv.reader(f)
+            self.id_prop_data = [row for row in reader]
+        random.seed(random_seed)
+        random.shuffle(self.id_prop_data)
+        atom_init_file = os.path.join(self.root_dir, "atom_init.json")
+        assert os.path.exists(atom_init_file), "atom_init.json does not exist!"
+        self.ari = AtomCustomJSONInitializer(atom_init_file)
+        self.gdf = GaussianDistance(dmin=dmin, dmax=self.radius, step=step)
+
+    def __len__(self):
+        return len(self.id_prop_data)
+
+    @functools.lru_cache(maxsize=None)  # Cache loaded structures
+    def __getitem__(self, idx):
+        cif_id, target = self.id_prop_data[idx]
+        crystal = Structure.from_file(os.path.join(self.root_dir, cif_id + ".cif"))
+        atom_fea = np.vstack(
+            [
+                self.ari.get_atom_fea(crystal[i].specie.number)
+                for i in range(len(crystal))
+            ]
+        )
+        atom_fea = torch.Tensor(atom_fea)
+        all_nbrs = crystal.get_all_neighbors(self.radius, include_index=True)
+        all_nbrs = [sorted(nbrs, key=lambda x: x[1]) for nbrs in all_nbrs]
+        nbr_fea_idx, nbr_fea = [], []
+        for nbr in all_nbrs:
+            if len(nbr) < self.max_num_nbr:
+                warnings.warn(
+                    "{} not find enough neighbors to build graph. "
+                    "If it happens frequently, consider increase "
+                    "radius.".format(cif_id)
+                )
+                nbr_fea_idx.append(
+                    list(map(lambda x: x[2], nbr)) + [0] * (self.max_num_nbr - len(nbr))
+                )
+                nbr_fea.append(
+                    list(map(lambda x: x[1], nbr))
+                    + [self.radius + 1.0] * (self.max_num_nbr - len(nbr))
+                )
+            else:
+                nbr_fea_idx.append(list(map(lambda x: x[2], nbr[: self.max_num_nbr])))
+                nbr_fea.append(list(map(lambda x: x[1], nbr[: self.max_num_nbr])))
+        nbr_fea_idx, nbr_fea = np.array(nbr_fea_idx), np.array(nbr_fea)
+        nbr_fea = self.gdf.expand(nbr_fea)
+        atom_fea = torch.Tensor(atom_fea)
+        nbr_fea = torch.Tensor(nbr_fea)
+        nbr_fea_idx = torch.LongTensor(nbr_fea_idx)
+        target = torch.Tensor([float(target)])
+        return (atom_fea, nbr_fea, nbr_fea_idx), target, cif_id
+
+
+class CIFData_pred(Dataset):
+    """
+    The CIFData dataset is a wrapper for a dataset where the crystal structures
+    are stored in the form of CIF files. The dataset should have the following
+    directory structure:
+
+    root_dir
+    ├── id_prop.csv
+    ├── atom_init.json
+    ├── id0.cif
+    ├── id1.cif
+    ├── ...
+
+    id_prop.csv: a CSV file with two columns. The first column recodes a
+    unique ID for each crystal, and the second column recodes the value of
+    target property.
+
+    atom_init.json: a JSON file that stores the initialization vector for each
+    element.
+
+    ID.cif: a CIF file that recodes the crystal structure, where ID is the
+    unique ID for the crystal.
+
+    Parameters
+    ----------
+
+    root_dir: str
+        The path to the root directory of the dataset
+    max_num_nbr: int
+        The maximum number of neighbors while constructing the crystal graph
+    radius: float
+        The cutoff radius for searching neighbors
+    dmin: float
+        The minimum distance for constructing GaussianDistance
+    step: float
+        The step size for constructing GaussianDistance
+    random_seed: int
+        Random seed for shuffling the dataset
+
+    Returns
+    -------
+
+    atom_fea: torch.Tensor shape (n_i, atom_fea_len)
+    nbr_fea: torch.Tensor shape (n_i, M, nbr_fea_len)
+    nbr_fea_idx: torch.LongTensor shape (n_i, M)
+    target: torch.Tensor shape (1, )
+    cif_id: str or int
+    """
+
+    def __init__(
+        self, root_dir, max_num_nbr=12, radius=8, dmin=0, step=0.2, random_seed=123
+    ):
+        self.root_dir = root_dir
+        self.max_num_nbr, self.radius = max_num_nbr, radius
+        assert os.path.exists(root_dir), "root_dir does not exist!"
+        id_prop_file = os.path.join(self.root_dir, "id_prop.csv")
+        assert os.path.exists(id_prop_file), "id_prop.csv does not exist!"
+        with open(id_prop_file) as f:
+            reader = csv.reader(f)
+            self.id_prop_data = [row for row in reader]
+        random.seed(random_seed)
+        atom_init_file = os.path.join(self.root_dir, "atom_init.json")
+        assert os.path.exists(atom_init_file), "atom_init.json does not exist!"
+        self.ari = AtomCustomJSONInitializer(atom_init_file)
+        self.gdf = GaussianDistance(dmin=dmin, dmax=self.radius, step=step)
+
+    def __len__(self):
+        return len(self.id_prop_data)
+
+    @functools.lru_cache(maxsize=None)  # Cache loaded structures
+    def __getitem__(self, idx):
+        cif_id, target = self.id_prop_data[idx]
+        crystal = Structure.from_file(os.path.join(self.root_dir, cif_id + ".cif"))
+        atom_fea = np.vstack(
+            [
+                self.ari.get_atom_fea(crystal[i].specie.number)
+                for i in range(len(crystal))
+            ]
+        )
+        atom_fea = torch.Tensor(atom_fea)
+        all_nbrs = crystal.get_all_neighbors(self.radius, include_index=True)
+        all_nbrs = [sorted(nbrs, key=lambda x: x[1]) for nbrs in all_nbrs]
+        nbr_fea_idx, nbr_fea = [], []
+        for nbr in all_nbrs:
+            if len(nbr) < self.max_num_nbr:
+                warnings.warn(
+                    "{} not find enough neighbors to build graph. "
+                    "If it happens frequently, consider increase "
+                    "radius.".format(cif_id)
+                )
+                nbr_fea_idx.append(
+                    list(map(lambda x: x[2], nbr)) + [0] * (self.max_num_nbr - len(nbr))
+                )
+                nbr_fea.append(
+                    list(map(lambda x: x[1], nbr))
+                    + [self.radius + 1.0] * (self.max_num_nbr - len(nbr))
+                )
+            else:
+                nbr_fea_idx.append(list(map(lambda x: x[2], nbr[: self.max_num_nbr])))
+                nbr_fea.append(list(map(lambda x: x[1], nbr[: self.max_num_nbr])))
+        nbr_fea_idx, nbr_fea = np.array(nbr_fea_idx), np.array(nbr_fea)
+        nbr_fea = self.gdf.expand(nbr_fea)
+        atom_fea = torch.Tensor(atom_fea)
+        nbr_fea = torch.Tensor(nbr_fea)
+        nbr_fea_idx = torch.LongTensor(nbr_fea_idx)
+        target = torch.Tensor([float(target)])
+        return (atom_fea, nbr_fea, nbr_fea_idx), target, cif_id

cgcnn2-0.1.0/cgcnn2/cgcnn_model.py

@@ -0,0 +1,372 @@
+"""
+This module implements the Crystal Graph Convolutional Neural Network (CGCNN) for predicting
+material properties based on their crystal structures.
+
+Classes:
+    ConvLayer: Convolutional layer for graph data.
+    MaskedConvLayer: Convolutional layer with masking for padding indices.
+    CrystalGraphConvNet: CGCNN model for predicting material properties.
+    Normalizer: Utility class for normalizing tensors.
+
+Usage:
+    Define your model by creating an instance of CrystalGraphConvNet with the desired parameters.
+    Use the Normalizer class to normalize your target properties during training.
+"""
+
+import torch
+import torch.nn as nn
+from typing import List, Dict, Tuple
+
+
+class ConvLayer(nn.Module):
+    """
+    Convolutional layer for graph data.
+
+    Performs a convolutional operation on graphs, updating atom features based on their neighbors.
+    """
+
+    def __init__(self, atom_fea_len, nbr_fea_len):
+        """
+        Initialize the ConvLayer.
+
+        Args:
+            atom_feature_len (int): Number of atom hidden features.
+            neighbor_feature_len (int): Number of bond (neighbor) features.
+        """
+        super(ConvLayer, self).__init__()
+        self.atom_fea_len = atom_fea_len
+        self.nbr_fea_len = nbr_fea_len
+        self.fc_full = nn.Linear(
+            2 * self.atom_fea_len + self.nbr_fea_len, 2 * self.atom_fea_len
+        )
+        self.sigmoid = nn.Sigmoid()
+        self.softplus1 = nn.Softplus()
+        self.bn1 = nn.BatchNorm1d(2 * self.atom_fea_len)
+        self.bn2 = nn.BatchNorm1d(self.atom_fea_len)
+        self.softplus2 = nn.Softplus()
+
+    def forward(self, atom_in_fea, nbr_fea, nbr_fea_idx):
+        """
+        Forward pass
+
+        N: Total number of atoms in the batch
+        M: Max number of neighbors
+
+        Parameters
+        ----------
+
+        atom_in_fea: Variable(torch.Tensor) shape (N, atom_fea_len)
+          Atom hidden features before convolution
+        nbr_fea: Variable(torch.Tensor) shape (N, M, nbr_fea_len)
+          Bond features of each atom's M neighbors
+        nbr_fea_idx: torch.LongTensor shape (N, M)
+          Indices of M neighbors of each atom
+
+        Returns
+        -------
+
+        atom_out_fea: nn.Variable shape (N, atom_fea_len)
+          Atom hidden features after convolution
+
+        """
+        N, M = nbr_fea_idx.shape
+        # convolution
+        atom_nbr_fea = atom_in_fea[nbr_fea_idx, :]
+        total_nbr_fea = torch.cat(
+            [
+                atom_in_fea.unsqueeze(1).expand(N, M, self.atom_fea_len),
+                atom_nbr_fea,
+                nbr_fea,
+            ],
+            dim=2,
+        )
+        total_gated_fea = self.fc_full(total_nbr_fea)
+        total_gated_fea = self.bn1(
+            total_gated_fea.view(-1, self.atom_fea_len * 2)
+        ).view(N, M, self.atom_fea_len * 2)
+        nbr_filter, nbr_core = total_gated_fea.chunk(2, dim=2)
+        nbr_filter = self.sigmoid(nbr_filter)
+        nbr_core = self.softplus1(nbr_core)
+        nbr_sumed = torch.sum(nbr_filter * nbr_core, dim=1)
+        nbr_sumed = self.bn2(nbr_sumed)
+        out = self.softplus2(atom_in_fea + nbr_sumed)
+        return out
+
+
+class MaskedConvLayer(nn.Module):
+    """
+    Convolutional operation on graphs
+    """
+
+    def __init__(self, atom_fea_len, nbr_fea_len):
+        """
+        Initialize ConvLayer.
+
+        Parameters
+        ----------
+
+        atom_fea_len: int
+          Number of atom hidden features.
+        nbr_fea_len: int
+          Number of bond features.
+        """
+        super(MaskedConvLayer, self).__init__()
+        self.atom_fea_len = atom_fea_len
+        self.nbr_fea_len = nbr_fea_len
+        self.fc_full = nn.Linear(
+            2 * self.atom_fea_len + self.nbr_fea_len, 2 * self.atom_fea_len
+        )
+        self.sigmoid = nn.Sigmoid()
+        self.softplus1 = nn.Softplus()
+        self.bn1 = nn.BatchNorm1d(2 * self.atom_fea_len)
+        self.bn2 = nn.BatchNorm1d(self.atom_fea_len)
+        self.softplus2 = nn.Softplus()
+
+    def forward(self, atom_in_fea, nbr_fea, nbr_fea_idx):
+        """
+        Forward pass
+
+        N: Total number of atoms in the batch
+        M: Max number of neighbors
+
+        Parameters
+        ----------
+
+        atom_in_fea: Variable(torch.Tensor) shape (N, atom_fea_len)
+          Atom hidden features before convolution
+        nbr_fea: Variable(torch.Tensor) shape (N, M, nbr_fea_len)
+          Bond features of each atom's M neighbors
+        nbr_fea_idx: torch.LongTensor shape (N, M)
+          Indices of M neighbors of each atom
+
+        Returns
+        -------
+
+        atom_out_fea: nn.Variable shape (N, atom_fea_len)
+          Atom hidden features after convolution
+
+        """
+        N, M = nbr_fea_idx.shape
+        # Create a mask for valid neighbor indices
+        mask = nbr_fea_idx != 0  # Shape: (N, M)
+        # Get neighbor atom features
+        atom_nbr_fea = atom_in_fea[nbr_fea_idx, :]  # Shape: (N, M, atom_fea_len)
+        # Zero out features corresponding to padding indices
+        mask = mask.unsqueeze(-1).float()
+        atom_nbr_fea = atom_nbr_fea * mask
+        nbr_fea = nbr_fea * mask
+        # Continue with your original code
+        total_nbr_fea = torch.cat(
+            [
+                atom_in_fea.unsqueeze(1).expand(N, M, self.atom_fea_len),
+                atom_nbr_fea,
+                nbr_fea,
+            ],
+            dim=2,
+        )
+        total_gated_fea = self.fc_full(total_nbr_fea)
+        total_gated_fea = self.bn1(
+            total_gated_fea.view(-1, self.atom_fea_len * 2)
+        ).view(N, M, self.atom_fea_len * 2)
+        nbr_filter, nbr_core = total_gated_fea.chunk(2, dim=2)
+        nbr_filter = self.sigmoid(nbr_filter)
+        nbr_core = self.softplus1(nbr_core)
+        # Zero out contributions from padding indices
+        nbr_filter = nbr_filter * mask
+        nbr_core = nbr_core * mask
+        nbr_sumed = torch.sum(nbr_filter * nbr_core, dim=1)
+        nbr_sumed = self.bn2(nbr_sumed)
+        out = self.softplus2(atom_in_fea + nbr_sumed)
+        return out
+
+
+class CrystalGraphConvNet(nn.Module):
+    """
+    Create a crystal graph convolutional neural network for predicting total
+    material properties.
+    """
+
+    def __init__(
+            self,
+            orig_atom_fea_len,
+            nbr_fea_len,
+            atom_fea_len=64,
+            n_conv=3,
+            h_fea_len=128,
+            n_h=1,
+            classification=False,
+    ):
+        """
+        Initialize CrystalGraphConvNet.
+
+        Parameters
+        ----------
+
+        orig_atom_fea_len: int
+          Number of atom features in the input.
+        nbr_fea_len: int
+          Number of bond features.
+        atom_fea_len: int
+          Number of hidden atom features in the convolutional layers
+        n_conv: int
+          Number of convolutional layers
+        h_fea_len: int
+          Number of hidden features after pooling
+        n_h: int
+          Number of hidden layers after pooling
+        """
+        super(CrystalGraphConvNet, self).__init__()
+        self.classification = classification
+        self.embedding = nn.Linear(orig_atom_fea_len, atom_fea_len)
+        self.convs = nn.ModuleList(
+            [
+                ConvLayer(atom_fea_len=atom_fea_len, nbr_fea_len=nbr_fea_len)
+                for _ in range(n_conv)
+            ]
+        )
+        self.conv_to_fc = nn.Linear(atom_fea_len, h_fea_len)
+        self.conv_to_fc_softplus = nn.Softplus()
+        if n_h > 1:
+            self.fcs = nn.ModuleList(
+                [nn.Linear(h_fea_len, h_fea_len) for _ in range(n_h - 1)]
+            )
+            self.softpluses = nn.ModuleList([nn.Softplus() for _ in range(n_h - 1)])
+
+        if self.classification:
+            self.fc_out = nn.Linear(h_fea_len, 2)
+        else:
+            self.fc_out = nn.Linear(h_fea_len, 1)
+
+        if self.classification:
+            self.logsoftmax = nn.LogSoftmax(dim=1)
+            self.dropout = nn.Dropout()
+
+    def forward(self, atom_fea, nbr_fea, nbr_fea_idx, crystal_atom_idx):
+        """
+        Forward pass
+
+        N: Total number of atoms in the batch
+        M: Max number of neighbors
+        N0: Total number of crystals in the batch
+
+        Parameters
+        ----------
+
+        atom_fea: Variable(torch.Tensor) shape (N, orig_atom_fea_len)
+          Atom features from atom type
+        nbr_fea: Variable(torch.Tensor) shape (N, M, nbr_fea_len)
+          Bond features of each atom's M neighbors
+        nbr_fea_idx: torch.LongTensor shape (N, M)
+          Indices of M neighbors of each atom
+        crystal_atom_idx: list of torch.LongTensor of length N0
+          Mapping from the crystal idx to atom idx
+
+        Returns
+        -------
+
+        prediction: nn.Variable shape (N, )
+          Atom hidden features after convolution
+
+        """
+        atom_fea = self.embedding(atom_fea)
+        for conv_func in self.convs:
+            atom_fea = conv_func(atom_fea, nbr_fea, nbr_fea_idx)
+        crys_fea = self.pooling(atom_fea, crystal_atom_idx)
+        crys_fea = self.conv_to_fc(self.conv_to_fc_softplus(crys_fea))
+        crys_fea = self.conv_to_fc_softplus(crys_fea)
+        if self.classification:
+            crys_fea = self.dropout(crys_fea)
+        if hasattr(self, "fcs") and hasattr(self, "softpluses"):
+            for fc, softplus in zip(self.fcs, self.softpluses):
+                crys_fea = softplus(fc(crys_fea))
+        out = self.fc_out(crys_fea)
+        if self.classification:
+            out = self.logsoftmax(out)
+        return out, crys_fea
+
+    def pooling(self, atom_fea, crystal_atom_idx):
+        """
+        Pooling the atom features to crystal features
+
+        N: Total number of atoms in the batch
+        N0: Total number of crystals in the batch
+
+        Parameters
+        ----------
+
+        atom_fea: Variable(torch.Tensor) shape (N, atom_fea_len)
+          Atom feature vectors of the batch
+        crystal_atom_idx: list of torch.LongTensor of length N0
+          Mapping from the crystal idx to atom idx
+        """
+        assert (
+                sum([len(idx_map) for idx_map in crystal_atom_idx])
+                == atom_fea.data.shape[0]
+        )
+        summed_fea = [
+            torch.mean(atom_fea[idx_map], dim=0, keepdim=True)
+            for idx_map in crystal_atom_idx
+        ]
+        return torch.cat(summed_fea, dim=0)
+
+
+class Normalizer:
+    """
+    Normalizes a PyTorch tensor and allows restoring it later.
+
+    This class keeps track of the mean and standard deviation of a tensor and provides methods
+    to normalize and denormalize tensors using these statistics.
+    """
+
+    def __init__(self, tensor: torch.Tensor):
+        """
+        Initialize the Normalizer with a sample tensor to calculate mean and standard deviation.
+
+        Args:
+            tensor (torch.Tensor): Sample tensor to compute mean and standard deviation.
+        """
+        self.mean: torch.Tensor = torch.mean(tensor)
+        self.std: torch.Tensor = torch.std(tensor)
+
+    def norm(self, tensor: torch.Tensor) -> torch.Tensor:
+        """
+        Normalize a tensor using the stored mean and standard deviation.
+
+        Args:
+            tensor (torch.Tensor): Tensor to normalize.
+
+        Returns:
+            torch.Tensor: Normalized tensor.
+        """
+        return (tensor - self.mean) / self.std
+
+    def denorm(self, normed_tensor: torch.Tensor) -> torch.Tensor:
+        """
+        Denormalize a tensor using the stored mean and standard deviation.
+
+        Args:
+            normed_tensor (torch.Tensor): Normalized tensor to denormalize.
+
+        Returns:
+            torch.Tensor: Denormalized tensor.
+        """
+        return normed_tensor * self.std + self.mean
+
+    def state_dict(self) -> Dict[str, torch.Tensor]:
+        """
+        Returns the state dictionary containing the mean and standard deviation.
+
+        Returns:
+            Dict[str, torch.Tensor]: State dictionary.
+        """
+        return {"mean": self.mean, "std": self.std}
+
+    def load_state_dict(self, state_dict: Dict[str, torch.Tensor]):
+        """
+        Loads the mean and standard deviation from a state dictionary.
+
+        Args:
+            state_dict (Dict[str, torch.Tensor]): State dictionary containing 'mean' and 'std'.
+        """
+        self.mean = state_dict["mean"]
+        self.std = state_dict["std"]

cgcnn2-0.1.0/cgcnn2/cgcnn_utils.py

@@ -0,0 +1,474 @@
+import os
+import csv
+import sys
+import glob
+import torch
+import argparse
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from datetime import datetime
+from sklearn.metrics import mean_squared_error, r2_score
+from pymatviz import density_hexbin
+
+from torch.utils.data import DataLoader
+from .cgcnn_data import CIFData_pred, collate_pool
+from .cgcnn_model import CrystalGraphConvNet, Normalizer
+
+
+def output_id_gen():
+    """
+    This function obtains the current date and time, formats it as 'mmdd_HHMM',
+    and prepends 'output_' to form a unique identifier. This can be useful
+    for creating distinct output folder names or filenames at runtime.
+
+    Returns:
+        - str: A string that represents the current date and time in the format of 'output_mmdd_HHMM'.
+    """
+
+    now = datetime.now()
+    # Format time to match desired format (mmdd_HHMM)
+    timestamp = now.strftime("%m%d_%H%M")
+    # Prepend 'output_' to timestamp to form folder name
+    folder_name = f"output_{timestamp}"
+
+    return folder_name
+
+
+def get_lr(optimizer):
+    """
+    This function iterates over the parameter groups of a given PyTorch optimizer,
+    extracting the learning rate from each group. The learning rates are then returned in a list.
+
+    Parameters:
+        - optimizer (torch.optim.Optimizer): The PyTorch optimizer to extract learning rates from.
+
+    Returns:
+        - list: A list of learning rates, one for each parameter group in the optimizer.
+    """
+
+    return [param_group["lr"] for param_group in optimizer.param_groups]
+
+
+def extract_fea(model, loader, device):
+    """
+    Applies a trained model to a dataset to extract learned feature
+    representations, targets, and CIF IDs, returning these as tensors.
+
+    Parameters:
+        - model (torch.nn.Module): The trained model.
+        - loader (torch.utils.data.DataLoader): DataLoader for the dataset.
+        - device (str): The device ('cuda' or 'cpu') to send tensors to.
+
+    Returns:
+        - tuple (torch.Tensor, torch.Tensor, list): A tuple where the first element is
+        the tensor of extracted features, the second element is the tensor of targets,
+        and the third is a list of CIF IDs.
+    """
+
+    crys_fea_list, target_list, cif_id_list = [], [], []
+
+    with torch.no_grad():
+        for inputs, target, cif_id in loader:
+            inputs = [
+                item.to(device) if torch.is_tensor(item) else item for item in inputs
+            ]
+            target = target.to(device)
+
+            _, crys_fea = model(*inputs)
+
+            crys_fea_list.append(crys_fea)
+            target_list.append(target)
+            cif_id_list.append(cif_id)
+
+    crys_fea = torch.cat(crys_fea_list, dim=0)
+    target = torch.cat(target_list, dim=0)
+
+    return crys_fea, target, cif_id_list
+
+
+def id_prop_gen(cif_dir):
+    cif_list = glob.glob(f"{cif_dir}/*.cif")
+
+    id_prop_cif = pd.DataFrame(
+        {
+            "id": [
+                os.path.basename(cif).split(".")[0] for cif in cif_list
+            ],
+            "prop": [0 for _ in range(len(cif_list))],
+        }
+    )
+
+    id_prop_cif.to_csv(
+        f"{cif_dir}/id_prop.csv",
+        index=False,
+        header=False,
+    )
+
+
+def test_model(
+    model,
+    loader,
+    device,
+    plot_file="parity_plot.svg",
+    results_file="results.csv",
+    plot_mode=2,
+):
+    """
+    This function tests a trained machine learning model on a provided dataset, calculates the Mean Squared Error (
+    MSE) and R2 score, and prints these results. It also saves the prediction results as a CSV file and generates a
+    parity plot as an SVG file. The plot displays the model's predictions versus the actual values, color-coded by
+    the point density.
+
+    Parameters:
+        - model (torch.nn.Module): The trained model.
+        - loader (torch.utils.data.DataLoader): DataLoader for the dataset.
+        - device (str): The device ('cuda' or 'cpu') where the model will be run.
+        - plot_file (str, optional): The file path where the parity plot will be saved. Defaults to 'parity_plot.svg'.
+        - results_file (str, optional): The file path where the results will be saved as a CSV file. Defaults to 'results.csv'.
+        - plot_mode (int, optional): The mode for the parity plot. Set to 1 for scatter plot or 2 for density plot. Defaults to 2.
+    """
+
+    model.eval()
+    targets_list = []
+    outputs_list = []
+
+    with torch.no_grad():
+        for input, target, cif_id in loader:
+            atom_fea, nbr_fea, nbr_fea_idx, crystal_atom_idx = input
+            atom_fea = atom_fea.to(device)
+            nbr_fea = nbr_fea.to(device)
+            nbr_fea_idx = nbr_fea_idx.to(device)
+            crystal_atom_idx = [idx_map.to(device) for idx_map in crystal_atom_idx]
+            target = target.to(device)
+            output, _ = model(atom_fea, nbr_fea, nbr_fea_idx, crystal_atom_idx)
+            targets_list.extend(target.cpu().numpy().ravel().tolist())
+            outputs_list.extend(output.cpu().numpy().ravel().tolist())
+
+    mse = mean_squared_error(targets_list, outputs_list)
+    r2 = r2_score(targets_list, outputs_list)
+    print(f"MSE: {mse:.4f}, R2 Score: {r2:.4f}")
+
+    # Save results to csv
+    with open(results_file, "w", newline="") as file:
+        writer = csv.writer(file)
+        writer.writerow(["cif_id", "Actual", "Predicted"])
+        writer.writerows(zip(cif_id, targets_list, outputs_list))
+    print(f"Prediction results have been saved to {results_file}")
+
+    # Generate parity plot
+    fig, ax = plt.subplots(figsize=(8, 6))
+
+    if plot_mode == 1:
+        ax.scatter(
+            targets_list, outputs_list, alpha=0.6, s=50, edgecolor="none", color="blue"
+        )
+
+        plt.plot(
+            [min(targets_list), max(targets_list)],
+            [min(targets_list), max(targets_list)],
+            "r--",
+        )
+
+        ax.xlabel("Actual", fontsize=14)
+        ax.ylabel("Predicted", fontsize=14)
+        ax.title(f"Parity Plot (R2={r2:.4f}, MSE={mse:.4f})", fontsize=16)
+        ax.grid(True)
+
+    elif plot_mode == 2:
+        # Density plot using pymatviz
+        df = pd.DataFrame({"Actual": targets_list, "Predicted": outputs_list})
+        density_hexbin("Actual", "Predicted", df=df, ax=ax, xlabel="Actual", ylabel="Predicted")
+
+    plt.tight_layout()
+    plt.savefig(plot_file, format="svg")
+    print(f"Parity plot has been saved to {plot_file}")
+
+
+def predict_model(
+    model,
+    loader,
+    device,
+    verbose,
+    plot_file="parity_plot.svg",
+    results_file="results.csv",
+):
+    """
+    This function tests a trained machine learning model on a provided dataset, calculates the Mean Squared Error (
+    MSE) and R2 score, and prints these results. It also saves the prediction results as a CSV file and generates a
+    parity plot as an SVG file. The plot displays the model's predictions versus the actual values, color-coded by
+    the point density.
+
+    Parameters:
+        - model (torch.nn.Module): The trained model.
+        - loader (torch.utils.data.DataLoader): DataLoader for the dataset.
+        - device (str): The device ('cuda' or 'cpu') where the model will be run.
+        - plot_file (str, optional): The file path where the parity plot will be saved. Defaults to 'parity_plot.svg'.
+        - results_file (str, optional): The file path where the results will be saved as a CSV file. Defaults to 'results.csv'.
+    """
+
+    model.eval()
+    targets_list = []
+    outputs_list = []
+    crys_feas_list = []
+    index = 0
+
+    with torch.no_grad():
+        for input, target, cif_id in loader:
+            atom_fea, nbr_fea, nbr_fea_idx, crystal_atom_idx = input
+            atom_fea = atom_fea.to(device)
+            nbr_fea = nbr_fea.to(device)
+            nbr_fea_idx = nbr_fea_idx.to(device)
+            crystal_atom_idx = [idx_map.to(device) for idx_map in crystal_atom_idx]
+            target = target.to(device)
+
+            output, crys_fea = model(atom_fea, nbr_fea, nbr_fea_idx, crystal_atom_idx)
+
+            targets_list.extend(target.cpu().numpy().ravel().tolist())
+            outputs_list.extend(output.cpu().numpy().ravel().tolist())
+            crys_feas_list.append(crys_fea.cpu().numpy())
+
+            index += 1
+
+            # Extract the actual values from cif_id and output tensor
+            cif_id_value = cif_id[0] if cif_id and isinstance(cif_id, list) else cif_id
+            prediction_value = output.item() if output.numel() == 1 else output.tolist()
+
+            if verbose >= 3:
+                print(
+                    "index:",
+                    index,
+                    "| cif id:",
+                    cif_id_value,
+                    "| prediction:",
+                    prediction_value,
+                )
+
+    return outputs_list, crys_feas_list
+
+
+def cgcnn_pred(
+    model_path, all_set, verbose=3, cuda=False, num_workers=0
+):
+    if not os.path.isfile(model_path):
+        raise FileNotFoundError(f"=> No model params found at '{model_path}'")
+
+    total_dataset = CIFData_pred(all_set)
+
+    checkpoint = torch.load(
+        model_path,
+        map_location=lambda storage, loc: storage if not cuda else None,
+        weights_only=False,
+    )
+    structures, _, _ = total_dataset[0]
+    orig_atom_fea_len = structures[0].shape[-1]
+    nbr_fea_len = structures[1].shape[-1]
+    model_args = argparse.Namespace(**checkpoint["args"])
+    model = CrystalGraphConvNet(
+        orig_atom_fea_len,
+        nbr_fea_len,
+        atom_fea_len=model_args.atom_fea_len,
+        n_conv=model_args.n_conv,
+        h_fea_len=model_args.h_fea_len,
+        n_h=model_args.n_h,
+    )
+    if cuda:
+        model.cuda()
+
+    normalizer = Normalizer(torch.zeros(3))
+    normalizer.load_state_dict(checkpoint["normalizer"])
+    model.load_state_dict(checkpoint["state_dict"])
+
+    if verbose >= 3:
+        print(
+            f"=> Loaded model from '{model_path}' (epoch {checkpoint['epoch']}, validation error {checkpoint['best_mae_error']})"
+        )
+
+    device = "cuda" if cuda else "cpu"
+    model.to(device).eval()
+
+    full_loader = DataLoader(
+        total_dataset,
+        batch_size=1,
+        shuffle=False,
+        num_workers=num_workers,
+        collate_fn=collate_pool,
+        pin_memory=cuda,
+    )
+
+    pred, last_layer = predict_model(model, full_loader, device, verbose)
+
+    return pred, last_layer
+
+
+def parse_arguments():
+    """
+    Parses command-line arguments for the script.
+    """
+    parser = argparse.ArgumentParser(
+        description="Command-line interface for the Crystal Graph Convolutional Neural Network (CGCNN) model."
+    )
+    parser.add_argument(
+        "-mp",
+        "--model-path",
+        type=str,
+        help="Path to the file containing the trained model parameters.",
+    )
+    parser.add_argument(
+        "-mp2",
+        "--model-path2",
+        type=str,
+        help="Path to the file containing the trained model 2 parameters.",
+    )
+    parser.add_argument(
+        "-as",
+        "--total-set",
+        type=str,
+        help="Path to the directory containing all CIF files for the dataset.",
+    )
+    parser.add_argument(
+        "-trs",
+        "--train-set",
+        type=str,
+        help="Path to the directory containing CIF files for the train dataset.",
+    )
+    parser.add_argument(
+        "-vs",
+        "--valid-set",
+        type=str,
+        help="Path to the directory containing CIF files for the validation dataset.",
+    )
+    parser.add_argument(
+        "-ts",
+        "--test-set",
+        type=str,
+        help="Path to the directory containing CIF files for the test dataset.",
+    )
+    parser.add_argument(
+        "-trr",
+        "--train-ratio",
+        default=0.6,
+        type=float,
+        help="The ratio of the dataset to be used for training. Default: 0.6",
+    )
+    parser.add_argument(
+        "-vr",
+        "--valid-ratio",
+        default=0.2,
+        type=float,
+        help="The ratio of the dataset to be used for validation. Default: 0.2",
+    )
+    parser.add_argument(
+        "-tr",
+        "--test-ratio",
+        default=0.2,
+        type=float,
+        help="The ratio of the dataset to be used for testing. Default: 0.2",
+    )
+    parser.add_argument(
+        "-e",
+        "--epoch",
+        default=10000,
+        type=float,
+        help="Total epochs for training the model.",
+    )
+    parser.add_argument(
+        "-sp",
+        "--stop-patience",
+        default=100,
+        type=float,
+        help="Epochs for early stopping.",
+    )
+    parser.add_argument(
+        "-lrp",
+        "--lr-patience",
+        default=0,
+        type=float,
+        help="Epochs for reducing learning rate.",
+    )
+    parser.add_argument(
+        "-lrf",
+        "--lr-factor",
+        default=0.0,
+        type=float,
+        help="Factor for reducing learning rate.",
+    )
+    parser.add_argument(
+        "-tlfc",
+        "--train-last-fc",
+        default=0,
+        type=int,
+        help="Train on the last fully connected layer or all the fully connected layers",
+    )
+    parser.add_argument(
+        "-lrfc",
+        "--lr-fc",
+        default=0.01,
+        type=float,
+        help="Learning rate for fully connected layer.",
+    )
+    parser.add_argument(
+        "-lrnfc",
+        "--lr-non-fc",
+        default=0.001,
+        type=float,
+        help="Learning rate for non-fully connected layer.",
+    )
+    parser.add_argument(
+        "-rs", "--random-seed", default=123, type=int, help="Random seed."
+    )
+    parser.add_argument(
+        "-bs",
+        "--batch-size",
+        default=256,
+        type=int,
+        metavar="N",
+        help="The size of each batch during training or testing. Default: 256",
+    )
+    parser.add_argument(
+        "-j",
+        "--workers",
+        default=0,
+        type=int,
+        metavar="N",
+        help="The number of subprocesses to use for data loading. Default: 0",
+    )
+    parser.add_argument(
+        "--disable-cuda",
+        action="store_true",
+        help="Set this flag to disable CUDA, even if it is available.",
+    )
+    parser.add_argument(
+        "-m",
+        "--mode",
+        default=1,
+        type=int,
+        help="Set to 1 to train the model, or 0 to test the model. Default: 1",
+    )
+    parser.add_argument(
+        "-ji", "--job-id", default=None, type=str, help="The id of the current job."
+    )
+    parser.add_argument(
+        "-r",
+        "--replace",
+        default=1,
+        type=int,
+        help="Replace the training layer to restart.",
+    )
+    parser.add_argument(
+        "-bt",
+        "--bias-temperature",
+        default=0.0,
+        type=float,
+        help="Bias the loss function using a Boltzmann like factor.",
+    )
+
+    args = parser.parse_args(sys.argv[1:])
+    args.cuda = not args.disable_cuda and torch.cuda.is_available()
+
+    # Warning if train ratio and test ratio don't sum to 1
+    if abs(args.train_ratio + args.valid_ratio + args.test_ratio - 1) > 1e-6:
+        print("Warning: Train ratio, Valid ratio and Test ratio do not sum up to 1")
+
+    return args

cgcnn2-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[tool.poetry]
+name = "cgcnn2"
+version = "0.1.0"
+description = "Crystal Graph Convolutional Neural Networks"
+authors = ["Jiacheng Wang <jiachengwang@umass.edu>"]
+maintainers = ["Jiacheng Wang"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/jcwang587/cgcnn2/"
+repository = "https://github.com/jcwang587/cgcnn2/"
+
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+
+keywords = ["python", "gnn", "vasp", "crystal"]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.12"
+ase = "3.23.0"
+numpy = "*"
+pandas = "*"
+scikit-learn = "*"
+torch = "2.5.1"
+pymatgen = "2024.10.3"
+pymatviz = "0.13.2"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "8.3.3"
+pytest-cov = "5.0.0"
+
+[build-system]
+requires = ["poetry-core==1.9.0"]
+build-backend = "poetry.core.masonry.api"