SevenNet (sevenn)

0.12.1 · active · verified Thu Apr 16

SevenNet is a Python library implementing Scalable EquiVariance Enabled Neural Networks, primarily for atomistic simulations and materials science. It integrates with the Atomic Simulation Environment (ASE) for molecular dynamics, energy, and force calculations. The library is actively developed, with frequent minor releases and specific checkpoint releases for new pre-trained models. The current stable version is 0.12.1.

Common errors

```
AttributeError: module 'sevenn' has no attribute 'train'
```
cause Attempting to use the old CLI command style (e.g., `sevenn.train.run()`) after the CLI refactor in `v0.11.1`.

fix Use the new subcommand-based CLI interface: `from sevenn.cli import run` and call `run(['train', ...])`, or execute `sevenn train ...` from the terminal.
```
RuntimeError: Could not find a suitable E3nn version. The installed version is X.Y.Z, but SevenNet requires A.B.C.
```
cause `e3nn` library version incompatibility with your installed `sevenn` version.

fix Reinstall `sevenn` to ensure `e3nn` is installed correctly via its dependencies, or manually ensure your `e3nn` version matches the requirements for your `sevenn` version (e.g., `pip install 'e3nn>=0.5.0,<0.6.0'` if specified).
```
ModuleNotFoundError: No module named 'ninja'
```
cause Attempting to enable or use the FlashTP feature without the `ninja` package installed.

fix Install the `ninja` package: `pip install ninja`. This dependency is required for FlashTP's optimized kernel compilation.

Warnings

breaking The command-line interface (CLI) was significantly refactored in v0.11.1, changing from a single `sevenn_train` or `sevenn_inference` script to a subcommand-based structure (e.g., `sevenn train`, `sevenn inference`).
Fix: Update your CLI commands to use the `sevenn <subcommand>` pattern. Refer to the official documentation for updated subcommand syntax.
gotcha SevenNet has strict compatibility requirements with the `e3nn` library. Versions `0.10.4` and older are compatible with `e3nn < 0.5.0`, while `0.11.1` and newer likely require `e3nn >= 0.5.0` or a specific range. Installing an incompatible `e3nn` version can lead to runtime errors.
Fix: Always install `sevenn` using its `pip install sevenn` command, which will handle `e3nn` dependencies. If manually managing `e3nn`, check `sevenn`'s `pyproject.toml` or `setup.py` for the exact required `e3nn` version range for your `sevenn` version.
gotcha Using the FlashTP feature for accelerated calculations requires the `ninja` package to be installed, as it's used for compiling optimized kernels. If `ninja` is not present, FlashTP will fail to initialize.
Fix: Install `ninja` manually (`pip install ninja`) or install `sevenn` with the `[flashtp]` extra (e.g., `pip install sevenn[flashtp]`) if available, or manually install dependencies for the FlashTP feature.
deprecated Inconsistent argument naming for FlashTP-related settings in CLI and configuration files was fixed in `v0.12.1`. Older scripts or configs might use deprecated argument names.
Fix: Upgrade to `v0.12.1` or later and review your configuration files and CLI calls, especially those related to FlashTP, to ensure they use the standardized argument names.

Install

pip install sevenn Stable release
pip install sevenn[gpu] With GPU support (requires CUDA setup)

Imports

SevenNetCalculator
wrong:
```
from sevenn import SevenNetCalculator
```
correct:
```
from sevenn.calculator import SevenNetCalculator
```
The calculator is located in the 'calculator' submodule.
SevenNet
wrong:
```
from sevenn import SevenNet
```
correct:
```
from sevenn.model import SevenNet
```
The main model class resides in the 'model' submodule.
run
wrong:
```
import sevenn.train
```
correct:
```
from sevenn.cli import run
```
CLI operations are consolidated under 'sevenn.cli'.

Quickstart

This quickstart demonstrates how to use `SevenNetCalculator` to compute energy, forces, and stress for an ASE `Atoms` object using a pre-trained SevenNet model. Ensure you have a model checkpoint available locally.

import os
import numpy as np
from ase.build import bulk
from sevenn.calculator import SevenNetCalculator

# Assuming a pre-trained model checkpoint path
# Replace with your actual model path or a path to a downloaded checkpoint
# Example: sevenn_cp download 'SevenNet-Omni-i8' will download to current dir
MODEL_PATH = os.environ.get('SEVENN_MODEL_PATH', 'SevenNet-Omni-i8.ckpt')

# Create an ASE atom object
atoms = bulk('Si', 'diamond', a=5.43, cubic=True)
atoms.set_positions(atoms.get_positions() + np.random.rand(*atoms.get_positions().shape) * 0.1)

# Initialize the SevenNetCalculator
calculator = SevenNetCalculator(
    path=MODEL_PATH,
    device='cuda' if os.environ.get('SEVENN_USE_CUDA', 'false').lower() == 'true' else 'cpu'
)
atoms.set_calculator(calculator)

# Get energy and forces
energy = atoms.get_potential_energy()
forces = atoms.get_forces()
stress = atoms.get_stress()

print(f"Energy: {energy:.4f} eV")
print(f"Forces (first atom): {forces[0]}")
print(f"Stress: {stress}")

# Clean up (optional, if you're done with the calculator)
calculator.cleanup()

view raw JSON →