# Copyright (C) 2022-3 Intel Corporation # SPDX-License-Identifier: MIT License from __future__ import annotations from abc import ABC, abstractmethod from collections.abc import Iterable from contextlib import ExitStack, nullcontext from pathlib import Path from typing import Any, Callable, ContextManager, Dict, List, Optional, Type, Union from warnings import warn import pytorch_lightning as pl import torch import torchmetrics from einops import reduce from matsciml.common import package_registry from matsciml.common.registry import registry from matsciml.common.types import AbstractGraph, BatchDict, DataDict, Embeddings from matsciml.models.common import OutputHead from matsciml.modules.normalizer import Normalizer from torch import Tensor, nn from torch.optim import AdamW, Optimizer, lr_scheduler if package_registry["dgl"]: import dgl if package_registry["pyg"]: import torch_geometric as pyg __all__ = [ "AbstractEnergyModel", "ScalarRegressionTask", "BinaryClassificationTask", "ForceRegressionTask", "CrystalSymmetryClassificationTask", "MultiTaskLitModule", "OpenCatalystInference", "IS2REInference", "S2EFInference", ] """ base.py This module implements all the base classes for task and model abstraction. The way models and tasks are meant to be composed is as follows: An abstract GNN architecture inherits from either `AbstractS2EFModel` or `AbstractIS2REModel`: this abstracts out things like force computation in the former, where the `forward` pass computes the energy, and the class implements the `compute_force` method that uses autograd for the force. The GNN model is then passed as "the model" within a PyTorch Lightning Module, which takes care of all the loss computation, normalization, logging, and CPU/GPU/TPU transfers. """ def decorate_color(color: str): """This creates a logging function with flair""" def debug_message(logger, message: str) -> None: logger.debug(f"\033{color} {message}\033[00m") return debug_message # set up different colors for logging debug_green = decorate_color("[92m") debug_lightpurple = decorate_color("[94m") debug_cyan = decorate_color("[96m") def dynamic_gradients_context(need_grad: bool, has_rnn: bool) -> ContextManager: """ Conditional gradient context manager, based on whether or not force computation is necessary in the process. This is necessary because there are actually two contexts necessary: enable gradient computation _and_ make sure we aren't in inference mode, which is enabled by PyTorch Lightning for faster inference. If this is `regress_forces` is set to False, a `nullcontext` is applied that does nothing. Parameters ---------- need_grad : bool Flag to designate whether or not gradients need to be forced within this code block. has_rnn : bool Flag to indicate whether or not RNNs are being used in this model, which will disable cudnn to enable double backprop. Returns ------- ContextManager Joint context, combining `inference_mode` and `enable_grad`, otherwise a `nullcontext` if `need_grad` is `False`. """ manager = ExitStack() if need_grad: contexts = [torch.inference_mode(False), torch.enable_grad()] # if we're also using CUDA, there is an additional context to allow # RNNs to do double backprop if torch.cuda.is_available() and has_rnn: contexts.append(torch.backends.cudnn.flags(enabled=False)) for cxt in contexts: manager.enter_context(cxt) else: manager.enter_context(nullcontext()) return manager def rnn_force_train_mode(module: nn.Module) -> None: """ Forces RNN subclasses into training mode to facilitate derivatives for force computation outside of training steps. See https://docs.nvidia.com/deeplearning/cudnn/api/index.html#cudnnRNNForward Parameters ---------- module : nn.Module Abstract `torch.nn.Module` to check and toggle """ # this try/except will catch non-CUDA enabled systems # this patch is only for cudnn try: _ = torch.cuda.current_device() if isinstance(module, nn.RNNBase): module.train() except AssertionError: pass def lit_conditional_grad(regress_forces: bool): """ Decorator function that will dynamically enable gradient computation. An example usage for this decorator is given in the `S2EFLitModule.forward` call, where we determine at runtime whether or not to enable gradients for the force computation by wrapping the embedded `gnn.forward` method. Parameters ---------- regress_forces : bool Specifies whether or not to regress forces; if so, enable gradient computation. """ def decorator(func): def cls_method(self, *args, **kwargs): f = func if regress_forces: f = torch.enable_grad()(func) return f(self, *args, **kwargs) return cls_method return decorator def prepend_affix(metrics: dict[str, torch.Tensor], affix: str) -> None: """ Mutate a dictionary in place, prepending an affix to keys. This is primarily for logging metrics, where we want to denote something originating from train/test/validation, etc. Parameters ---------- metrics : Dict[str, torch.Tensor] Dictionary containing metrics affix : str Affix to prepend each key, for example "train" for training metrics. """ keys = list(metrics.keys()) for key in keys: metrics[f"{affix}.{key}"] = metrics[key] del metrics[key] class BaseModel(nn.Module): def __init__(self, num_atoms=None, bond_feat_dim=None, num_targets=None): super().__init__() self.num_atoms = num_atoms self.bond_feat_dim = bond_feat_dim self.num_targets = num_targets def forward(self, data): raise NotImplementedError @property def num_params(self): return sum(p.numel() for p in self.parameters()) class AbstractTask(ABC, pl.LightningModule): # TODO the intention is for this class to supersede AbstractEnergyModel for DGL def __init__( self, atom_embedding_dim: int, num_atom_embedding: int = 100, embedding_kwargs: dict[str, Any] = {}, encoder_only: bool = True, ) -> None: super().__init__() embedding_kwargs.setdefault("padding_idx", 0) self.atom_embedding = nn.Embedding( num_atom_embedding, atom_embedding_dim, **embedding_kwargs, ) self.save_hyperparameters() @property def num_params(self) -> int: return sum(p.numel() for p in self.parameters()) @property def has_rnn(self) -> bool: """ Returns True if any components of this model contains an RNN unit that inherits from 'nn.RNNBase'. """ return any([isinstance(block, nn.RNNBase) for block in self.modules()]) @abstractmethod def read_batch(self, batch: BatchDict) -> DataDict: """ This method must be implemented by subclasses to extract input data out of a batch and into a dictionary format ready to be ingested by the actual model. Parameters ---------- batch : BatchDict Batch of input data to be read Returns ------- DataDict Dictionary containing input data, i.e. graphs and other tensor structures to be passed into the model """ ... @abstractmethod def read_batch_size(self, batch: BatchDict) -> int | None: ... @abstractmethod def _forward(self, *args, **kwargs) -> Embeddings: """ Implements the actual logic of the architecture. Given a set of input features, produce outputs/predictions from the model. Returns ------- Embeddings Data structure containing system/graph and point/node level embeddings. """ ... def forward(self, batch: BatchDict) -> Embeddings: """ Given a batch structure, extract out data and pass it into the neural network architecture. This implements the 'forward' method as expected of all children of 'nn.Module'; it is not intended to be overridden, instead modify the 'read_batch' and '_forward' methods to change how this model/class of models interact with data. Parameters ---------- batch : BatchDict Batch of data to process Returns ------- Embeddings Data structure containing system/graph and point/node level embeddings. """ input_data = self.read_batch(batch) outputs = self._forward(**input_data) # raise an error to help spot models that have not yet been refactored if not isinstance(outputs, Embeddings): raise ValueError( "Encoder did not return `Embeddings` data structure: please refactor your model!", ) return outputs class AbstractPointCloudModel(AbstractTask): def read_batch(self, batch: BatchDict) -> DataDict: r""" Extract data needed for point cloud modeling from a batch. Notably, to facilitate force calculation, the point cloud "neighborhood" for atom positions is constructed **after** giving the primary task (i.e. ``ForceRegressionTask``) an opportunity to enable gradients for each sample within the point cloud. To clarify usage of ``pos`` and ``pc_pos``, the former represents the packed batch of positions without separating them into their individual point clouds: **this is used for force computation** where we want to end up with a force tensor with the same shape. ``pc_pos`` corresponds to the padded, molecule centered point cloud data that should be used as input to a point cloud model. Parameters ---------- batch : BatchDict Batch of samples to process Returns ------- DataDict Input data for a point cloud model to process, notably including particle positions and features """ from matsciml.datasets.utils import pad_point_cloud assert isinstance( batch["pos"], torch.Tensor, ), "Expect 'pos' data to be a packed tensor of shape [N, 3]" data = {key: batch.get(key) for key in ["pc_features", "pos"]} # split the stacked positions into each individual point cloud temp_pos = batch["pos"].split(batch["sizes"]) pc_pos = [] # sizes records the number of centers being used sizes = [] # loop over each sample within a batch for index, sample in enumerate(temp_pos): src_nodes, dst_nodes = batch["src_nodes"][index], batch["dst_nodes"][index] # use dst_nodes to gauge size because you will always have more # dst nodes than src nodes right now sizes.append(len(dst_nodes)) # carve out neighborhoods as dictated by the dataset/transform definition sample_pc_pos = sample[src_nodes][None, :] - sample[dst_nodes][:, None] pc_pos.append(sample_pc_pos) # pad the position result pc_pos, mask = pad_point_cloud(pc_pos, max(sizes)) # get the features and make sure the shapes are consistent for the # batch and neighborhood feat_shape = data.get("pc_features").shape assert ( pc_pos.shape[:-1] == feat_shape[:-1] ), "Shape of point cloud neighborhood positions is different from features!" data["pc_pos"] = pc_pos data["mask"] = mask data["sizes"] = sizes return data @abstractmethod def _forward( self, pc_pos: torch.Tensor, pc_features: torch.Tensor, mask: torch.Tensor | None = None, sizes: list[int] | None = None, **kwargs, ) -> Embeddings: """ Sets expected patterns for args for point cloud based modeling, whereby the bare minimum expected data are 'pos' and 'pc_features' akin to graph approaches. Parameters ---------- pc_pos : torch.Tensor Padded point cloud neighborhood tensor, with shape ``[B, N, M, 3]`` for ``B`` batch size and ``N`` padded size. For full pairwise point clouds, ``N == M``. pc_features : torch.Tensor Padded point cloud feature tensor, with shape ``[B, N, M, D_in]`` for ``B`` batch size and ``N`` padded size. For full pairwise point clouds, ``N == M``. mask : Optional[torch.Tensor], optional Boolean tensor with shape ``[B, N, M]``, by default None. If supplied in conjuction with ``sizes``, will mask out contributions from padding nodes. sizes : Optional[List[int]], optional List of integers denoting the size of the first non-batch point cloud dimension, by default None. If supplied in conjuction with ``mask``, will mask out contributions from padding nodes. Returns ------- torch.Tensor Output of a point cloud model; system-level embedding or predictions """ ... @staticmethod def mask_model_output( result: torch.Tensor, mask: torch.Tensor, sizes: list[int], extensive: bool, ) -> torch.Tensor: r""" Perform a masked reduction over a point cloud model output. This effectively removes the contributions from node centers or source particles, i.e. the first non-batch dimension, that correspond to padding nodes. The resulting shape should be ``[B, D]`` with ``B`` batch size and ``D`` desired output dimension. Parameters ---------- result : torch.Tensor Result of a point cloud model, with shape ``[B, N, M, D]`` for ``B`` batch size, ``N`` padded source nodes, ``M`` padded destination nodes, and output dimension ``D``. mask : torch.Tensor A 3D boolean tensor of shape ``[B, N, M]`` sizes : List[int] A list comprising the number of atom centers that are not padding nodes. extensive : bool If ``True``, sums over nodes, otherwise performs a mean reduction. Returns ------- torch.Tensor Per-point cloud results, with shape ``[B, D]`` """ # extract out a mask over [B, N] for N atom centers, removing # padded center node contributions to the system output center_mask = mask[..., 0] # this extracts a [N, D] tensor with N total particles, D embedding dim unpadded_result = result[center_mask] # this splits up into embeddings per node split_results = unpadded_result.split(sizes) # figure out what reduction to perform over the particles if extensive: reduce = torch.sum else: reduce = torch.mean # should be [B, D] for B systems output = torch.stack([reduce(t, dim=0) for t in split_results]) return output def read_batch_size(self, batch: BatchDict) -> None: # returns None, because batch size can be readily determined by Lightning return None class AbstractGraphModel(AbstractTask): def __init__( self, atom_embedding_dim: int, num_atom_embedding: int = 100, embedding_kwargs: dict[str, Any] = {}, encoder_only: bool = True, ) -> None: super().__init__( atom_embedding_dim, num_atom_embedding, embedding_kwargs, encoder_only, ) def read_batch(self, batch: BatchDict) -> DataDict: assert ( "graph" in batch ), f"Model {self.__class__.__name__} expects graph structures, but 'graph' key was not found in batch." graph = batch.get("graph") return {"graph": graph} @staticmethod def join_position_embeddings( pos: torch.Tensor, node_feats: torch.Tensor, ) -> torch.Tensor: """ This is a method for conveniently embedding both positions and node features together. Given that not every type of model will use this approach, it is left for concrete classes to utilize rather than being the default. Parameters ---------- pos : torch.Tensor 2D tensor with [N, 3] containing coordinates of each node in N node_feats : torch.Tensor 2D tensor with [N, D] containing features of each node in N. Typically this pertains to the embedding lookup features, but up to the developer Returns ------- torch.Tensor 2D tensor with shape [N, D + 3] """ return torch.hstack([pos, node_feats]) @abstractmethod def _forward( self, graph: AbstractGraph, node_feats: torch.Tensor, pos: torch.Tensor | None = None, edge_feats: torch.Tensor | None = None, graph_feats: torch.Tensor | None = None, **kwargs, ) -> Embeddings: """ Sets args/kwargs for the expected components of a graph-based model. At the bare minimum, we expect some kind of abstract graph structure, along with tensors of atomic coordinates and numbers to process. Optionally, models can include edge and graph features, but is left for concrete classes to implement how these are obtained. Parameters ---------- graph : AbstractGraph Graph structure implemented in a particular framework node_feats : torch.Tensor Atomic numbers or other featurizations, typically shape [N, ...] for N nuclei pos : Optional[torch.Tensor] Atom positions with shape [N, 3], by default None to make this optional as some architectures may pass them as 'node_feats' edge_feats : Optional[torch.Tensor], optional Edge features to process, by default None graph_feats : Optional[torch.Tensor], optional Graph-level attributes/features to use, by default None Returns ------- torch.Tensor Model output; either embedding or projected output """ ... if package_registry["dgl"]: class AbstractDGLModel(AbstractGraphModel): def read_batch(self, batch: BatchDict) -> DataDict: """ Extract DGLGraph structure and features to pass into the model. More complicated models can override this method to extract out edge and graph features as well. Parameters ---------- batch : BatchDict Batch of data to process. Returns ------- DataDict Dictionary of input features to pass into the model """ data = super().read_batch(batch) graph = data.get("graph") assert isinstance( graph, dgl.DGLGraph, ), f"Model {self.__class__.__name__} expects DGL graphs, but data in 'graph' key is type {type(graph)}" atomic_numbers = data["graph"].ndata["atomic_numbers"].long() node_embeddings = self.atom_embedding(atomic_numbers) pos = graph.ndata["pos"] # optionally can fuse into a single tensor with `self.join_position_embeddings` data["node_feats"] = node_embeddings data["pos"] = pos # these keys are left as None, but are filler for concrete models to extract data.setdefault("edge_feats", None) data.setdefault("graph_feats", None) return data def read_batch_size(self, batch: BatchDict) -> int: # grabs the number of batch samples from the DGLGraph attribute graph = batch["graph"] return graph.batch_size if package_registry["pyg"]: class AbstractPyGModel(AbstractGraphModel): def read_batch(self, batch: BatchDict) -> DataDict: """ Extract PyG structure and features to pass into the model. More complicated models can override this method to extract out edge and graph features as well. Parameters ---------- batch : BatchDict Batch of data to process. Returns ------- DataDict Dictionary of input features to pass into the model """ data = super().read_batch(batch) graph = data.get("graph") assert isinstance( graph, (pyg.data.Data, pyg.data.Batch), ), f"Model {self.__class__.__name__} expects PyG graphs, but data in 'graph' key is type {type(graph)}" for key in ["edge_feats", "graph_feats"]: data[key] = getattr(graph, key, None) atomic_numbers: torch.Tensor = getattr(graph, "atomic_numbers").to( torch.int, ) node_embeddings = self.atom_embedding(atomic_numbers) pos: torch.Tensor = getattr(graph, "pos") # optionally can fuse into a single tensor with `self.join_position_embeddings` data["node_feats"] = node_embeddings data["pos"] = pos return data def read_batch_size(self, batch: BatchDict) -> int: graph = batch["graph"] return graph.num_graphs class AbstractEnergyModel(pl.LightningModule): """ At a minimum, the point of this is to help register associated models with PyTorch Lightning ModelRegistry; the expectation is that you get the graph energy as well as the atom forces. TODO - replace this class with `AbstractTask`, see #167 and #168 """ def __init__(self): super().__init__() self.save_hyperparameters() def forward(self, graph: dgl.DGLGraph) -> Tensor: """ Implements the basic forward call for an S2EF task; given a graph, predict the energy. Force computation relies on a decorated version of this function, which is used by the `S2EFLitModule`. Parameters ---------- graph : dgl.DGLGraph A DGL graph object Returns ------- Tensor A float Tensor containing the energy of each graph, shape [G, 1] for G graphs """ energy = self.forward(graph) return energy @registry.register_task("BaseTaskModule") class BaseTaskModule(pl.LightningModule): __task__ = None __needs_grads__ = [] def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module | None = None, task_keys: list[str] | None = None, output_kwargs: dict[str, Any] = {}, lr: float = 1e-4, weight_decay: float = 0.0, embedding_reduction_type: str = "mean", normalize_kwargs: dict[str, float] | None = None, scheduler_kwargs: dict[str, dict[str, Any]] | None = None, **kwargs, ) -> None: super().__init__() if encoder is not None: warn( f"Encoder object was passed directly into {self.__class__.__name__}; saved hyperparameters will be incomplete!", ) if encoder_class is not None and encoder_kwargs: try: encoder = encoder_class(**encoder_kwargs) except: # noqa: E722 raise ValueError( f"Unable to instantiate encoder {encoder_class} with kwargs: {encoder_kwargs}.", ) if encoder is not None: self.encoder = encoder else: raise ValueError("No valid encoder passed.") if isinstance(loss_func, type): loss_func = loss_func() self.loss_func = loss_func default_heads = {"act_last": None, "hidden_dim": 128} default_heads.update(output_kwargs) self.output_kwargs = default_heads self.normalize_kwargs = normalize_kwargs self.task_keys = task_keys if "task_loss_scaling" in kwargs: if kwargs["task_loss_scaling"] is not None: self.task_loss_scaling = kwargs["task_loss_scaling"] else: self.task_loss_scaling = dict(zip(task_keys, [1] * len(task_keys))) self.embedding_reduction_type = embedding_reduction_type self.save_hyperparameters(ignore=["encoder", "loss_func"]) accuracy_func = kwargs.get("accuracy_func", None) if accuracy_func is not None: self.accuracy_func = accuracy_func( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), ) self.accuracy_func_5 = accuracy_func( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=5, ) self.accuracy_func_10 = accuracy_func( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=10, ) self._precision = torchmetrics.Precision( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), ) self._precision_5 = torchmetrics.Precision( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=5, ) self._precision_10 = torchmetrics.Precision( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=10, ) self.recall = torchmetrics.Recall( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), ) self.recall_5 = torchmetrics.Recall( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=5, ) self.recall_10 = torchmetrics.Recall( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=10, ) self.f1 = torchmetrics.F1Score( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), ) self.f1_5 = torchmetrics.F1Score( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=5, ) self.f1_10 = torchmetrics.F1Score( task=kwargs["classification_type"], num_classes=kwargs.get("num_classes", None), top_k=10, ) else: self.accuracy_func = accuracy_func @property def task_keys(self) -> list[str]: return self._task_keys @task_keys.setter def task_keys(self, values: set | list[str] | None) -> None: """ Ensures that the task keys are unique. Parameters ---------- values : Union[set, List[str]] Array of keys to use to look up targets. """ if values is None: values = [] if isinstance(values, list): values = set(values) if isinstance(values, set): values = list(values) self._task_keys = values # if we're setting task keys we have enough to initialize # the output heads if not self.has_initialized: self.output_heads = self._make_output_heads() self.normalizers = self._make_normalizers() self.hparams["task_keys"] = self._task_keys @property def has_initialized(self) -> bool: if len(self.task_keys) == 0: return False output_heads = getattr(self, "output_heads", None) if output_heads is None: return False # basically if we've passed these two assertions, we should have # all the heads. We can't check against self.task_keys, because # some tasks like ForceRegressionTask doesn't actually use an output # head for the forces return True @abstractmethod def _make_output_heads(self) -> nn.ModuleDict: ... @property def output_heads(self) -> nn.ModuleDict: return self._output_heads @output_heads.setter def output_heads(self, heads: nn.ModuleDict) -> None: assert isinstance( heads, nn.ModuleDict, ), "Output heads must be an instance of `nn.ModuleDict`." assert len(heads) > 0, f"No output heads in {heads}." assert all( [key in self.task_keys for key in heads.keys()], ), f"Output head keys {heads.keys()} do not match any in tasks: {self.task_keys}." self._output_heads = heads @property def num_heads(self) -> int: return len(self.task_keys) @property def uses_normalizers(self) -> bool: # property determines if we normalize targets or not norms = getattr(self, "normalizers", None) if norms is None or self.__task__ in ["classification", "symmetry"]: return False return True @property def has_rnn(self) -> bool: """ Property to determine whether or not this LightningModule contains RNNs. This is primarily to determine whether or not to enable/disable contexts with cudnn, as double backprop is not supported. Returns ------- bool True if any module is a subclass of `RNNBase`, otherwise False. """ return any([isinstance(module, nn.RNNBase) for module in self.modules()]) def forward( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: if "embeddings" in batch: embedding = batch.get("embeddings") else: embedding = self.encoder(batch) outputs = self.process_embedding(embedding) return outputs def process_embedding(self, embeddings: Embeddings) -> dict[str, torch.Tensor]: """ Given a set of embeddings, output predictions for each head. Parameters ---------- embeddings : torch.Tensor Batch of graph/point cloud embeddings Returns ------- Dict[str, torch.Tensor] Predictions per output head """ results = {} for key, head in self.output_heads.items(): # in the event that we get multiple embeddings, we average # every dimension execpt the batch and dimensionality output = head(embeddings.system_embedding) output = reduce( output, "b ... d -> b d", reduction=self.embedding_reduction_type, ) results[key] = output return results def _get_targets( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: """ Method for extracting targets out of a batch. Ultimately it is up to the individual task to determine how to obtain a dictionary of target tensors to use for loss computation, but this implements the base logic assuming everything is neatly in the "targets" key of a batch. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples from the dataset. Returns ------- Dict[str, torch.Tensor] A flat dictionary containing target tensors. """ target_dict = {} assert len(self.task_keys) != 0, "No target keys were set!" for key in self.task_keys: target_dict[key] = batch["targets"][key] return target_dict def _filter_task_keys( self, keys: list[str], batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> list[str]: """ Implement a mechanism for filtering out keys for targets. The base class simply returns the keys without modification. Parameters ---------- keys : List[str] List of task keys batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of training samples to inspect. Returns ------- List[str] List of filtered task keys """ return keys def _compute_losses( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor | dict[str, torch.Tensor]]: """ Compute pred versus target for every target, then sum. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples to evaluate on. embeddings : Optional[torch.Tensor] If provided, bypasses calling the encoder and obtains predictions from processing the embeddings. Mainly intended for use with multitask abstraction. Returns ------- Dict[str, Union[torch.Tensor, Dict[str, torch.Tensor]]] Dictionary containing the joint loss, and a subdictionary containing each individual target loss. """ # targets = self._get_targets(batch) # predictions = self(batch) # losses = {} # for key in self.task_keys: # target_val = targets[key] # if self.uses_normalizers: # target_val = self.normalizers[key].norm(target_val) # losses[key] = self.loss_func(predictions[key], target_val) # total_loss: torch.Tensor = sum(losses.values()) # return {"loss": total_loss, "log": losses} targets = self._get_targets(batch) predictions = self(batch) losses = {} accuracies = {} precisions = {} recalls = {} f1s = {} for key in self.task_keys: target_val = targets[key] if self.uses_normalizers: target_val = self.normalizers[key].norm(target_val) # if predictions[key].shape[-1] >1: # preds = torch.argmax(predictions[key], axis=1) # else: preds = predictions[key] if self.accuracy_func is not None: accuracies[key] = self.accuracy_func(preds, target_val) accuracies[f"{key}_5"] = self.accuracy_func_5(preds, target_val) accuracies[f"{key}_10"] = self.accuracy_func_10(preds, target_val) precisions[key] = self._precision(preds, target_val) precisions[f"{key}_5"] = self._precision_5(preds, target_val) precisions[f"{key}_10"] = self._precision_10(preds, target_val) recalls[key] = self.recall(preds, target_val) recalls[f"{key}_5"] = self.recall_5(preds, target_val) recalls[f"{key}_10"] = self.recall_10(preds, target_val) f1s[key] = self.f1(preds, target_val) f1s[f"{key}_5"] = self.f1_5(preds, target_val) f1s[f"{key}_10"] = self.f1_10(preds, target_val) loss = self.loss_func(predictions[key], target_val) loss = loss * self.task_loss_scaling[key] losses[key] = loss total_loss: torch.Tensor = sum(losses.values()) total_accuracy: torch.Tensor = sum(accuracies.values()) log_dict = {} for k, v in losses.items(): log_dict[f"{k}"] = v for k, v in accuracies.items(): log_dict[f"{k}_acc"] = v for k, v in precisions.items(): log_dict[f"{k}_precision"] = v for k, v in recalls.items(): log_dict[f"{k}_recall"] = v for k, v in f1s.items(): log_dict[f"{k}_f1s"] = v return { "loss": total_loss, "log": log_dict, "acc": total_accuracy, } def configure_optimizers(self) -> torch.optim.AdamW: opt = torch.optim.AdamW( self.parameters(), lr=self.hparams.lr, weight_decay=self.hparams.weight_decay, ) # configure schedulers as a nested dictionary schedule_dict = getattr(self.hparams, "scheduler_kwargs", None) schedulers = [] if schedule_dict: for scheduler_name, params in schedule_dict.items(): # try get the scheduler class scheduler_class = getattr(lr_scheduler, scheduler_name, None) if not scheduler_class: raise NameError( f"{scheduler_class} was requested for LR scheduling, but is not in 'torch.optim.lr_scheduler'.", ) scheduler = scheduler_class(opt, **params) schedulers.append(scheduler) return [opt], schedulers def training_step( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], batch_idx: int, ): loss_dict = self._compute_losses(batch) metrics = {} # prepending training flag for for key, value in loss_dict["log"].items(): metrics[f"train_{key}"] = value try: batch_size = self.encoder.read_batch_size(batch) except: # noqa: E722 warn( "Unable to parse batch size from data, defaulting to `None` for logging.", ) batch_size = None self.log_dict(metrics, on_step=True, prog_bar=True, batch_size=batch_size) return loss_dict def validation_step( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], batch_idx: int, ): loss_dict = self._compute_losses(batch) metrics = {} # prepending training flag for for key, value in loss_dict["log"].items(): metrics[f"val_{key}"] = value try: batch_size = self.encoder.read_batch_size(batch) except: # noqa: E722 warn( "Unable to parse batch size from data, defaulting to `None` for logging.", ) batch_size = None self.log_dict(metrics, batch_size=batch_size, sync_dist=True) return loss_dict def test_step( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], batch_idx: int, ): loss_dict = self._compute_losses(batch) metrics = {} # prepending training flag for for key, value in loss_dict["log"].items(): metrics[f"test_{key}"] = value try: batch_size = self.encoder.read_batch_size(batch) except: # noqa: E722 warn( "Unable to parse batch size from data, defaulting to `None` for logging.", ) batch_size = None self.log_dict(metrics, batch_size=batch_size, sync_dist=True) return loss_dict def _make_normalizers(self) -> dict[str, Normalizer]: """ Instantiate a set of normalizers for targets associated with this task. Assumes that task keys has been set correctly, and the default behavior will use normalizers with a mean and standard deviation of zero and one. Returns ------- Dict[str, Normalizer] Normalizers for each target """ if self.normalize_kwargs is not None: norm_kwargs = self.normalize_kwargs else: norm_kwargs = {} normalizers = {} for key in self.task_keys: mean = norm_kwargs.get(f"{key}_mean", 0.0) std = norm_kwargs.get(f"{key}_std", 1.0) normalizers[key] = Normalizer(mean=mean, std=std, device=self.device) return normalizers def predict(self, batch: BatchDict) -> dict[str, torch.Tensor]: """ Implements what is effectively the 'inference' logic of the task, where run the forward pass on a batch of samples, and if normalizers were used for training, we also apply the inverse operation to get values in the right scale. Not to be confused with `predict_step`, which is used by Lightning as part of the prediction workflow. Since there is no one-size-fits-all inference workflow we can define, this provides a convenient function for users to call as a replacement. Parameters ---------- batch : BatchDict Batch of samples to pass to the model. Returns ------- dict[str, torch.Tensor] Output dictionary as provided by the forward pass, but if normalizers are available for a given task, we apply the inverse norm on the value. """ # use EMA weights instead if they are available if hasattr(self, "ema_module"): wrapper = self.ema_module else: wrapper = self outputs = wrapper(batch) if self.uses_normalizers: for key in self.task_keys: if key in self.normalizers: # apply the inverse transform if provided outputs[key] = self.normalizers[key].denorm(outputs[key]) return outputs @classmethod def from_pretrained_encoder(cls, task_ckpt_path: str | Path, **kwargs): """ Attempts to instantiate a new task, adopting a previously trained encoder model. This function will load in a saved PyTorch Lightning checkpoint, copy over the hyperparameters needed to reconstruct the encoder, and simply maps the encoder ``state_dict`` to the new instance. ``Kwargs`` are passed directly into the creation of the task, and so can be thought of as just a task through the typical interface normally. Parameters ---------- task_ckpt_path : Union[str, Path] Path to an existing task checkpoint file. Typically, this would be a PyTorch Lightning checkpoint. Examples -------- 1. Create a new task simply from training another one >>> new_task = ScalarRegressionTask.from_pretrained_encoder( "epoch=10-step=100.ckpt" ) 2. Create a new task, modifying output heads >>> new_taks = ForceRegressionTask.from_pretrained_encoder( "epoch=5-step=12516.ckpt", output_kwargs={ "num_hidden": 3, "activation": "nn.ReLU" } ) """ if isinstance(task_ckpt_path, str): task_ckpt_path = Path(task_ckpt_path) assert ( task_ckpt_path.exists() ), "Encoder checkpoint filepath specified but does not exist." ckpt = torch.load(task_ckpt_path) for key in ["encoder_class", "encoder_kwargs"]: assert ( key in ckpt["hyper_parameters"] ), f"{key} expected to be in hyperparameters, but was not found." # copy over the data for the new task kwargs[key] = ckpt["hyper_parameters"][key] # construct the new task with random weights task = cls(**kwargs) # this only copies over encoder weights, and removes the 'encoder.' # pattern from keys encoder_weights = { key.replace("encoder.", ""): tensor for key, tensor in ckpt["state_dict"].items() if "encoder." in key } # load in pre-trained weights task.encoder.load_state_dict(encoder_weights) return task @registry.register_task("ScalarRegressionTask") class ScalarRegressionTask(BaseTaskModule): __task__ = "regression" """ NOTE: You can have multiple targets, but each target is scalar. """ def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module = nn.MSELoss, task_keys: list[str] | None = None, output_kwargs: dict[str, Any] = {}, **kwargs: Any, ) -> None: super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, task_keys, output_kwargs, **kwargs, ) self.save_hyperparameters(ignore=["encoder", "loss_func"]) def _make_output_heads(self) -> nn.ModuleDict: modules = {} for key in self.task_keys: modules[key] = OutputHead(1, **self.output_kwargs).to(self.device) return nn.ModuleDict(modules) def _filter_task_keys( self, keys: list[str], batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> list[str]: """ Filters out task keys for scalar regression. This routine will filter out keys with targets that are multidimensional, since this is the _scalar_ regression task class. Parameters ---------- keys : List[str] List of task keys batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of training samples to inspect. Returns ------- List[str] List of filtered task keys """ keys = super()._filter_task_keys(keys, batch) def checker(key) -> bool: # this ignores all non-tensor objects, and checks to make # sure the last target dimension is scalar target = batch["targets"][key] if isinstance(target, torch.Tensor): return target.size(-1) <= 1 return False # this filters out targets that are multidimensional keys = list(filter(checker, keys)) return keys def on_train_batch_start(self, batch: Any, batch_idx: int) -> int | None: """ PyTorch Lightning hook to check OutputHeads are created. This will take data from the batch to determine which key to retrieve data from and how many heads to create. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of data from data loader. batch_idx : int Batch index. unused PyTorch Lightning hangover Returns ------- Optional[int] Just returns the parent result. """ status = super().on_train_batch_start(batch, batch_idx) # if there are no task keys set, task has not been initialized yet if len(self.task_keys) == 0: keys = batch["target_types"]["regression"] self.task_keys = self._filter_task_keys(keys, batch) # now add the parameters to our task's optimizer opt = self.optimizers() opt.add_param_group({"params": self.output_heads.parameters()}) # create normalizers for each target self.normalizers = self._make_normalizers() return status def on_validation_batch_start( self, batch: any, batch_idx: int, dataloader_idx: int = 0, ): self.on_train_batch_start(batch, batch_idx) @registry.register_task("MaceEnergyForceTask") class MaceEnergyForceTask(BaseTaskModule): __task__ = "regression" """ Class for training MACE on energy and forces """ def __init__( self, encoder: Optional[nn.Module] = None, encoder_class: Optional[Type[nn.Module]] = None, encoder_kwargs: Optional[Dict[str, Any]] = None, loss_func: Union[Type[nn.Module], nn.Module] = nn.MSELoss, loss_coeff: Optional[Dict[str, Any]] = None, task_keys: Optional[List[str]] = None, output_kwargs: Dict[str, Any] = {}, **kwargs: Any, ) -> None: super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, task_keys, output_kwargs, **kwargs, ) self.save_hyperparameters(ignore=["encoder", "loss_func"]) self.loss_coeff = loss_coeff def process_embedding(self, embeddings: Embeddings) -> Dict[str, torch.Tensor]: """ Given a set of embeddings, output predictions for each head. Parameters ---------- embeddings : torch.Tensor Batch of graph/point cloud embeddings Returns ------- Dict[str, torch.Tensor] Predictions per output head """ results = {} for key, head in self.output_heads.items(): # in the event that we get multiple embeddings, we average # every dimension execpt the batch and dimensionality output = head(embeddings.system_embedding[key]) output = reduce(output, "b ... d -> b d", reduction="mean") results[key] = output return results def _compute_losses( self, batch: Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]], ) -> Dict[str, Union[torch.Tensor, Dict[str, torch.Tensor]]]: """ Compute pred versus target for every target, then sum. With coefficients defined for each key Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples to evaluate on. embeddings : Optional[torch.Tensor] If provided, bypasses calling the encoder and obtains predictions from processing the embeddings. Mainly intended for use with multitask abstraction. Returns ------- Dict[str, Union[torch.Tensor, Dict[str, torch.Tensor]]] Dictionary containing the joint loss, and a subdictionary containing each individual target loss. """ targets = self._get_targets(batch) predictions = self(batch) losses = {} for key in self.task_keys: target_val = targets[key] if self.uses_normalizers: target_val = self.normalizers[key].norm(target_val) if self.loss_coeff is None: coefficient = 1.0 else: coefficient = self.loss_coeff[key] losses[key] = self.loss_func(predictions[key], target_val) * ( coefficient / predictions[key].numel() ) total_loss: torch.Tensor = sum(losses.values()) return {"loss": total_loss, "log": losses} def _make_output_heads(self) -> nn.ModuleDict: modules = {} for key in self.task_keys: modules[key] = OutputHead(**self.output_kwargs[key]).to(self.device) return nn.ModuleDict(modules) def _filter_task_keys( self, keys: List[str], batch: Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]], ) -> List[str]: """ Filters out task keys for scalar regression. This routine will filter out keys with targets that are multidimensional, since this is the _scalar_ regression task class. Parameters ---------- keys : List[str] List of task keys batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of training samples to inspect. Returns ------- List[str] List of filtered task keys """ keys = super()._filter_task_keys(keys, batch) def checker(key) -> bool: # this ignores all non-tensor objects, and checks to make # sure the last target dimension is scalar target = batch["targets"][key] if isinstance(target, torch.Tensor): return target.size(-1) <= 1 return False # this filters out targets that are multidimensional keys = list(filter(checker, keys)) return keys def validation_step( self, batch: Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]], batch_idx: int, ): with torch.enable_grad(): # Enabled gradient for Force computation loss_dict = self._compute_losses(batch) metrics = {} # prepending training flag for for key, value in loss_dict["log"].items(): metrics[f"val_{key}"] = value try: batch_size = self.encoder.read_batch_size(batch) except: # noqa: E722 warn( "Unable to parse batch size from data, defaulting to `None` for logging." ) batch_size = None self.log_dict(metrics, batch_size=batch_size, sync_dist=True) return loss_dict def test_step( self, batch: Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]], batch_idx: int, ): with torch.enable_grad(): # Enabled gradient for Force computation loss_dict = self._compute_losses(batch) metrics = {} # prepending training flag for for key, value in loss_dict["log"].items(): metrics[f"test_{key}"] = value try: batch_size = self.encoder.read_batch_size(batch) except: # noqa: E722 warn( "Unable to parse batch size from data, defaulting to `None` for logging." ) batch_size = None self.log_dict(metrics, batch_size=batch_size, sync_dist=True) return loss_dict def on_train_batch_start(self, batch: Any, batch_idx: int) -> Optional[int]: """ PyTorch Lightning hook to check OutputHeads are created. This will take data from the batch to determine which key to retrieve data from and how many heads to create. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of data from data loader. batch_idx : int Batch index. unused PyTorch Lightning hangover Returns ------- Optional[int] Just returns the parent result. """ status = super().on_train_batch_start(batch, batch_idx) # if there are no task keys set, task has not been initialized yet if len(self.task_keys) == 0: keys = batch["target_types"]["regression"] self.task_keys = self._filter_task_keys(keys, batch) # now add the parameters to our task's optimizer opt = self.optimizers() opt.add_param_group({"params": self.output_heads.parameters()}) # create normalizers for each target self.normalizers = self._make_normalizers() return status def on_validation_batch_start( self, batch: any, batch_idx: int, dataloader_idx: int = 0 ): self.on_train_batch_start(batch, batch_idx) @registry.register_task("BinaryClassificationTask") class BinaryClassificationTask(BaseTaskModule): __task__ = "classification" """ Same as the regression case; you can have multiple targets, but each target has to be a binary classification task. Output heads will produce logits by default alongside BCEWithLogitsLoss for computation; if otherwise, requires user intervention. """ def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module = nn.BCEWithLogitsLoss, task_keys: list[str] | None = None, output_kwargs: dict[str, Any] = {}, **kwargs, ) -> None: super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, task_keys, output_kwargs, **kwargs, ) self.save_hyperparameters(ignore=["encoder", "loss_func"]) def _make_output_heads(self) -> nn.ModuleDict: modules = {} for key in self.task_keys: modules[key] = OutputHead(1, **self.output_kwargs).to(self.device) return nn.ModuleDict(modules) def on_train_batch_start(self, batch: Any, batch_idx: int) -> int | None: """ PyTorch Lightning hook to check OutputHeads are created. This will take data from the batch to determine which key to retrieve data from and how many heads to create. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of data from data loader. batch_idx : int Batch index. unused PyTorch Lightning hangover Returns ------- Optional[int] Just returns the parent result. """ status = super().on_train_batch_start(batch, batch_idx) # if there are no task keys set, task has not been initialized yet if len(self.task_keys) == 0: keys = batch["target_types"]["classification"] self.task_keys = keys # now add the parameters to our task's optimizer opt = self.optimizers() opt.add_param_group({"params": self.output_heads.parameters()}) return status def on_validation_batch_start( self, batch: Any, batch_idx: int, dataloader_idx: int = 0, ): self.on_train_batch_start(batch, batch_idx) @registry.register_task("ForceRegressionTask") class ForceRegressionTask(BaseTaskModule): __task__ = "force_regression" __needs_grads__ = ["pos"] def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module = nn.L1Loss, task_keys: list[str] | None = None, output_kwargs: dict[str, Any] = {}, embedding_reduction_type: str = "sum", **kwargs, ) -> None: super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, task_keys, output_kwargs, embedding_reduction_type=embedding_reduction_type, **kwargs, ) self.save_hyperparameters(ignore=["encoder", "loss_func"]) # have to enable double backprop self.automatic_optimization = False def _make_output_heads(self) -> nn.ModuleDict: # this task only utilizes one output head modules = {"energy": OutputHead(1, **self.output_kwargs).to(self.device)} return nn.ModuleDict(modules) def forward( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: # for ease of use, this task will always compute forces #del batch["embeddings"] with dynamic_gradients_context(True, self.has_rnn): # first ensure that positions tensor is backprop ready if "graph" in batch: graph = batch["graph"] cell = batch["cell"] # the DGL case if hasattr(graph, "ndata"): pos: torch.Tensor = graph.ndata.get("pos") # for frame averaging fa_rot = graph.ndata.get("fa_rot", None) fa_pos = graph.ndata.get("fa_pos", None) graph.ndata["pos"] = pos else: # otherwise assume it's PyG pos: torch.Tensor = graph.pos # for frame averaging fa_rot = getattr(graph, "fa_rot", None) fa_pos = getattr(graph, "fa_pos", None) cell = getattr(graph, "cell", None) else: graph = None # assume point cloud otherwise pos: torch.Tensor = batch.get("pos") # no frame averaging architecture yet for point clouds fa_rot = None fa_pos = None if pos is None: raise ValueError( "No atomic positions were found in batch - neither as standalone tensor nor graph.", ) if isinstance(pos, torch.Tensor): pos.requires_grad_(True) displacement = torch.zeros( (1, 3, 3), dtype=pos.dtype, device=pos.device, ) displacement.requires_grad_(True) symmetric_displacement = 0.5 * ( displacement + displacement.transpose(-1, -2) ) # From https://github.com/mir-group/nequip pos = pos + torch.einsum( "be,bec->bc", pos, symmetric_displacement, ) if "graph" in batch: graph.pos = pos if hasattr(graph, "ndata"): graph.ndata["pos"] = pos if fa_pos is not None: for k in range(len(fa_pos)): fa_pos[0].requires_grad_(True) fa_pos[0] = fa_pos[0] + torch.einsum( "be,bec->bc", pos, symmetric_displacement, ) elif isinstance(pos, list): [p.requires_grad_(True) for p in pos] else: raise ValueError( f"'pos' data is required for force calculation, but isn't a tensor or a list of tensors: {type(pos)}.", ) if isinstance(fa_pos, torch.Tensor): fa_pos.requires_grad_(True) elif isinstance(fa_pos, list): [f_p.requires_grad_(True) for f_p in fa_pos] if "embeddings" in batch: embeddings = batch.get("embeddings") else: embeddings = self.encoder(batch) natoms = batch.get("natoms", None) outputs = self.process_embedding( embeddings, pos, displacement, cell, fa_rot, fa_pos, natoms, graph ) return outputs def process_embedding( self, embeddings: Embeddings, pos: torch.Tensor, displacement: torch.Tensor, cell: torch.Tensor, fa_rot: None | torch.Tensor = None, fa_pos: None | torch.Tensor = None, natoms: None | torch.Tensor = None, graph: None | AbstractGraph = None, ) -> dict[str, torch.Tensor]: outputs = {} # compute node-level contributions to the energy node_energies = self.output_heads["energy"](embeddings.point_embedding) # figure out how we're going to reduce node level energies # depending on the representation and/or the graph framework if graph is not None: if isinstance(graph, dgl.DGLGraph): graph.ndata["node_energies"] = node_energies def readout(node_energies: torch.Tensor): return dgl.readout_nodes( graph, "node_energies", op=self.embedding_reduction_type ) else: # assumes a batched pyg graph batch = graph.batch from torch_geometric.utils import scatter def readout(node_energies: torch.Tensor): return scatter( node_energies, batch, dim=-2, reduce=self.embedding_reduction_type, ) else: def readout(node_energies: torch.Tensor): return reduce( node_energies, "b ... d -> b ()", self.embedding_reduction_type ) def energy_and_force( pos: torch.Tensor, displacement: torch.Tensor, cell: torch.Tensor, node_energies: torch.Tensor, readout: Callable, ) -> tuple[torch.Tensor, torch.Tensor]: # we sum over points and keep dimension as 1 energy = readout(node_energies) if energy.ndim == 1: energy.unsqueeze(-1) # now use autograd for force calculation # force = ( # -1 # * torch.autograd.grad( # energy, # pos, # grad_outputs=torch.ones_like(energy), # create_graph=True, # )[0] # ) forces, virials = torch.autograd.grad( outputs=[energy], # [n_graphs, ] inputs=[pos, displacement], # [n_nodes, 3] retain_graph=True, # Make sure the graph is not destroyed during training create_graph=True, # Create graph for second derivative allow_unused=True, ) cell = cell.view(-1, 3, 3) volume = torch.einsum( "zi,zi->z", cell[:, 0, :], torch.cross(cell[:, 1, :], cell[:, 2, :], dim=1), ).unsqueeze(-1) stress = virials / volume.view(-1, 1, 1) return energy, -1 * forces, stress # not using frame averaging if fa_pos is None: energy, force, stress = energy_and_force( pos, displacement, cell, node_energies, readout ) else: energy = [] force = [] stress = [] for idx, pos in enumerate(fa_pos): frame_embedding = node_energies[:, idx, :] frame_energy, frame_force, frame_stress = energy_and_force( pos, displacement, cell, frame_embedding, readout ) force.append(frame_force) energy.append(frame_energy.unsqueeze(-1)) stress.append(frame_stress) # check to see if we are frame averaging if fa_rot is not None: all_forces = [] # loop over each frame prediction, and transform to guarantee # equivariance of frame averaging method natoms = natoms.squeeze(-1).to(int) for frame_idx, frame_rot in enumerate(fa_rot): repeat_rot = torch.repeat_interleave( frame_rot, natoms, dim=0, ).to(self.device) rotated_forces = ( force[frame_idx].view(-1, 1, 3).bmm(repeat_rot.transpose(1, 2)) ) all_forces.append(rotated_forces) # combine all the force and energy data into a single tensor # using frame averaging, the expected shapes after concatenation are: # force - [num positions, num frames, 3] # energy - [batch size, num frames, 1] force = torch.cat(all_forces, dim=1) energy = torch.cat(energy, dim=1) stress = torch.cat(stress, dim=1) # reduce outputs to what are expected shapes outputs["force"] = reduce( force, "n ... d -> n d", self.embedding_reduction_type, d=3, ) # this may not do anything if we aren't frame averaging # since the reduction is also done in the energy_and_force call outputs["energy"] = reduce( energy, "b ... d -> b d", self.embedding_reduction_type, d=1, ) # this ensures that we get a scalar value for every node # representing the energy contribution outputs["node_energies"] = node_energies outputs["stress"] = stress return outputs def predict(self, batch: BatchDict) -> dict[str, torch.Tensor]: """ Similar to the base method, but we make two minor modifications to the denormalization logic as we want to potentially apply the same energy normalization rescaling to the forces and node-level energies. Parameters ---------- batch : BatchDict Batch of samples to evaluate on. Returns ------- dict[str, torch.Tensor] Output dictionary as provided by the forward call. For this task in particular, we may also apply the energy rescaling to forces and node energies if separate keys for them are not provided. """ output = super().predict(batch) # for forces, in the event that a dedicated normalizer wasn't provided # but we have an energy normalizer, we apply the same factors to the force if self.uses_normalizers: if "force" not in self.normalizers and "energy" in self.normalizers: # for force only std is used to rescale output["force"] = output["force"] * self.normalizers["energy"].std output["stress"] = output["stress"] * self.normalizers["energy"].std if "node_energies" not in self.normalizers and "energy" in self.normalizers: output["node_energies"] = self.normalizers["energy"].denorm( output["node_energies"] ) # print('ye walla use krna hai') return output def _get_targets( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: """ Extract out the energy and force targets from a batch. The intended behavior is similar to other tasks, however explicit because we actually expect "energy" and "force" keys as opposed to inferring them from a batch. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples to evaluate Returns ------- Dict[str, torch.Tensor] Dictionary containing targets to evaluate against Raises ------ KeyError If either "energy" or "force" keys aren't found in the "targets" dictionary within a batch, we abort the program. """ target_dict = {} for key in ["energy", "force"]: try: target_dict[key] = batch["targets"][key] except KeyError as e: raise KeyError( f"{key} was not found in targets key in batch, which is needed for force regression task.", ) from e return target_dict def on_train_batch_start(self, batch: Any, batch_idx: int) -> int | None: """ PyTorch Lightning hook to check OutputHeads are created. This will take data from the batch to determine which key to retrieve data from and how many heads to create. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of data from data loader. batch_idx : int Batch index. unused PyTorch Lightning hangover Returns ------- Optional[int] Just returns the parent result. """ status = super().on_train_batch_start(batch, batch_idx) # if there are no task keys set, task has not been initialized yet if len(self.task_keys) == 0: # first round is used to initialize the output head self.task_keys = ["energy"] self.output_heads = self._make_output_heads() # overwrite it so that the loss is computed but we don't make another head # for force outputs self._task_keys = ["energy", "force"] # now add the parameters to our task's optimizer opt = self.optimizers() opt.add_param_group({"params": self.output_heads.parameters()}) # create normalizers for each target self.normalizers = self._make_normalizers() return status def training_step( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], batch_idx: int, ): """ Implements the training logic for force regression. This task uses manual optimization to facilitate double backprop, but by in large functions in the same way as other tasks. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph]] A dictionary of batched data from the S2EF dataset. batch_idx : int Index of the batch being processed. Returns ------- Dict[str, Union[float, Dict[str, float]]] Nested dictionary of losses """ opt = self.optimizers() self.on_before_zero_grad(opt) opt.zero_grad() # compute losses loss_dict = self._compute_losses(batch) loss = loss_dict["loss"] # sandwich lightning callbacks self.manual_backward(loss, retain_graph=True) self.manual_backward(loss) self.on_before_optimizer_step(opt) opt.step() metrics = {} # prepending training flag for key, value in loss_dict["log"].items(): metrics[f"train_{key}"] = value try: batch_size = self.encoder.read_batch_size(batch) except: # noqa: E722 warn( "Unable to parse batch size from data, defaulting to `None` for logging.", ) batch_size = None self.log_dict(metrics, on_step=True, prog_bar=True, batch_size=batch_size) return loss_dict @registry.register_task("GradFreeForceRegressionTask") class GradFreeForceRegressionTask(ScalarRegressionTask): __task__ = "gff_regression" def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module = nn.MSELoss, output_kwargs: dict[str, Any] = {}, **kwargs: Any, ) -> None: if "task_keys" in kwargs: warn( f"GradFreeForceRegressionTask does not `task_keys`; " f"ignoring passed keys: {kwargs['task_keys']}", ) del kwargs["task_keys"] super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, ["force"], output_kwargs, **kwargs, ) def _make_output_heads(self) -> nn.ModuleDict: modules = {"force": OutputHead(3, **self.output_kwargs).to(self.device)} return nn.ModuleDict(modules) def _get_targets( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: """ Extract out the energy and force targets from a batch. The intended behavior is similar to other tasks, however explicit because we actually expect "energy" and "force" keys as opposed to inferring them from a batch. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples to evaluate Returns ------- Dict[str, torch.Tensor] Dictionary containing targets to evaluate against Raises ------ KeyError If either "energy" or "force" keys aren't found in the "targets" dictionary within a batch, we abort the program. """ if "force" not in batch["targets"]: raise KeyError( f"Force key missing in batch targets: keys found: {batch['targets'].keys()}", ) target_dict = {"force": batch["targets"]["force"]} return target_dict def forward( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: if "embeddings" in batch: embedding = batch.get("embeddings") else: embedding = self.encoder(batch) # check for frame averaging if "graph" in batch: graph = batch["graph"] if hasattr(graph, "ndata"): fa_rot = getattr(graph.ndata, "fa_rot", None) else: fa_rot = getattr(graph, "fa_rot", None) outputs = self.process_embedding(embedding, fa_rot) return outputs def process_embedding( self, embeddings: Embeddings, fa_rot: None | torch.Tensor = None, ) -> dict[str, torch.Tensor]: """ Given point/node-level embeddings, predict forces of each point. Parameters ---------- embeddings : Embeddings Data structure containing system/graph and point/node-level embeddings. Returns ------- Dict[str, torch.Tensor] Dictionary containing a ``force`` key that maps to predicted forces per point/node """ results = {} force_head = self.output_heads["force"] forces = force_head(embeddings.point_embedding) if isinstance(fa_rot, torch.Tensor): natoms = forces.size(0) all_forces = [] # loop over each frame prediction, and transform to guarantee # equivariance of frame averaging method for frame_idx, frame_rot in fa_rot: repeat_rot = torch.repeat_interleave( frame_rot, natoms, dim=0, ).to(self.device) rotated_forces = ( forces[:, frame_idx, :] .view(-1, 1, 3) .bmm( repeat_rot.transpose(1, 2), ) ) all_forces.append(rotated_forces.view(natoms, 3)) # combine all the force data into a single tensor forces = torch.stack(all_forces, dim=1) # make sure forces are in the right shape forces = reduce(forces, "n ... d -> n d", self.embedding_reduction_type, d=3) results["force"] = forces return results @registry.register_task("CrystalSymmetryClassificationTask") class CrystalSymmetryClassificationTask(BaseTaskModule): __task__ = "symmetry" def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module = nn.CrossEntropyLoss, output_kwargs: dict[str, Any] = {}, normalize_kwargs: dict[str, float] | None = None, freeze_embedding: bool = False, **kwargs, ) -> None: super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, [ "spacegroup", ], output_kwargs, normalize_kwargs=normalize_kwargs, **kwargs, ) self.freeze_embedding = freeze_embedding if self.freeze_embedding: self.encoder.atom_embedding.requires_grad_(False) def _make_output_heads(self) -> nn.ModuleDict: # this task only utilizes one output head; 230 possible space groups modules = {"spacegroup": OutputHead(230, **self.output_kwargs).to(self.device)} return nn.ModuleDict(modules) def on_train_batch_start(self, batch: Any, batch_idx: int) -> int | None: """ PyTorch Lightning hook to check OutputHeads are created. This will take data from the batch to determine which key to retrieve data from and how many heads to create. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of data from data loader. batch_idx : int Batch index. unused PyTorch Lightning hangover Returns ------- Optional[int] Just returns the parent result. """ status = super().on_train_batch_start(batch, batch_idx) # if there are no task keys set, task has not been initialized yet if len(self.task_keys) == 0: self.task_keys = [ "spacegroup", ] # now add the parameters to our task's optimizer opt = self.optimizers() opt.add_param_group({"params": self.output_heads.parameters()}) return status def on_validation_batch_start( self, batch: Any, batch_idx: int, dataloader_idx: int = 0, ): self.on_train_batch_start(batch, batch_idx) def _get_targets( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> dict[str, torch.Tensor]: target_dict = {} subdict = batch.get("symmetry", None) if subdict is None: raise ValueError( "'symmetry' key is missing from batch, which is needed for space group classification.", ) labels: torch.Tensor = subdict.get("number", None) if labels is None: raise ValueError( "Point group numbers missing from symmetry key, which is needed for symmetry classification.", ) # subtract one for zero-indexing labels = labels.long() - 1 # cast to long type, and make sure it is 1D for cross entropy loss if labels.ndim > 1: labels = labels.flatten() target_dict["spacegroup"] = labels return target_dict @registry.register_task("MultiTaskLitModule") class MultiTaskLitModule(pl.LightningModule): def __init__( self, *tasks: tuple[str, BaseTaskModule], task_scaling: Iterable[float] | None = None, task_keys: dict[str, list[str]] | None = None, **encoder_opt_kwargs, ) -> None: """ High level module for orchestrating multiple tasks. Keep in mind that multiple tasks is distinct from multiple datasets: this class can be used for multiple tasks even with a single dataset for example regression and classification in Materials Project. Parameters ---------- *tasks : Tuple[str, BaseTaskModule] A variable number of 2-tuples, each comprising the dataset name and the task associated. Example would be ('MaterialsProjectDataset', RegressionTask). """ super().__init__() assert len(tasks) > 0, "No tasks provided." # hold a set of dataset mappings task_map = nn.ModuleDict() self.encoder = tasks[0][1].encoder dset_names = set() subtask_hparams = {} task_counts = {} for index, entry in enumerate(tasks): # unpack tuple (dset_name, task) = entry if dset_name not in task_map: task_map[dset_name] = nn.ModuleDict() # set the task's encoder to be the same model instance except # the first to avoid recursion if index != 0: task.encoder = self.encoder # nest the task based on its category if task.__task__ in task_counts.keys(): task_counts[task.__task__] += 1 else: task_counts[task.__task__] = 0 task_map[dset_name][f"{task.__task__}{task_counts[task.__task__]}"] = task # task_map[dset_name][task.__task__] = task # add dataset names to determine forward logic dset_names.add(dset_name) # save hyperparameters from subtasks subtask_hparams[f"{dset_name}_{task.__class__.__name__}"] = task.hparams self.save_hyperparameters( { "subtask_hparams": subtask_hparams, "task_scaling": task_scaling, "encoder_opt_kwargs": encoder_opt_kwargs, }, ) self.task_map = task_map self.dataset_names = dset_names self.task_scaling = task_scaling self.encoder_opt_kwargs = encoder_opt_kwargs if task_keys is not None: for pair in self.dataset_task_pairs: # unpack 2-tuple dataset_name, task_type = pair relevant_keys = task_keys[dataset_name][task_type] self._initialize_subtask_output( dataset_name, task_type, task_keys=relevant_keys, ) self.configure_optimizers() self.automatic_optimization = False @property def task_list(self) -> list[BaseTaskModule]: # return a flat list of tasks to iterate over modules = [] for task_group in self.task_map.values(): for subtask in task_group.values(): modules.append(subtask) return modules @property def dataset_task_pairs(self) -> list[tuple[str, str]]: # Return a list of 2-tuples corresponding to (dataset name, task type) pairs = [] for dataset in self.dataset_names: task_types = self.task_map[dataset].keys() for task_type in task_types: pairs.append((dataset, task_type)) return pairs def configure_optimizers(self) -> list[Optimizer]: """ Configure subtask optimizers, as well as the joint encoder optimizer. The main logic of this function is to aggregate all of the subtask optimizers together, if they haven't been added yet. This is done by assuming dataset name/task type combinations are unique, and we rely on the subtask's own `configure_optimizers` function. The latter half of the function adds the encoder optimizer. Returns ------- List[Optimizer] List of optimizers that are subsequently passed into Lightning's internal mechanisms """ optimizers = [] # this keeps a list of 2-tuples to index optimizers self.optimizer_names = [] # iterate over tasks index = 0 for data_key, tasks in self.task_map.items(): for task_type, subtask in tasks.items(): combo = (data_key, task_type) if combo not in self.optimizer_names: output_head = getattr(subtask, "output_heads", None) assert ( output_head is not None ), f"{subtask} does not contain output heads; ensure `task_keys` are set: {subtask.task_keys}" optimizer = subtask.configure_optimizers() if isinstance(optimizer, tuple): # unpack the two things if a tuple is returned optimizer, scheduler = optimizer if isinstance(optimizer, list): # we only work with one optimizer optimizer = optimizer[0] # remove all the optimizer parameters, and re-add only the output heads optimizer.param_groups.clear() optimizer.add_param_group({"params": output_head.parameters()}) # add optimizer to the pile optimizers.append(optimizer) self.optimizer_names.append((data_key, task_type)) index += 1 assert ( len(self.optimizer_names) > 1 ), "Only one optimizer was found for multi-task training." if ("Global", "Encoder") not in self.optimizer_names: opt_kwargs = {"lr": 1e-4} opt_kwargs.update(self.encoder_opt_kwargs) optimizers.append(AdamW(self.encoder.parameters(), **opt_kwargs)) self.optimizer_names.append(("Global", "Encoder")) return optimizers @property def dataset_names(self) -> list[str]: return self._dataset_names @dataset_names.setter def dataset_names(self, values: set | list[str]) -> None: if isinstance(values, set): values = list(values) self._dataset_names = values @property def task_scaling(self) -> list[float]: """ Returns a list of scaling factors used task importance. These values are applied to the loss values prior to backprop. Returns ------- List[float] List of scaling factors for each task """ return self._task_scaling @task_scaling.setter def task_scaling(self, values: Iterable[float] | None) -> None: if values is None: values = [1.0 for _ in range(self.num_tasks)] assert ( len(values) == self.num_tasks ), "Number of provided task scaling values not equal to number of tasks." self._task_scaling = values @property def num_tasks(self) -> int: """ Return the total number of tasks. Returns ------- int Number of tasks, aggregated over all datasets. """ counter = 0 # basically loop over datasets, and add up number of tasks # per dataset for tasks in self.task_map.values(): counter += len(tasks) return counter @property def is_multidata(self) -> bool: # convenient property to determine how to unpack batches return len(self.dataset_names) > 1 @property def has_initialized(self) -> bool: """ Property to track if subtasks have been initialized. Right now this is manually set, but would like to refactor this later to check if subtask output heads are all set. Returns ------- bool True if first batch has been run already, otherwise False """ return all([task.has_initialized for task in self.task_list]) @property def input_grad_keys(self) -> dict[str, list[str]]: """ Property to returns a list of keys for inputs that need gradient tracking. Returns ------- Union[List[str], None] If there are tasks in this multitask that need input variables to have gradients tracked, this property will return a list of them. Otherwise, this returns None. """ keys = {} if self.is_multidata: for dset_name, task_group in self.task_map.items(): if dset_name not in keys: keys[dset_name] = set() dset_keyset = keys.get(dset_name) for subtask in task_group.values(): dset_keyset.update(subtask.__needs_grads__) else: tasks = list(self.task_map.values()).pop(0) keys[self.dataset_names[0]] = set() for task in tasks: keys[self.dataset_names[0]].update(task.__needs_grads__) keys = {dset_name: sorted(subkeys) for dset_name, subkeys in keys.items()} return keys @property def has_rnn(self) -> bool: """ Property to determine whether or not this LightningModule contains RNNs. This is primarily to determine whether or not to enable/disable contexts with cudnn, as double backprop is not supported. Returns ------- bool True if any module is a subclass of `RNNBase`, otherwise False. """ return any([isinstance(module, nn.RNNBase) for module in self.modules()]) @property def needs_dynamic_grads(self) -> bool: """ Boolean property reflecting whether this multitask in general needs gradient computation to override inference modes. Returns ------- bool True if any datasets need input grads, otherwise False """ return sum([len(keys) for keys in self.input_grad_keys.values()]) > 0 def _toggle_input_grads( self, batch: dict[ str, dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ], ) -> None: """ Inplace method that will automatically enable gradient tracking for tensors needed by tasks/datasets. This function will loop over a batch of data (in the multidata case) and grabs the list of tensor keys as required by a given subtask. The list of tensor keys are then used to grab the input data from the batch and/or graph, and if it's found will then try and set requires_grad_(True). Parameters ---------- batch : Dict[str, Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]]] Batch of data """ need_grad_keys = getattr(self, "input_grad_keys", None) if need_grad_keys is not None: if self.is_multidata: # if this is a multidataset task, loop over each dataset # and enable gradients for the inputs that need them for dset_name, data in batch.items(): input_keys = need_grad_keys.get(dset_name) for key in input_keys: # set require grad for both point cloud and graph tensors if "graph" in data: g = data.get("g") if isinstance(g, dgl.DGLGraph): if key in g.ndata: data["graph"].ndata[key].requires_grad_(True) else: # assume it's a PyG graph if key in g: getattr(g, key).requires_grad_(True) if key in data: target = data.get(key) # for tensors just set them directly if isinstance(target, torch.Tensor): target.requires_grad_(True) else: # assume the remaining case are lists of tensors try: [t.requires_grad_(True) for t in target] except AttributeError: pass else: # in the single dataset case, we just need to loop over a single # set of tasks input_keys = list(self.input_grad_keys.values()).pop(0) for key in input_keys: # set require grad for both point cloud and graph tensors if "graph" in data: g = data.get("g") if isinstance(g, dgl.DGLGraph): if key in g.ndata: data["graph"].ndata[key].requires_grad_(True) else: # assume it's a PyG graph if key in g: getattr(g, key).requires_grad_(True) if key in data: target = data.get(key) # for tensors just set them directly if isinstance(target, torch.Tensor): target.requires_grad_(True) else: # assume the remaining case are lists of tensors try: [t.requires_grad_(True) for t in target] except AttributeError: pass def forward( self, batch: dict[ str, dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ], ) -> dict[str, dict[str, torch.Tensor]]: """ Forward method for `MultiTaskLitModule`. This is devised slightly specially to comprise a variety of scenarios, including wrapping the entire compute in gradient contexts (for force prediction tasks), ensuring inputs that need gradients are enabled, as well as running the encoder at the beginning and passing the embeddings onto downstream tasks. Parameters ---------- batch : Dict[str, Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]]] Batches of samples per dataset Returns ------- Dict[str, Dict[str, torch.Tensor]] Dictionary of predictions, per dataset per subtask """ # iterate over datasets in the batch results = {} _grads = getattr( self, "needs_dynamic_grads", False, ) # default to not needing grads with dynamic_gradients_context(_grads, self.has_rnn): # this function switches of `requires_grad_` for input tensors that need them self._toggle_input_grads(batch) # compute embeddings for each dataset if self.is_multidata: for key, data in batch.items(): data["embeddings"] = self.encoder(data) else: batch["embeddings"] = self.encoder(batch) # for single dataset usage, we assume the nested structure isn't used if self.is_multidata: for key, data in batch.items(): subtasks = self.task_map[key] if key not in results: results[key] = {} # finally call the task with the data for task_type, subtask in subtasks.items(): results[key][task_type] = subtask(data) else: # in the single dataset case, we can skip the outer loop # and just pass the batch into the subtask tasks = list(self.task_map.values()).pop(0) for task_type, subtask in tasks.items(): results[task_type] = subtask(batch) return results def on_train_batch_start(self, batch: Any, batch_idx: int) -> None: """ This callback is used to dynamically initialize output heads. In the event where `task_keys` are not explicitly provided by the user into the creation of each task, we the incoming batch for tasks that have not been initialized and create the output heads. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples to compute batch_idx : int Batch index unused : int Legacy PyTorch Lightning arg """ # this follows what's implemented in forward to ensure the # output heads and optimizers are set properly if not self.has_initialized: if self.is_multidata: for dataset in batch.keys(): subtasks = self.task_map[dataset] for task_type in subtasks.keys(): self._initialize_subtask_output(dataset, task_type, batch) else: # skip grabbing dataset key from the batch tasks = list(self.task_map.values()).pop(0) dataset = list(self.task_map.keys()).pop(0) for task_type in tasks.keys(): self._initialize_subtask_output(dataset, task_type, batch) return None def _compute_losses( self, batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ): """ Function for computing the losses over a batch. This relies on the `_compute_losses` function of each subtask. Between the single dataset and multidataset settings, the difference is just how the tasks are retrieved; the former skips going through the dataset/task hierarchy. Parameters ---------- batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of samples to calculate losses over """ # compute predictions for required models losses = {} if self.is_multidata: for key, data in batch.items(): subtasks = self.task_map[key] if key not in losses: losses[key] = {} for task_type, subtask in subtasks.items(): losses[key][task_type] = subtask._compute_losses(data) else: tasks = list(self.task_map.values()).pop(0) for task_type, subtask in tasks.items(): losses[task_type] = subtask._compute_losses(batch) return losses def _initialize_subtask_output( self, dataset: str, task_type: str, batch: None | ( dict[ str, dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ] ) = None, task_keys: list[str] | None = None, ): """ For a given dataset and task type, this function will check and initialize corresponding output heads and add them to the corresponding optimizer. The behavior of this function changes depending on whether or not the output heads were initialized earlier (i.e. before `on_train_batch_start`), based on whether it sees an incoming batch, or explicitly passed `task_keys`. In the former, we will add the output head parameters to the appropriate optimizer as well. Parameters ---------- dataset : str Name of the dataset task_type : str String classification of the task type, e.g. "regression" batch : Optional[Dict[str, Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]]]] For "dynamically" instantiating multitasks, this function relies on an incoming batch to determine what output heads to instantiate. """ task_instance: BaseTaskModule = self.task_map[dataset][task_type] if batch is None and task_keys is None: raise ValueError( f"Unable to initialize output heads for {dataset}-{task_type}; neither batch nor task keys provided.", ) if not task_instance.has_initialized: # get the task keys from the batch, depends on usage if batch is not None: if self.is_multidata: subset = batch[dataset] else: subset = batch if task_keys is None: task_keys = subset["target_types"][task_type] # if keys aren't explicitly provided, apply filter task_keys = task_instance._filter_task_keys(task_keys, subset) # set task keys, then call make output heads task_instance.task_keys = task_keys if task_type == "regression": task_instance.normalizers = task_instance._make_normalizers() if batch is not None: # if batch was provided then this is done after configure_optimizers # so we need to add their parameters to the right optimizer ref = (dataset, task_type) opt_index = self.optimizer_names.index(ref) # this adds the output head weights to optimizer self.optimizers()[opt_index].add_param_group( {"params": task_instance.output_heads.parameters()}, ) def embed(self, *args, **kwargs) -> Any: return self.encoder(*args, **kwargs) def _calculate_batch_size( self, batch: dict[ str, dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ], ) -> dict[str, int | dict[str, int]]: """ Compute the size of a given batch. For multidata runs, this will sum over each of the subsets, providing a breakdown of how many samples from each respective dataset as well. Parameters ---------- batch : Dict[str, Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]]] Batch of samples. Returns ------- Dict[str, Union[int, Dict[str, int]]] Dictionary holding the batch size. For multidata runs, an additional "breakdown" key comprises the number of samples from each dataset. """ batch_info = {} batch_size = 0 if self.is_multidata: break_down = {} for dataset, subset in batch.items(): # extract out targets to figure batch size for this subset of data if "graph" in subset: counts = subset["graph"].batch_size elif len(subset["targets"]) > 0: key = next(iter(batch["targets"])) sample = subset["targets"][key] if isinstance(sample, dgl.DGLGraph): counts = sample.batch_size elif isinstance(sample, torch.Tensor): # assume first dimension is the batch size counts = sample.size(0) else: # assume the object is like a list counts = len(sample) # track how much data from each dataset break_down[dataset] = counts batch_size += counts batch_info["breakdown"] = break_down else: if "graph" in batch: batch_size = batch["graph"].batch_size elif len(batch["targets"]) > 0: key = next(iter(batch["targets"])) sample = batch["targets"][key] if isinstance(sample, dgl.DGLGraph): batch_size = sample.batch_size elif isinstance(sample, torch.Tensor): # assume first dimension is the batch size batch_size = sample.size(0) else: # assume the object is like a list batch_size = len(sample) batch_info["batch_size"] = batch_size return batch_info def __repr__(self) -> str: build_str = "MultiTask Training module:\n" for dataset, tasks in self.task_map.items(): for task_type in tasks.keys(): build_str += f"{dataset}-{task_type}\n" return build_str def training_step( self, batch: dict[ str, dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ], batch_idx: int, ) -> dict[str, dict[str, torch.Tensor]]: """ Manual training logic for multi tasks. We sequentially step through each loss returned, and perform backpropagation. The logic looks complicated, because we have to match each loss with its corresponding optimizer. Parameters ---------- batch : Dict[str, Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]]] Batch of data from one or more datasets. batch_idx : int Index of current batch """ # zero all gradients optimizers = self.optimizers() for opt in optimizers: self.on_before_zero_grad(opt) opt.zero_grad(set_to_none=True) losses = self._compute_losses(batch) loss_logging = {} # for multiple datasets, we step through each dataset if self.is_multidata: for dataset_name, task_loss in losses.items(): for task_name, subtask_loss in task_loss.items(): # get the right optimizer by indexing our lookup list ref = (dataset_name, task_name) opt_index = self.optimizer_names.index(ref) # backprop gradients opt = optimizers[opt_index] is_last_opt = opt_index == len(self.optimizer_names) - 2 # run hooks between backward self.on_before_backward(subtask_loss["loss"]) # scale loss values in task scaling = self.task_scaling[opt_index] subtask_loss["loss"] = subtask_loss["loss"] * scaling subtask_loss["loss"].backward(retain_graph=not is_last_opt) # self.manual_backward( # subtask_loss["loss"] * scaling, # retain_graph=not is_last_opt, # ) self.on_after_backward() prepend_affix(subtask_loss["log"], dataset_name) loss_logging.update(subtask_loss["log"]) # for single dataset, we can just unpack the dictionary directly else: dataset_name = self.dataset_names[0] for task_name, loss in losses.items(): opt_index = self.optimizer_names.index((dataset_name, task_name)) opt = optimizers[opt_index] is_last_opt = opt_index == len(self.optimizer_names) - 2 # run hooks between backward self.on_before_backward(loss["loss"]) # scale loss values in task scaling = self.task_scaling[opt_index] self.manual_backward( loss["loss"] * scaling, retain_graph=not is_last_opt, ) self.on_after_backward() loss_logging.update(loss["log"]) # run before step hooks for opt_idx, opt in enumerate(optimizers): self.on_before_optimizer_step(opt) opt.step() # compoute the joint loss for logging purposes loss_logging["total_loss"] = sum(list(loss_logging.values())) # add train prefix to metric logs prepend_affix(loss_logging, "train") batch_info = self._calculate_batch_size(batch) if "breakdown" in batch_info: for key, value in batch_info["breakdown"].items(): self.log( f"{key}.num_samples", float(value), on_step=True, on_epoch=False, reduce_fx="min", ) self.log_dict( loss_logging, on_step=True, prog_bar=True, batch_size=batch_info["batch_size"], ) return losses def validation_step( self, batch: dict[ str, dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ], batch_idx: int, ) -> dict[str, dict[str, torch.Tensor]]: """ Manual training logic for multi tasks. We sequentially step through each loss returned, and perform backpropagation. The logic looks complicated, because we have to match each loss with its corresponding optimizer. Parameters ---------- batch : Dict[str, Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]]] Batch of data from one or more datasets. batch_idx : int Index of current batch """ losses = self._compute_losses(batch) loss_logging = {} # for multiple datasets, we step through each dataset if self.is_multidata: for dataset_name, task_loss in losses.items(): for task_name, subtask_loss in task_loss.items(): prepend_affix(subtask_loss["log"], dataset_name) loss_logging.update(subtask_loss["log"]) # for single dataset, we can just unpack the dictionary directly else: dataset_name = self.dataset_names[0] for task_name, loss in losses.items(): loss_logging.update(loss["log"]) # compoute the joint loss for logging purposes loss_logging["total_loss"] = sum(list(loss_logging.values())) # add train prefix to metric logs prepend_affix(loss_logging, "val") batch_info = self._calculate_batch_size(batch) if "breakdown" in batch_info: for key, value in batch_info["breakdown"].items(): self.log( f"{key}.num_samples", float(value), on_epoch=True, reduce_fx="min", sync_dist=True, ) self.log_dict( loss_logging, on_epoch=True, prog_bar=True, batch_size=batch_info["batch_size"], sync_dist=True, ) return losses @classmethod def load_from_checkpoint( cls, checkpoint_path, map_location=None, hparams_file=None, strict: bool = True, **kwargs: Any, ): raise NotImplementedError( "MultiTask should be reloaded using the `matsciml.models.multitask_from_checkpoint` function instead.", ) @classmethod def from_pretrained_encoder(cls, task_ckpt_path: str | Path, **kwargs): """ Attempts to instantiate a new task, adopting a previously trained encoder model. This function will load in a saved PyTorch Lightning checkpoint, copy over the hyperparameters needed to reconstruct the encoder, and simply maps the encoder ``state_dict`` to the new instance. ``Kwargs`` are passed directly into the creation of the task, and so can be thought of as just a task through the typical interface normally. Parameters ---------- task_ckpt_path : Union[str, Path] Path to an existing task checkpoint file. Typically, this would be a PyTorch Lightning checkpoint. Examples -------- 1. Create a new task simply from training another one >>> new_task = ScalarRegressionTask.from_pretrained_encoder( "epoch=10-step=100.ckpt" ) 2. Create a new task, modifying output heads >>> new_taks = ForceRegressionTask.from_pretrained_encoder( "epoch=5-step=12516.ckpt", output_kwargs={ "num_hidden": 3, "activation": "nn.ReLU" } ) """ if isinstance(task_ckpt_path, str): task_ckpt_path = Path(task_ckpt_path) assert ( task_ckpt_path.exists() ), "Encoder checkpoint filepath specified but does not exist." ckpt = torch.load(task_ckpt_path) for key in ["encoder_class", "encoder_kwargs"]: assert ( key in ckpt["hyper_parameters"] ), f"{key} expected to be in hyperparameters, but was not found." # copy over the data for the new task kwargs[key] = ckpt["hyper_parameters"][key] # construct the new task with random weights task = cls(**kwargs) # this only copies over encoder weights, and removes the 'encoder.' # pattern from keys encoder_weights = { key.replace("encoder.", ""): tensor for key, tensor in ckpt["state_dict"].items() if "encoder." in key } # load in pre-trained weights task.encoder.load_state_dict(encoder_weights) return task @registry.register_task("OpenCatalystInference") class OpenCatalystInference(ABC, pl.LightningModule): """ Implement a set of bare bones LightningModules that are solely used for OpenCatalyst leaderboard submissions. """ def __init__(self, pretrained_model: nn.Module) -> None: super().__init__() self.model = pretrained_model def _raise_inference_error(self): raise NotImplementedError( f"{self.__class__.__name__} is solely used for OpenCatalyst leaderboard submissions; please call 'predict' from trainer.", ) def training_step(self, *args: Any, **kwargs: Any) -> None: self._raise_inference_error() def validation_step(self, *args: Any, **kwargs: Any) -> None: self._raise_inference_error() def test_step(self, *args: Any, **kwargs: Any) -> None: self._raise_inference_error() @abstractmethod def predict_step( self, batch: Any, batch_idx: int, dataloader_idx: int = 0 ) -> Any: ... @registry.register_task("IS2REInference") class IS2REInference(OpenCatalystInference): def __init__( self, pretrained_model: AbstractEnergyModel | ScalarRegressionTask, ) -> None: assert isinstance( pretrained_model, (AbstractEnergyModel, ScalarRegressionTask), ), "IS2REInference expects a pretrained energy model or 'ScalarRegressionTask' as input." super().__init__(pretrained_model) def forward(self, batch: BatchDict) -> DataDict: predictions = self.model(batch) return predictions @registry.register_task("S2EFInference") class S2EFInference(OpenCatalystInference): def __init__(self, pretrained_model: ForceRegressionTask) -> None: assert isinstance( pretrained_model, ForceRegressionTask, ), "S2EFInference expects a pretrained 'ForceRegressionTask' instance as input." super().__init__(pretrained_model) def forward(self, batch: BatchDict) -> DataDict: predictions = self.model(batch) return predictions def on_predict_start(self) -> None: self.apply(rnn_force_train_mode) return super().on_predict_start() def predict_step(self, batch: Any, batch_idx: int, dataloader_idx: int = 0) -> Any: # force gradients when running predictions predictions = self(batch) energy, force = predictions["energy"], predictions["force"] energy = energy.detach().cpu().to(torch.float16) force = force.detach().cpu() ids, chunk_ids = batch.get("sid"), batch.get("fid") # ids are formatted differently for force tasks system_ids = [f"{i}_{j}" for i, j in zip(ids, chunk_ids)] predictions = { "ids": system_ids, "chunk_ids": chunk_ids, "energy": energy, } # processing the forces is a bit more complicated because apparently # only the free atoms are considered if self.regress_forces: if "graph" in batch: graph = batch.get("graph") fixed = graph.ndata["fixed"] else: # otherwise it's a point cloud fixed = batch.get("fixed") fixed_mask = fixed == 0 # retrieve only forces corresponding to unfixed nodes predictions["forces"] = force[fixed_mask] natoms = tuple(batch.get("natoms").cpu().numpy().astype(int)) chunk_split = torch.split(fixed, natoms) chunk_ids = [] for chunk in chunk_split: ids = (len(chunk) - sum(chunk)).cpu().numpy().astype(int) chunk_ids.append(int(ids)) predictions["chunk_ids"] = chunk_ids return predictions def on_predict_batch_end( self, outputs: Any, batch: Any, batch_idx: int, dataloader_idx: int = 0, ) -> None: # reset gradients to ensure no contamination between batches self.zero_grad(set_to_none=True) class NodeDenoisingTask(BaseTaskModule): __task__ = "pretraining" """ This implements a node position denoising task, as described by Zaidi _et al._, ICLR 2023. This task is paired with the `NoisyPositions` pretraining data transform, which generates the noise. A single output head is used to predict the noise for every atom, using the MSE between the predicted and actual noise as the loss function. """ def __init__( self, encoder: nn.Module | None = None, encoder_class: type[nn.Module] | None = None, encoder_kwargs: dict[str, Any] | None = None, loss_func: type[nn.Module] | nn.Module | None = None, task_keys: list[str] | None = None, output_kwargs: dict[str, Any] = {}, lr: float = 0.0001, weight_decay: float = 0, embedding_reduction_type: str = "mean", normalize_kwargs: dict[str, float] | None = None, scheduler_kwargs: dict[str, dict[str, Any]] | None = None, **kwargs, ) -> None: if task_keys is not None: warn("Task keys were passed to NodeDenoisingTask, but is not used.") task_keys = ["denoise"] super().__init__( encoder, encoder_class, encoder_kwargs, loss_func, task_keys, output_kwargs, lr, weight_decay, embedding_reduction_type, normalize_kwargs, scheduler_kwargs, **kwargs, ) self.loss_func = nn.MSELoss() def _make_output_heads(self) -> nn.ModuleDict: # make a single output head for noise prediction applied to nodes denoise = OutputHead(3, **self.output_kwargs).to(self.device) return nn.ModuleDict({"denoise": denoise}) def _filter_task_keys( self, keys: list[str], batch: dict[str, torch.Tensor | dgl.DGLGraph | dict[str, torch.Tensor]], ) -> list[str]: """ For the denoising task, we will only ever target the "denoise" key. Parameters ---------- keys : List[str] List of task keys batch : Dict[str, Union[torch.Tensor, dgl.DGLGraph, Dict[str, torch.Tensor]]] Batch of training samples to inspect. Returns ------- List[str] List of filtered task keys """ return ["denoise"] def process_embedding(self, embeddings: Embeddings) -> dict[str, torch.Tensor]: """ Override the base process embedding method, since we are assumed to only have a single output head and we need to use the point/node-level embeddings. Parameters ---------- embeddings : Embeddings Embeddings data structure containing graph and node-level embeddings. Returns ------- dict[str, torch.Tensor] Dictionary with a single 'denoise' key, corresponding to the predicted noise. """ head = self.output_heads["denoise"] # prediction node noise pred_noise = head(embeddings.point_embedding) return {"denoise": pred_noise} def forward( self, batch: BatchDict, ) -> dict[str, torch.Tensor]: """ Modified forward call for denoising positions. The goal of this task is to predict noise, given noisy coordinates, and for this to happen we substitute the noise-free positions temporarily for the noisy ones to prevent interference with other tasks. Parameters ---------- batch : BatchDict Batch of data samples Returns ------- dict[str, torch.Tensor] Dictionary output from ``process_embedding`` Raises ------ KeyError: Raises a ``KeyError`` ff the noisy positions are not found in either the graph or point cloud dictionary. """ if "graph" in batch: graph = batch["graph"] if hasattr(graph, "ndata"): target = graph.ndata else: target = graph else: target = batch if "noisy_pos" not in target: raise KeyError( "'noisy_pos' was not found in data structure, please add the" " NoisyPositions pretraining transform, and/or check that" " 'noisy_pos' is included in the graph transform ``node_keys``." ) temp_pos = target["pos"].clone().detach() # swap out positions for the noisy ones target["pos"] = target["noisy_pos"] if "embeddings" in batch: embedding = batch.get("embeddings") else: embedding = self.encoder(batch) outputs = self.process_embedding(embedding) target["pos"] = temp_pos return outputs