# yamllint disable rule:line-length
# This tutorial config file is meant to complement the "User Guide" docs: https://nequip.readthedocs.io/en/latest/guide/guide.html
# New users are advised to read the config page before continuing: https://nequip.readthedocs.io/en/latest/guide/configuration/config.html

# ===========
#     RUN
# ===========
# the run types will be completed in sequence
# one can do `train`, `val`, `test` run types
run: [train, test]


# the following parameters (cutoff_radius, chemical_symbols, model_type_names, monitored_metric) are not used directly by the config parser
# but parameters that should share the same values are present in different parts of the config
# thus, we use variable interpolation to keep their multiple instances consistent
# i.e. we only ever have to change the values here instead of everywhere it's necessary to

# data and model r_max can be different (model's r_max should be smaller), but we try to make them the same
cutoff_radius: 5.0

# variable interpolation is convenient for wandb sweeps, see documentation for more details
# the following are NequIP model hyperparameters that can be swept over
num_layers: 4       # number of interaction blocks, we find 3-5 to work best
l_max: 1            # the maximum irrep order (rotation order) for the network's features, l=1 is a good default, l=2 is more accurate but slower
num_features: 32    # the multiplicity of the features, 32 is a good default for accurate network, if you want to be more accurate, go larger, if you want to be faster, go lower

# There are two sets of atomic types to keep track of in most applications.
# There is the conventional atomic species (e.g. C, H), and a separate `type_names` known to the model.
# The model only knows types based on a set of zero-based indices and user-given `type_names` argument.
# An example where this distinction is necessary include datasets with the same atomic species with different charge states:
# we could define `chemical_species: [C, C]` and model `type_names: [C3, C4]` for +3 and +4 charge states.
# There could also be instances such as coarse graining we only care about the model's `type_names` (no need to define chemical species).
# Because of this distinction, these variables show up as arguments across different categories, including, data, model, metrics and even callbacks.
# In this case, we fix both to be the same, so we define a single set of each here and use variable interpolation to retrieve them below.
# This ensures a single location where the values are set to reduce the chances of misconfiguring runs.
model_type_names: [C, H, O, Cu]
chemical_species: ${model_type_names}

# We want a metric to condition training on (e.g. for best `ModelCheckpoint`, `EarlyStopping`, LR scheduling) which will show up in various places later on, so we set up a "single source of truth" to interpolate over
# see https://nequip.readthedocs.io/en/latest/guide/configuration/metrics.html
monitored_metric: val0_epoch/weighted_sum


# ============
#     DATA
# ============
# New users are advised to read the "Data Configuration" docs before continuing: https://nequip.readthedocs.io/en/latest/guide/configuration/data.html
data:
  _target_: nequip.data.datamodule.ASEDataModule
  seed: 456             # dataset seed for reproducibility

  # here we take an ASE-readable file (in extxyz format) and split it into train:val:test = 80:10:10
  split_dataset:
    file_path: FragmentChainExtension/FragmentChainExtensionTraining.xyz
    train: 0.9
    val: 0.05
    test: 0.05

  # `transforms` convert data from the Dataset to a form that can be used by the ML model
  transforms:
    # the models only know atom types, which can be different from the chemical species (e.g. C, H)
    # in this case, the atom types are the same as the chemical species (H, C, O, Cu), so we can omit
    # `chemical_species_to_atom_type_map` and it will default to an identity mapping
    # if `model_type_names` were something like ["my_H", "carbon", "oxygen", "copper"], then you would need
    # to explicitly provide the mapping: chemical_species_to_atom_type_map: {H: my_H, C: carbon, O: oxygen, Cu: copper}
    - _target_: nequip.data.transforms.ChemicalSpeciesToAtomTypeMapper
      model_type_names: ${model_type_names}
      # chemical_species_to_atom_type_map: ${list_to_identity_dict:${chemical_species}}
    # data doesn't usually come with a neighborlist -- this transform prepares the neighborlist
    - _target_: nequip.data.transforms.NeighborListTransform
      r_max: ${cutoff_radius}

  # the following are torch.utils.data.DataLoader configs,
  # excluding the arguments `dataset` and `collate_fn`
  # https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader
  train_dataloader:
    _target_: torch.utils.data.DataLoader
    batch_size: 5
    num_workers: 5
    shuffle: true
  val_dataloader:
    _target_: torch.utils.data.DataLoader
    batch_size: 10
    num_workers: ${data.train_dataloader.num_workers}  # we want to use the same num_workers -- variable interpolation helps
  test_dataloader: ${data.val_dataloader}  # variable interpolation comes in handy again

  # dataset statistics can be calculated to be used for model initialization such as for shifting, scaling and standardizing.
  # it is advised to provide custom names -- you will have to retrieve them later under model to initialize certain parameters to the dataset statistics computed
  stats_manager:
    # dataset statistics is handled by the `DataStatisticsManager`
    # here, we use `CommonDataStatisticsManager` for a basic set of dataset statistics for general use cases
    # the dataset statistics include `num_neighbors_mean`, `per_atom_energy_mean`, `forces_rms`, `per_type_forces_rms`
    _target_: nequip.data.CommonDataStatisticsManager
    # dataloader kwargs for data statistics computation
    # `batch_size` should ideally be as large as possible without triggering OOM
    dataloader_kwargs:
      batch_size: 10
    # we need to provide the same type names that correspond to the model's `type_names`
    # so we interpolate the "central source of truth" model type names from above
    type_names: ${model_type_names}


# =============
#    TRAINER
# =============
# `trainer` is a `Lightning.Trainer` object (https://lightning.ai/docs/pytorch/stable/common/trainer.html#trainer-class-api)
trainer:
  _target_: lightning.Trainer
  accelerator: gpu
  enable_checkpointing: true
  max_epochs: 1000
  max_time: 03:00:00:00
  log_every_n_steps: 20       # how often to log

  # use any Lightning supported logger
  logger:
    # Lightning wandb logger https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb
    _target_: lightning.pytorch.loggers.wandb.WandbLogger
    project: nequip
    name: tutorial
    save_dir: ${hydra:runtime.output_dir}  # use resolver to place wandb logs in hydra's output directory

  # use any Lightning callbacks https://lightning.ai/docs/pytorch/stable/api_references.html#callbacks
  # and any custom callbacks that subclass Lightning's Callback parent class
  callbacks:

    # https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.callbacks.EarlyStopping.html#lightning.pytorch.callbacks.EarlyStopping
    - _target_: lightning.pytorch.callbacks.EarlyStopping
      monitor: ${monitored_metric}            # validation metric to monitor
      min_delta: 1e-3                         # how much to be considered a "change"
      patience: 20                            # how many instances of "no change" before stopping

    # https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.callbacks.ModelCheckpoint.html#lightning.pytorch.callbacks.ModelCheckpoint
    - _target_: lightning.pytorch.callbacks.ModelCheckpoint
      monitor: ${monitored_metric}            # validation metric to monitor
      dirpath: ${hydra:runtime.output_dir}    # use hydra output directory
      filename: best                          # `best.ckpt` is the checkpoint name
      save_last: true                         # `last.ckpt` will be saved

    # https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.callbacks.LearningRateMonitor.html#lightning.pytorch.callbacks.LearningRateMonitor
    - _target_: lightning.pytorch.callbacks.LearningRateMonitor
      logging_interval: epoch


# =====================
#    TRAINING MODULE
# =====================
# training_module refers to a `NequIPLightningModule` or its subclass
# here we use the subclass that holds an exponential moving average of the base model's weights (an EMA model)
# one could also use the base `NequIPLightningModule` here if one does not want to use an EMA model
# EMA allows for smoother validation curves and thus more reliable metrics for monitoring
# Loading from a checkpoint for use in the `nequip.ase.NequIPCalculator` or during `nequip-compile` and `nequip-package` will always load the EMA model if it's present
training_module:
  _target_: nequip.train.EMALightningModule

  # the ema decay parameter of an EMA model
  ema_decay: 0.999

  # New users are advised to read the "Loss and Metrics" docs before continuing: https://nequip.readthedocs.io/en/latest/guide/configuration/metrics.html
  loss:
    _target_: nequip.train.EnergyForceLoss
    per_atom_energy: true
    coeffs:
      total_energy: 1.0
      forces: 1.0

  val_metrics:
    _target_: nequip.train.EnergyForceMetrics
    coeffs:
      total_energy_mae: 1.0
      forces_mae: 1.0
      # keys `total_energy_rmse` and `forces_rmse`, `per_atom_energy_rmse` and `per_atom_energy_mae` are also available
  # we could have train_metrics and test_metrics be different from val_metrics, but it makes sense to have them be the same
  train_metrics: ${training_module.val_metrics}  # use variable interpolation
  test_metrics: ${training_module.val_metrics}  # use variable interpolation

  # any torch compatible optimizer: https://pytorch.org/docs/stable/optim.html#algorithms
  optimizer:
    _target_: torch.optim.Adam
    lr: 0.01

  # see options for lr_scheduler_config
  # https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.core.LightningModule.html#lightning.pytorch.core.LightningModule.configure_optimizers
  lr_scheduler:
    # any torch compatible lr scheduler
    scheduler:
      _target_: torch.optim.lr_scheduler.ReduceLROnPlateau
      factor: 0.6
      patience: 5
      threshold: 0.2
      min_lr: 1e-6
    monitor: ${monitored_metric}
    interval: epoch
    frequency: 1

  # model: https://nequip.readthedocs.io/en/latest/api/nequip_model.html
  model:
    _target_: nequip.model.NequIPGNNModel

    # If you have PyTorch >= 2.6.0 installed, and are training on GPUs, the following line uses torch.compile to speed up training
    # for more details, see https://nequip.readthedocs.io/en/latest/guide/accelerations/pt2_compilation.html
    compile_mode: compile
    # ^ if you're using PyTorch <= 2.6.0, an error will be thrown -- comment out the line to avoid it

    # == basic model params ==
    seed: 456
    model_dtype: float32
    type_names: ${model_type_names}
    r_max: ${cutoff_radius}

    # == bessel encoding ==
    num_bessels: 8                # number of basis functions used in the radial Bessel basis, the default of 8 usually works well
    bessel_trainable: false       # set true to train the bessel weights (default false)
    polynomial_cutoff_p: 6        # p-exponent used in polynomial cutoff function, smaller p corresponds to stronger decay with distance

    # == convnet layers ==
    num_layers: ${num_layers}      # number of interaction blocks, we find 3-5 to work best
    l_max: ${l_max}                # the maximum irrep order (rotation order) for the network's features, l=1 is a good default, l=2 is more accurate but slower
    parity: true                   # whether to include features with odd mirror parity; often turning parity off gives equally good results but faster networks, so do consider this
    num_features: ${num_features}  # the multiplicity of the features, 32 is a good default for accurate network, if you want to be more accurate, go larger, if you want to be faster, go lower

    # it is also possible to provide the multiplicity for each irrep, e.g. for l_max=1 and parity=False, the following refers to 5x0e + 2x1o features
    # num_features: [5, 2]

    # == radial network ==
    radial_mlp_depth: 2            # number of radial layers, usually 1-3 works best, smaller is faster
    radial_mlp_width: 64           # number of hidden neurons in radial function, smaller is faster
    # ^ we could have programatically set `radial_mlp_width` to be twice `num_features` using NequIP's built in `int_mul` resolver, e.g.
    # radial_mlp_width: ${int_mul:${num_features},2}
    # the NequIP framework implements `int_mul` and `int_div`

    # see https://nequip.readthedocs.io/en/latest/guide/configuration/model.html to understand the following hyperparameters

    # dataset statistics used to inform the model's initial parameters for normalization, shifting and rescaling
    # we use omegaconf's resolvers (https://omegaconf.readthedocs.io/en/2.3_branch/usage.html#resolvers)
    # to facilitate getting the dataset statistics from the `DataStatisticsManager`

    # average number of neighbors for edge sum normalization
    avg_num_neighbors: ${training_data_stats:num_neighbors_mean}

    # == per-type per-atom scales and shifts ==
    per_type_energy_scales: ${training_data_stats:per_type_forces_rms}
    per_type_energy_shifts: ${training_data_stats:per_atom_energy_mean}
    # ^ IMPORTANT: it is usually useful and important to use isolated atom energies computed with the same method used to generate the training data
    #   they should be provided as a dict, e.g.
    # per_type_energy_shifts:
    #   C: 1.234
    #   H: 2.345
    #   O: 3.456
    #   Cu: 4.567
    per_type_energy_scales_trainable: false
    per_type_energy_shifts_trainable: false

    # == ZBL pair potential ==
    # useful as a prior for core repulsion to mitigate MD failure modes associated with atoms getting too close
    # docs: https://nequip.readthedocs.io/en/latest/api/nn.html#nequip.nn.pair_potential.ZBL
    pair_potential:
      _target_: nequip.nn.pair_potential.ZBL
      units: metal     # Ang and kcal/mol; LAMMPS unit names;  allowed values "metal" and "real"
      chemical_species: ${chemical_species}   # must tell ZBL the chemical species of the various model atom types