aimnet 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

aimnet/train/metrics.py

@@ -1,6 +1,5 @@
 import logging
 from collections import defaultdict
-from typing import Dict, List, Tuple
 
 import ignite.distributed as idist
 import numpy as np
@@ -11,7 +10,7 @@ from ignite.metrics.metric import reinit__is_reduced
 from torch import Tensor
 
 
-def regression_stats(pred: Tensor, true: Tensor) -> Dict[str, Tensor]:
+def regression_stats(pred: Tensor, true: Tensor) -> dict[str, Tensor]:
     diff = true - pred
     diff2 = diff.pow(2)
     mae = diff.abs().mean(-1)
@@ -23,7 +22,7 @@ def regression_stats(pred: Tensor, true: Tensor) -> Dict[str, Tensor]:
     return {"mae": mae, "rmse": rmse, "r2": r2}
 
 
-def cat_flatten(y_pred: Tensor, y_true: Tensor) -> Tuple[Tensor, Tensor]:
+def cat_flatten(y_pred: Tensor, y_true: Tensor) -> tuple[Tensor, Tensor]:
     if isinstance(y_true, (list, tuple)):
         y_true = torch.cat([x.view(-1) for x in y_true])
     if isinstance(y_pred, (list, tuple)):
@@ -69,7 +68,7 @@ def calculate_metrics(result, histogram=False, corrplot=False):
         y_pred, y_true = cat_flatten(y_pred, y_true)
         stats = regression_stats(y_pred, y_true)
         npass = stats["mae"].numel()
-        if k.split(".")[-1] in ("energy", "forces"):  # noqa: SIM108
+        if k.split(".")[-1] in ("energy", "forces"):
             f = 23.06  # eV to kcal/mol
         else:
             f = 1.0
@@ -86,7 +85,7 @@ def calculate_metrics(result, histogram=False, corrplot=False):
 
 
 class RegMultiMetric(Metric):
-    def __init__(self, cfg: List[Dict], loss_fn=None):
+    def __init__(self, cfg: list[dict], loss_fn=None):
         super().__init__()
         self.cfg = cfg
         self.loss_fn = loss_fn
@@ -139,7 +138,7 @@ class RegMultiMetric(Metric):
                         loss = loss.item()
                     self.loss[k] += loss * b
 
-    def compute(self) -> Dict[str, float]:
+    def compute(self) -> dict[str, float]:
         if self.samples == 0:
             raise NotComputableError
         # Use custom reduction

aimnet/train/train.py

@@ -70,7 +70,7 @@ def train(config, model, load=None, save=None, args=None, no_default_config=Fals
     logging.info(train_cfg)
     logging.info("--- END train.yaml ---")
 
-    # try load model and pring its configuration
+    # try load model and print its configuration
     logging.info("Building model")
     model = utils.build_model(model_cfg)
     logging.info(model)
@@ -113,6 +113,8 @@ def run(local_rank, world_size, model_cfg, train_cfg, load, save):
         from ignite import distributed as idist
 
         model = idist.auto_model(model)  # type: ignore[attr-defined]
+    elif torch.cuda.is_available():
+        model = model.cuda()  # type: ignore
 
     # load weights
     if load is not None:
@@ -135,6 +137,7 @@ def run(local_rank, world_size, model_cfg, train_cfg, load, save):
         optimizer = idist.auto_optim(optimizer)  # type: ignore[attr-defined]
     scheduler = utils.get_scheduler(optimizer, train_cfg.scheduler) if train_cfg.scheduler is not None else None  # type: ignore[attr-defined]
     loss = utils.get_loss(train_cfg.loss)
+
     metrics = utils.get_metrics(train_cfg.metrics)
     metrics.attach_loss(loss)  # type: ignore[attr-defined]
 

aimnet/train/utils.py

@@ -1,7 +1,8 @@
 import logging
 import os
 import re
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+from collections.abc import Callable, Sequence
+from typing import Any
 
 import numpy as np
 import omegaconf
@@ -58,7 +59,7 @@ def apply_sae(ds: SizeGroupedDataset, cfg: omegaconf.DictConfig):
         if c is not None and k in cfg.y:
             sae = load_yaml(c.file)
             unique_numbers = set(np.unique(ds.concatenate("numbers").tolist()))
-            if not set(sae.keys()).issubset(unique_numbers):  # type: ignore[attr-defined]
+            if not unique_numbers.issubset(sae.keys()):  # type: ignore[attr-defined]
                 raise ValueError(f"Keys in SAE file {c.file} do not cover all the dataset atoms")
             if c.mode == "linreg":
                 ds.apply_peratom_shift(k, k, sap_dict=sae)
@@ -177,7 +178,7 @@ def get_loss(cfg: omegaconf.DictConfig):
     return loss
 
 
-def set_trainable_parameters(model: nn.Module, force_train: List[str], force_no_train: List[str]) -> nn.Module:
+def set_trainable_parameters(model: nn.Module, force_train: list[str], force_no_train: list[str]) -> nn.Module:
     for n, p in model.named_parameters():
         if any(re.search(x, n) for x in force_no_train):
             p.requires_grad_(False)
@@ -214,7 +215,7 @@ def get_metrics(cfg: omegaconf.DictConfig):
     return metrics
 
 
-def train_step(engine: Engine, batch: Sequence[torch.Tensor]) -> Union[Any, Tuple[torch.Tensor]]:
+def train_step(engine: Engine, batch: Sequence[torch.Tensor]) -> Any | tuple[torch.Tensor]:
     global model
     global optimizer
     global prepare_batch
@@ -232,7 +233,7 @@ def train_step(engine: Engine, batch: Sequence[torch.Tensor]) -> Union[Any, Tupl
     return loss.item()
 
 
-def val_step(engine: Engine, batch: Sequence[torch.Tensor]) -> Union[Any, Tuple[torch.Tensor]]:
+def val_step(engine: Engine, batch: Sequence[torch.Tensor]) -> Any | tuple[torch.Tensor]:
     global model
     global optimizer
     global prepare_batch
@@ -248,7 +249,7 @@ def val_step(engine: Engine, batch: Sequence[torch.Tensor]) -> Union[Any, Tuple[
     return y_pred, y
 
 
-def prepare_batch(batch: Dict[str, Tensor], device="cuda", non_blocking=True) -> Dict[str, Tensor]:  # noqa: F811
+def prepare_batch(batch: dict[str, Tensor], device="cuda", non_blocking=True) -> dict[str, Tensor]:  # noqa: F811
     for k, v in batch.items():
         batch[k] = v.to(device, non_blocking=non_blocking)
     return batch
@@ -257,11 +258,11 @@ def prepare_batch(batch: Dict[str, Tensor], device="cuda", non_blocking=True) ->
 def default_trainer(
     model: torch.nn.Module,
     optimizer: torch.optim.Optimizer,
-    loss_fn: Union[Callable, torch.nn.Module],
-    device: Optional[Union[str, torch.device]] = None,
+    loss_fn: Callable | torch.nn.Module,
+    device: str | torch.device | None = None,
     non_blocking: bool = True,
 ) -> Engine:
-    def _update(engine: Engine, batch: Tuple[Dict[str, Tensor], Dict[str, Tensor]]) -> float:
+    def _update(engine: Engine, batch: tuple[dict[str, Tensor], dict[str, Tensor]]) -> float:
         model.train()
         optimizer.zero_grad()
         x = prepare_batch(batch[0], device=device, non_blocking=non_blocking)  # type: ignore
@@ -271,17 +272,18 @@ def default_trainer(
         loss.backward()
         torch.nn.utils.clip_grad_value_(model.parameters(), 0.4)
         optimizer.step()
+
         return loss.item()
 
     return Engine(_update)
 
 
 def default_evaluator(
-    model: torch.nn.Module, device: Optional[Union[str, torch.device]] = None, non_blocking: bool = True
+    model: torch.nn.Module, device: str | torch.device | None = None, non_blocking: bool = True
 ) -> Engine:
     def _inference(
-        engine: Engine, batch: Tuple[Dict[str, Tensor], Dict[str, Tensor]]
-    ) -> Tuple[Dict[str, Tensor], Dict[str, Tensor]]:
+        engine: Engine, batch: tuple[dict[str, Tensor], dict[str, Tensor]]
+    ) -> tuple[dict[str, Tensor], dict[str, Tensor]]:
         model.eval()
         x = prepare_batch(batch[0], device=device, non_blocking=non_blocking)  # type: ignore
         y = prepare_batch(batch[1], device=device, non_blocking=non_blocking)  # type: ignore
@@ -316,6 +318,23 @@ def build_engine(model, optimizer, scheduler, loss_fn, metrics, cfg, loader_val)
         logging.info(f"LR: {lr}")
 
     trainer.add_event_handler(Events.EPOCH_STARTED, log_lr)
+
+    # log loss weights
+    def log_loss_weights(engine):
+        s = []
+        for k, v in loss_fn.components.items():
+            s.append(f"{k}: {v[1]:.4f}")
+        s = " ".join(s)
+        logging.info(s)
+        if loss_fn.weights is not None:
+            s = []
+            for k, v in loss_fn.weights.items():
+                s.append(f"{k}: {v:.4f}")
+            s = " ".join(s)
+            logging.info(s)
+
+    trainer.add_event_handler(Events.EPOCH_STARTED, log_loss_weights)
+
     # write TQDM progress
     if idist.get_local_rank() == 0:
         pbar = ProgressBar()
@@ -327,15 +346,22 @@ def build_engine(model, optimizer, scheduler, loss_fn, metrics, cfg, loader_val)
     metrics.attach(validator, "multi")
     trainer.add_event_handler(Events.EPOCH_COMPLETED(every=1), validator.run, data=loader_val)
 
+    # attach optimizer and loss to engines
+    trainer.state.optimizer = optimizer
+    trainer.state.loss_fn = loss_fn
+    validator.state.optimizer = optimizer
+    validator.state.loss_fn = loss_fn
+
     # scheduler
     if scheduler is not None:
+        validator.state.scheduler = scheduler
         validator.add_event_handler(Events.COMPLETED, scheduler)
         terminator = TerminateOnLowLR(optimizer, cfg.scheduler.terminate_on_low_lr)
         trainer.add_event_handler(Events.EPOCH_STARTED, terminator)
 
     # checkpoint after each epoch
     if cfg.checkpoint and idist.get_local_rank() == 0:
-        kwargs = OmegaConf.to_container(cfg.checkpoint.kwargs) if "kwargs" not in cfg.checkpoint else {}
+        kwargs = OmegaConf.to_container(cfg.checkpoint.kwargs) if "kwargs" in cfg.checkpoint else {}
         if not isinstance(kwargs, dict):
             raise TypeError("Checkpoint kwargs must be a dictionary.")
         kwargs["global_step_transform"] = global_step_from_engine(trainer)
@@ -379,6 +405,9 @@ def setup_wandb(cfg, model_cfg, model, trainer, validator, optimizer):
             params = {
                 f"{self.param_name}_{i}": float(g[self.param_name]) for i, g in enumerate(self.optimizer.param_groups)
             }
+            if hasattr(engine.state, "loss_fn") and hasattr(engine.state.loss_fn, "components"):  # type: ignore
+                for name, (_, w) in engine.state.loss_fn.components.items():  # type: ignore
+                    params[f"weight/{name}"] = w
             logger.log(params, step=global_step, sync=self.sync)
 
     wandb_logger.attach(trainer, log_handler=EpochLRLogger(optimizer), event_name=Events.EPOCH_STARTED)

aimnet-0.1.0.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: aimnet
+Version: 0.1.0
+Summary: AIMNet Machine Learned Interatomic Potential
+Project-URL: Homepage, https://github.com/isayevlab/aimnetcentral
+Project-URL: Documentation, https://isayevlab.github.io/aimnetcentral/
+Project-URL: Repository, https://github.com/isayevlab/aimnetcentral
+Author-email: Roman Zubatyuk <zubatyuk@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024, Roman Zubatyuk
+        
+        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.
+License-File: LICENSE
+Keywords: computational chemistry,deep learning,interatomic potential,machine learning,molecular dynamics
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1.7
+Requires-Dist: h5py>=3.12.1
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: numpy
+Requires-Dist: nvalchemi-toolkit-ops>=0.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: requests>=2.32.3
+Requires-Dist: torch>=2.4
+Requires-Dist: warp-lang>=1.11
+Provides-Extra: ase
+Requires-Dist: ase==3.27.0; extra == 'ase'
+Provides-Extra: pysis
+Requires-Dist: pysisyphus; extra == 'pysis'
+Provides-Extra: train
+Requires-Dist: omegaconf>=2.3.0; extra == 'train'
+Requires-Dist: pytorch-ignite>=0.5.1; extra == 'train'
+Requires-Dist: wandb>=0.18.5; extra == 'train'
+Description-Content-Type: text/markdown
+
+[![Release](https://img.shields.io/github/v/release/isayevlab/aimnetcentral)](https://github.com/isayevlab/aimnetcentral/releases)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)](https://www.python.org/)
+[![Build status](https://img.shields.io/github/actions/workflow/status/isayevlab/aimnetcentral/main.yml?branch=main)](https://github.com/isayevlab/aimnetcentral/actions/workflows/main.yml?query=branch%3Amain)
+[![codecov](https://codecov.io/gh/isayevlab/aimnetcentral/branch/main/graph/badge.svg)](https://codecov.io/gh/isayevlab/aimnetcentral)
+[![License](https://img.shields.io/github/license/isayevlab/aimnetcentral)](https://github.com/isayevlab/aimnetcentral/blob/main/LICENSE)
+
+- **Github repository**: <https://github.com/isayevlab/aimnetcentral/>
+- **Documentation** <https://isayevlab.github.io/aimnetcentral/>
+
+# AIMNet2 : ML interatomic potential for fast and accurate atomistic simulations
+
+## Key Features
+
+- Accurate and Versatile: AIMNet2 excels at modeling neutral, charged, organic, and elemental-organic systems.
+- Flexible Interfaces: Use AIMNet2 through convenient calculators for popular simulation packages like ASE and PySisyphus.
+- Flexible Long-Range Interactions: Optionally employ the Damped-Shifted Force (DSF) or Ewald summation Coulomb models for accurate calculations in large or periodic systems.
+
+## Requirements
+
+### Python Version
+
+AIMNet2 requires **Python 3.11 or 3.12**.
+
+### GPU Support (Optional)
+
+AIMNet2 works on CPU out of the box. For GPU acceleration:
+
+- **CUDA GPU**: Install PyTorch with CUDA support from [pytorch.org](https://pytorch.org/get-started/locally/)
+- **compile_mode**: Requires CUDA for ~5x MD speedup (see Performance Optimization)
+
+Example PyTorch installation with CUDA 12.4:
+
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu124
+```
+
+## Available Models
+
+| Model           | Elements                                      | Description                                   |
+| --------------- | --------------------------------------------- | --------------------------------------------- |
+| `aimnet2`       | H, B, C, N, O, F, Si, P, S, Cl, As, Se, Br, I | wB97M-D3 (default)                            |
+| `aimnet2_b973c` | H, B, C, N, O, F, Si, P, S, Cl, As, Se, Br, I | B97-3c functional                             |
+| `aimnet2_2025`  | H, B, C, N, O, F, Si, P, S, Cl, As, Se, Br, I | B97-3c + improved intermolecular interactions |
+| `aimnet2nse`    | H, B, C, N, O, F, Si, P, S, Cl, As, Se, Br, I | Open-shell chemistry                          |
+| `aimnet2pd`     | H, B, C, N, O, F, Si, P, S, Cl, Se, Br, Pd, I | Palladium-containing systems                  |
+
+_Each model has ensemble members (append \_0 to \_3). Ensemble averaging recommended for production use._
+
+## Installation
+
+### Basic Installation
+
+Install from PyPI:
+
+```bash
+pip install aimnet
+```
+
+### Optional Features
+
+AIMNet2 provides optional extras for different use cases:
+
+**ASE Calculator** (for atomistic simulations with ASE):
+
+```bash
+pip install "aimnet[ase]"
+```
+
+**PySisyphus Calculator** (for reaction path calculations):
+
+```bash
+pip install "aimnet[pysis]"
+```
+
+**Training** (for model training and development):
+
+```bash
+pip install "aimnet[train]"
+```
+
+**All Features**:
+
+```bash
+pip install "aimnet[ase,pysis,train]"
+```
+
+### Development Installation
+
+For contributors, use [uv](https://docs.astral.sh/uv/) for fast dependency management:
+
+```bash
+git clone https://github.com/isayevlab/aimnetcentral.git
+cd aimnetcentral
+make install
+source .venv/bin/activate
+```
+
+## Quick Start
+
+### Basic Usage (Core)
+
+```python
+from aimnet.calculators import AIMNet2Calculator
+
+# Load a pre-trained model
+calc = AIMNet2Calculator("aimnet2")
+
+# Prepare input
+data = {
+    "coord": coordinates,  # Nx3 array
+    "numbers": atomic_numbers,  # N array
+    "charge": 0.0,
+}
+
+# Run inference
+results = calc(data, forces=True)
+print(results["energy"], results["forces"])
+```
+
+### Output Data
+
+The calculator returns a dictionary with the following keys:
+
+| Key       | Shape                   | Description                          |
+| --------- | ----------------------- | ------------------------------------ |
+| `energy`  | `(,)` or `(B,)`         | Total energy in eV                   |
+| `charges` | `(N,)` or `(B, N)`      | Atomic partial charges in e          |
+| `forces`  | `(N, 3)` or `(B, N, 3)` | Atomic forces in eV/A (if requested) |
+| `hessian` | `(N, 3, N, 3)`          | Second derivatives (if requested)    |
+| `stress`  | `(3, 3)`                | Stress tensor for PBC (if requested) |
+
+_B = batch size, N = number of atoms_
+
+### ASE Integration
+
+With `aimnet[ase]` installed:
+
+```python
+from ase.io import read
+from aimnet.calculators import AIMNet2ASE
+
+atoms = read("molecule.xyz")
+atoms.calc = AIMNet2ASE("aimnet2")
+
+energy = atoms.get_potential_energy()
+forces = atoms.get_forces()
+```
+
+### Periodic Boundary Conditions
+
+For periodic systems, provide a unit cell:
+
+```python
+data = {
+    "coord": coordinates,
+    "numbers": atomic_numbers,
+    "charge": 0.0,
+    "cell": cell_vectors,  # 3x3 array in Angstrom
+}
+results = calc(data, forces=True, stress=True)
+```
+
+### Long-Range Coulomb Methods
+
+Configure electrostatic interactions for large or periodic systems:
+
+```python
+# Damped-Shifted Force (DSF) - recommended for periodic systems
+calc.set_lrcoulomb_method("dsf", cutoff=15.0, dsf_alpha=0.2)
+
+# Ewald summation - for accurate periodic electrostatics
+calc.set_lrcoulomb_method("ewald", ewald_accuracy=1e-8)
+```
+
+### Performance Optimization
+
+For molecular dynamics simulations, use `compile_mode` for ~5x speedup:
+
+```python
+calc = AIMNet2Calculator("aimnet2", compile_mode=True)
+```
+
+Requirements:
+
+- CUDA GPU required
+- Not compatible with periodic boundary conditions
+- Best for repeated inference on similar-sized systems
+
+### Training
+
+With `aimnet[train]` installed:
+
+```bash
+aimnet train --config my_config.yaml --model aimnet2.yaml
+```
+
+## Technical Details
+
+### Batching and Neighbor Lists
+
+The `AIMNet2Calculator` automatically selects the optimal strategy based on system size (`nb_threshold`, default 120 atoms) and hardware:
+
+1. **Dense Mode (O(N²))**: Used for small molecules on GPU. Input is kept in 3D batched format `(B, N, 3)`. No neighbor list is computed; the model uses a fully connected graph for maximum parallelism.
+2. **Sparse Mode (O(N))**: Used for large systems or CPU execution. Input is flattened to 2D `(N_total, 3)` with an adaptive neighbor list. This ensures linear memory scaling.
+
+### Adaptive Neighbor List
+
+In sparse mode, AIMNet2 uses an `AdaptiveNeighborList` that automatically resizes its buffer to maintain efficient utilization (~75%) while preventing overflows.
+
+- **Format**: The neighbor list is stored as a 2D integer matrix `nbmat` of shape `(N_total, max_neighbors)`. Each row `i` contains the indices of atoms neighboring atom `i`.
+- **Padding**: Rows with fewer neighbors than `max_neighbors` are padded with the index `N_total` (a dummy atom index).
+- **Buffer Management**: The buffer size `max_neighbors` is always a multiple of 16 for memory alignment. It dynamically expands (by 1.5x) on overflow and shrinks if utilization drops significantly below the target, ensuring robust performance during MD simulations where density fluctuates.
+
+## Development
+
+Common development tasks using `make`:
+
+```bash
+make check       # Run linters and code quality checks
+make test        # Run tests with coverage
+make docs        # Build and serve documentation
+make build       # Build distribution packages
+```
+
+## Citation
+
+If you use AIMNet2 in your research, please cite the appropriate paper:
+
+**AIMNet2 (main model):**
+
+```bibtex
+@article{aimnet2,
+  title={AIMNet2: A Neural Network Potential to Meet Your Neutral, Charged, Organic, and Elemental-Organic Needs},
+  author={Anstine, Dylan M and Zubatyuk, Roman and Isayev, Olexandr},
+  journal={Chemical Science},
+  volume={16},
+  pages={10228--10244},
+  year={2025},
+  doi={10.1039/D4SC08572H}
+}
+```
+
+**AIMNet2-NSE:** [ChemRxiv preprint](https://chemrxiv.org/engage/chemrxiv/article-details/692d304c65a54c2d4a7ab3c7)
+
+**AIMNet2-Pd:** [ChemRxiv preprint](https://chemrxiv.org/engage/chemrxiv/article-details/67d7b7f7fa469535b97c021a)
+
+## License
+
+See [LICENSE](LICENSE) file for details.

aimnet-0.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+aimnet/__init__.py,sha256=uxi5cEnLX3g_C7nUnxGwULhF-wyNIUwcYUImDYhnoKA,185
+aimnet/base.py,sha256=jkMYzkF8ZB3RvN2G4p3felkXZm3UXVYK6KPcj5nC0Ac,1875
+aimnet/cli.py,sha256=d6sICpuRFoMifjE4DxPGB8YPUYOlxNnxZeQWfhqAypE,2158
+aimnet/config.py,sha256=N9ePMjlmUKWwumi-mAcBN_SrvqAAm41hYRxYv-MDcvU,5881
+aimnet/constants.py,sha256=T6eb_CG5dkxuUg22Xf8WiF0iGB-JLoLNzHq9R8SRzrQ,8760
+aimnet/nbops.py,sha256=tatWTo3RyQNfTfD6dO1Cxp70AKLmup89m69rNqITJGA,8731
+aimnet/ops.py,sha256=DJ9WqlTfP7ATYKOk0DvTSEWeYjCMnhv0-8qoj5zn2KY,10523
+aimnet/calculators/__init__.py,sha256=xn4guycZdf_FRJenbzTTQYG7BppFDZ4K671Ser4oRRc,383
+aimnet/calculators/aimnet2ase.py,sha256=s6M-quNxISpX9TjEthH6HNIvifcIA0lNcVOECpNGxJU,3890
+aimnet/calculators/aimnet2pysis.py,sha256=TDoDl-TExCQkg8EXfsTKjOu-z6Kd25xXqSH98gF8iGM,2876
+aimnet/calculators/calculator.py,sha256=lZXo7YqSLJuMPruFRqqxACzAlqL14J-rVI62zrduwT4,43938
+aimnet/calculators/model_registry.py,sha256=Vt0zW6LBOVZOSWSMFVUHhP4twsJXEYyrOPeaK1Yc07k,1840
+aimnet/data/__init__.py,sha256=rD84W2qazjXUbdcYBuHkMmYp44fGRFMS3qnv1OKPsQs,87
+aimnet/data/sgdataset.py,sha256=SKdSLXhtE00dKqF96FNX2sdI8wvenHMdIeyibHeGZqM,18891
+aimnet/kernels/__init__.py,sha256=seUBZszDGFGhRfr_WI7j8cz-rtstEDVLcFEHMaqEjbw,2548
+aimnet/kernels/conv_sv_2d_sp_wp.py,sha256=JUXej8LYa6She_TTUda-scZ_8pi7Q6VZ97Sfu5dLvVU,15329
+aimnet/models/__init__.py,sha256=_cbeJgPf35xQW7nib1zn0VeEvgTxK4mXRkwYF472tds,361
+aimnet/models/aimnet2.py,sha256=nmmNJTLuNxdMxzZ7Jn0fk98UesEl-MHFL0NEvnwi2eg,6971
+aimnet/models/base.py,sha256=1Cux585dEkzkmJ9Ne8EVzv7fO-CW3ga5SSFcJ643uC8,8290
+aimnet/models/convert.py,sha256=vxS2sIfM-wM2BOglXtiG1k0S5ayGT8CY7nR6d2y5xgU,1018
+aimnet/models/utils.py,sha256=Itn3VEFtWc64rpEzlYys8J4EfZwzGJSUb2-7LGiVX9U,24445
+aimnet/modules/__init__.py,sha256=I-9heqRdnXeypMUjzeQ6Y4EATM_9n4NFyCC6Om6H2Vw,216
+aimnet/modules/aev.py,sha256=aYCootmc3mdp9rgpvwc6dtrX96bORu1xTlgPPGobOQU,8099
+aimnet/modules/core.py,sha256=vIPyMcrS6tfQUMdlLYx1d-I8lJ56gRkofk5Wf6sEKPU,8232
+aimnet/modules/lr.py,sha256=1jA319NUvT-Cact7Xf4vY8tZ58IpOAg-8DDciRvLkOg,23741
+aimnet/modules/ops.py,sha256=FQkN-2yVK4pMGdUv7xYDvDB2ZnCiRNLksYmJjX-q9Hk,16175
+aimnet/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aimnet/train/calc_sae.py,sha256=h-y8jQVU6O7Rmw8xJWX3DHOpFv1gtjFwtZzZyUOhz9g,1459
+aimnet/train/export_model.py,sha256=mku74Bqu5OkxD-iDTnb78A202Bzu7vIvfBKjyrMgKsI,9028
+aimnet/train/loss.py,sha256=HSSagZvO_jRvouIwX0ZHLiOMf9uLgX3rSmtrZMCcKOA,3169
+aimnet/train/metrics.py,sha256=gCYIFAgsOfmGv2Mc2GtfOcIq2TLU6q5cvQPWLuiUdSM,6814
+aimnet/train/train.py,sha256=aOrYbujKdy_3nLUVM0wkv1E_CLRDGUJ7uIFzgmYegW4,5793
+aimnet/train/utils.py,sha256=8-6jvNRGaoEODjLOnmxhmUSQJYiM1GfFeGFCeytA5RQ,15666
+aimnet/dftd3_data.pt,sha256=g9HQ_2nekMs97UnIDIFReGEG8q6n6zQlq-Yl5LGQnOI,2710647
+aimnet/calculators/model_registry.yaml,sha256=HsreBHvQHkf0ErCuzYMqq1MsPYv6g6xRhS9yzOMrKOk,3423
+aimnet/models/aimnet2.yaml,sha256=VmI0ub7UbiJm833zwCtCKsrBIaXZKjJsCXxXxutwdLI,1062
+aimnet/models/aimnet2_dftd3_wb97m.yaml,sha256=Gk869_2RQIXzlHwRNbfsai4u9wPX3oAyINK1I71eBFI,1219
+aimnet/train/default_train.yaml,sha256=FAG3f3pFC2dkFUuVO_XE_UB6rFr-R3GkACddn7FH_58,4783
+aimnet-0.1.0.dist-info/METADATA,sha256=iPzwFcL4vxHeB-zEzUINhXEsHhSGjFQZWsD9xyMGVnQ,11083
+aimnet-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+aimnet-0.1.0.dist-info/entry_points.txt,sha256=LEicBveXz9HdsF0UiHXr3tMeHPxofm2VP5v9ISwhe9s,99
+aimnet-0.1.0.dist-info/licenses/LICENSE,sha256=73sk-zg2yVRrOZQDeVbPlVB7ScZc1iK0kyCBMwNwQgA,1072
+aimnet-0.1.0.dist-info/RECORD,,

{aimnet-0.0.1.dist-info → aimnet-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

aimnet-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+aimnet = aimnet.cli:cli
+aimnet2pysis = aimnet.calculators.aimnet2pysis:run_pysis