unocg 0.0.3__tar.gz → 0.0.4__tar.gz

{unocg-0.0.3/unocg.egg-info → unocg-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unocg
-Version: 0.0.3
+Version: 0.0.4
 Summary: UNO-CG
 Author-email: Julius Herb <herb@mib.uni-stuttgart.de>, Felix Fritzen <fritzen@mib.uni-stuttgart.de>
 License-Expression: MIT

{unocg-0.0.3 → unocg-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unocg"
-version = "0.0.3"
+version = "0.0.4"
 authors = [
   { name="Julius Herb", email="herb@mib.uni-stuttgart.de" },
   { name="Felix Fritzen", email="fritzen@mib.uni-stuttgart.de" },

unocg-0.0.4/unocg/training/losses/__init__.py

@@ -0,0 +1 @@
+from .base import Loss, WeightedLoss

unocg-0.0.4/unocg/training/losses/base.py

@@ -0,0 +1,102 @@
+"""
+Definition of loss function that allow for a physics-informed training of machine learning models
+"""
+from abc import ABC
+from typing import Union, Iterable, List, Optional
+
+# third-party packages
+import torch
+
+
+class Loss(ABC):
+    """
+    Abstract loss function
+    """
+
+    def __init__(self, n_dim: int = 2, reduction: str = "sum"):
+        """
+
+        :param n_dim: dimension of the problem
+        :param reduction: ('mean'|'sum'|'none'), defaults to 'sum'
+        :type reduction: str, optional
+        """
+        super().__init__()
+        self.n_dim = n_dim
+        self.ch_dim = -(1 + self.n_dim)
+        self.reduction = reduction
+
+    def reduce(self, loss):
+        """
+        Perform a reduction step over all datasets to transform a loss function to a cost function.
+
+        A loss function is evaluated element-wise for a dataset.
+        However, a cost function should return a single value for the dataset.
+        Typically, `mean` reduction is used.
+
+        :param loss: Tensor that contains the element-wise loss for a dataset
+        :type loss: :class:`torch.Tensor`
+        :return: Reduced loss
+        :rtype: float
+        """
+        if self.reduction == "mean":
+            return torch.nanmean(loss)
+        elif self.reduction == "sum":
+            return torch.nansum(loss)
+        else:
+            return loss
+
+    def unsqueeze(self, output, target):
+        """
+        Ensure that the tensors :code:`output` and :code:`target` have a shape of the form :code:`(N, features)`.
+
+        When a loss function is called with a single data point, the tensor shape is :code:`(features)` and hence does not fit.
+        This method expands the dimensions if needed.
+
+        :param output: Model output
+        :type output: :class:`torch.Tensor`
+        :param target: Target data
+        :type target: :class:`torch.Tensor`
+        :return: Tuple (output, target)
+        :rtype: tuple
+        """
+        while output.ndim < self.n_dim + 2:
+            output = torch.unsqueeze(output, 0)
+        while target.ndim < output.ndim:
+            target = torch.unsqueeze(target, 0)
+        while output.ndim < target.ndim:
+            output = torch.unsqueeze(output, 0)
+        assert output.ndim >= self.n_dim + 2 and output.ndim == target.ndim
+        return output, target
+        # return output.flatten(end_dim=-(self.n_dim + 2)), target.flatten(end_dim=-(self.n_dim + 2))
+
+    @property
+    def dims(self):
+        return self.n_dim * (slice(None),)
+
+    @property
+    def dims_list(self):
+        return tuple(range(-1, -(1 + self.n_dim), -1))
+
+    @property
+    def expand_dims(self):
+        return self.n_dim * (None,)
+
+
+class WeightedLoss(Loss):
+    """
+    Weighted loss function that represents a linear combination of several loss functions
+    """
+
+    def __init__(self, losses: Iterable[any], weights: Iterable[Union[float, int]], reduction="mean"):
+        super().__init__(reduction=reduction)
+        self.losses = losses
+        self.weights = weights
+
+    def __call__(self, output, target):
+        total_loss = 0.0
+        for loss, weight in zip(self.losses, self.weights):
+            total_loss += weight * loss(output, target)
+        return total_loss
+
+    def __str__(self):
+        return f"Weighted(...)"

unocg-0.0.4/unocg/training/losses/mechanical.py

@@ -0,0 +1,246 @@
+import torch
+from .base import Loss
+
+
+class DispLoss(Loss):
+    """
+    Displacement loss function
+    """
+
+    def __init__(self, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+
+    def abs(self, output, target):
+        """
+        Compute absolute error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_disp, target_disp = output[..., :self.n_dim, *self.dims], target[..., :self.n_dim, *self.dims]
+        loss = torch.sqrt(torch.nn.MSELoss(reduction="none")(target_disp, output_disp).nanmean(self.dims_list))
+        loss = self.reduce(loss).squeeze(-1)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute relative error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_disp, target_disp = output[..., :self.n_dim, *self.dims], target[..., :self.n_dim, *self.dims]
+        loss = torch.linalg.norm(target_disp - output_disp, dim=-(1 + self.n_dim)).nanmean(self.dims_list) \
+            / torch.linalg.norm(target_disp, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss).squeeze(-1)
+        return loss
+
+    def __call__(self, x, y):
+        return self.rel(x, y)
+
+    def __str__(self):
+        return f"Temp({self.reduction})"
+
+
+class StrainLoss(Loss):
+    """
+    Strain loss function
+    """
+
+    def __init__(self, grad_module, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+        self.grad_module = grad_module
+
+    def abs(self, output, target):
+        """
+        Compute absolute error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :self.n_dim, *self.dims], target[..., :self.n_dim, *self.dims]
+        loss = torch.linalg.norm(target_temp - output_temp, dim=self.ch_dim)
+        loss = self.reduce(loss)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute relative error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :self.n_dim, *self.dims], target[..., :self.n_dim, *self.dims]
+        batch_dims = output_temp.shape[:self.ch_dim]
+        output_temp = torch.flatten(output_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        target_temp = torch.flatten(target_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        output_grad = self.grad_module(output_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        target_grad = self.grad_module(target_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        output_temp = torch.unflatten(output_temp, dim=0, sizes=batch_dims)
+        target_temp = torch.unflatten(target_temp, dim=0, sizes=batch_dims)
+        loss = torch.linalg.norm(target_grad - output_grad, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss)
+        return loss
+
+    def __call__(self, x, y):
+        return self.rel(x, y)
+
+    def __str__(self):
+        return f"Grad({self.reduction})"
+
+
+class StressLoss(Loss):
+    """
+    Flux loss function
+    """
+
+    def __init__(self, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+
+    def abs(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_flux, target_flux = output[..., self.n_dim:, *self.dims], target[..., self.n_dim:, *self.dims]
+        loss = torch.linalg.norm(target_flux - output_flux, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_flux, target_flux = output[..., self.n_dim:, *self.dims], target[..., self.n_dim:, *self.dims]
+        loss = torch.linalg.norm(target_flux - output_flux, dim=-(1 + self.n_dim)).nanmean(self.dims_list) \
+            / torch.linalg.norm(target_flux, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss)
+        return loss
+
+    def __call__(self, output: torch.Tensor, target: torch.Tensor):
+        return self.rel(output, target)
+
+    def __str__(self):
+        return f"Flux({self.reduction})"
+    
+    
+class MechanicalEnergyLoss(Loss):
+    """
+    Thermal energy loss function
+    """
+
+    def __init__(self, grad_module, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+        self.grad_module = grad_module
+
+    def abs(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :self.n_dim, *self.dims], target[..., :self.n_dim, *self.dims]
+        output_flux, target_flux = output[..., self.n_dim:, *self.dims], target[..., self.n_dim:, *self.dims]
+        batch_dims = output_temp.shape[:self.ch_dim]
+        output_temp = torch.flatten(output_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        target_temp = torch.flatten(target_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        output_grad = self.grad_module(output_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        target_grad = self.grad_module(target_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        output_temp = torch.unflatten(output_temp, dim=0, sizes=batch_dims)
+        target_temp = torch.unflatten(target_temp, dim=0, sizes=batch_dims)
+        loss = torch.sqrt(
+            torch.linalg.norm((output_grad - target_grad) * (output_flux - target_flux), dim=self.ch_dim).nanmean(self.dims_list)
+        )
+        loss = self.reduce(loss)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :self.n_dim, *self.dims], target[..., :self.n_dim, *self.dims]
+        output_flux, target_flux = output[..., self.n_dim:, *self.dims], target[..., self.n_dim:, *self.dims]
+        batch_dims = output_temp.shape[:self.ch_dim]
+        output_temp = torch.flatten(output_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        target_temp = torch.flatten(target_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        output_grad = self.grad_module(output_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        target_grad = self.grad_module(target_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        output_temp = torch.unflatten(output_temp, dim=0, sizes=batch_dims)
+        target_temp = torch.unflatten(target_temp, dim=0, sizes=batch_dims)
+        loss = torch.sqrt(
+            torch.linalg.norm((output_grad - target_grad) * (output_flux - target_flux), dim=self.ch_dim).nanmean(self.dims_list)
+            / torch.linalg.norm(target_grad * target_flux, dim=self.ch_dim).nanmean(self.dims_list)
+        )
+        loss = self.reduce(loss)
+        return loss
+
+    def __call__(self, output_disp: torch.Tensor, target_disp: torch.Tensor, param_field=None):
+        return self.abs(output_disp, target_disp)
+
+    def __str__(self):
+        return f"ThermEnergy({self.reduction})"
+
+
+class LinearElasticResidualLoss(Loss):
+    """
+    Homogenized stress loss function
+    """
+
+    def __init__(self, div_module, n_dim=2, reduction="sum", residual_mode="mean"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+        self.div_module = div_module
+        self.residual_mode = residual_mode
+
+    def abs(self, output, target=None):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        batch_dims = target_flux.shape[:self.ch_dim]
+        output_flux = torch.flatten(output_flux, start_dim=0, end_dim=self.ch_dim - 1).unsqueeze(self.ch_dim - 1)
+        output_residual = self.div_module(output_flux)
+        output_residual = torch.unflatten(output_residual, dim=0, sizes=batch_dims)
+        if self.residual_mode == "sum":
+            loss = torch.abs(output_residual).nansum(self.dims_list)
+        elif self.residual_mode == "mean":
+            loss = torch.abs(output_residual).nanmean(self.dims_list)
+        else:
+            raise ValueError("Unknown residual_mode")
+        loss = self.reduce(loss).squeeze(-1)
+        return loss
+
+    def __call__(self, output: torch.Tensor, target):
+        return self.abs(output, target)
+
+    def __str__(self):
+        return f"HeatCondResidual({self.reduction})"

unocg-0.0.4/unocg/training/losses/thermal.py

@@ -0,0 +1,247 @@
+import torch
+from .base import Loss
+
+
+class TempLoss(Loss):
+    """
+    Displacement loss function
+    """
+
+    def __init__(self, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+
+    def abs(self, output, target):
+        """
+        Compute absolute error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :1, *self.dims], target[..., :1, *self.dims]
+        loss = torch.sqrt(torch.nn.MSELoss(reduction="none")(target_temp, output_temp).nanmean(self.dims_list))
+        loss = self.reduce(loss).squeeze(-1)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute relative error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :1, *self.dims], target[..., :1, *self.dims]
+        loss = torch.sqrt(torch.nn.MSELoss(reduction="none")(target_temp, output_temp).nanmean(self.dims_list) / \
+            torch.nn.MSELoss(reduction="none")(target_temp, torch.zeros_like(target_temp)).nanmean(self.dims_list))
+        loss = self.reduce(loss).squeeze(-1)
+        return loss
+
+    def __call__(self, x, y):
+        return self.rel(x, y)
+
+    def __str__(self):
+        return f"Temp({self.reduction})"
+
+
+class GradLoss(Loss):
+    """
+    Displacement loss function
+    """
+
+    def __init__(self, grad_module, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+        self.grad_module = grad_module
+
+    def abs(self, output, target):
+        """
+        Compute absolute error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :1, *self.dims], target[..., :1, *self.dims]
+        loss = torch.linalg.norm(target_temp - output_temp, dim=-3)
+        loss = self.reduce(loss)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute relative error for temperature field
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :1, *self.dims], target[..., :1, *self.dims]
+        # output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        batch_dims = output_temp.shape[:self.ch_dim]
+        output_temp = torch.flatten(output_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        target_temp = torch.flatten(target_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        output_grad = self.grad_module(output_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        target_grad = self.grad_module(target_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        output_temp = torch.unflatten(output_temp, dim=0, sizes=batch_dims)
+        target_temp = torch.unflatten(target_temp, dim=0, sizes=batch_dims)
+        loss = torch.linalg.norm(target_grad - output_grad, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss)
+        return loss
+
+    def __call__(self, x, y):
+        return self.rel(x, y)
+
+    def __str__(self):
+        return f"Grad({self.reduction})"
+
+
+class FluxLoss(Loss):
+    """
+    Flux loss function
+    """
+
+    def __init__(self, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+
+    def abs(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        loss = torch.linalg.norm(target_flux - output_flux, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        loss = torch.linalg.norm(target_flux - output_flux, dim=-(1 + self.n_dim)).nanmean(self.dims_list) \
+            / torch.linalg.norm(target_flux, dim=-(1 + self.n_dim)).nanmean(self.dims_list)
+        loss = self.reduce(loss)
+        return loss
+
+    def __call__(self, output: torch.Tensor, target: torch.Tensor):
+        return self.rel(output, target)
+
+    def __str__(self):
+        return f"Flux({self.reduction})"
+    
+    
+class ThermalEnergyLoss(Loss):
+    """
+    Thermal energy loss function
+    """
+
+    def __init__(self, grad_module, n_dim=2, reduction="sum"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+        self.grad_module = grad_module
+
+    def abs(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :1, *self.dims], target[..., :1, *self.dims]
+        output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        batch_dims = output_temp.shape[:self.ch_dim]
+        output_temp = torch.flatten(output_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        target_temp = torch.flatten(target_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        output_grad = self.grad_module(output_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        target_grad = self.grad_module(target_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        output_temp = torch.unflatten(output_temp, dim=0, sizes=batch_dims)
+        target_temp = torch.unflatten(target_temp, dim=0, sizes=batch_dims)
+        loss = torch.sqrt(
+            torch.linalg.norm((output_grad - target_grad) * (output_flux - target_flux), dim=self.ch_dim).nanmean(self.dims_list)
+        )
+        loss = self.reduce(loss)
+        return loss
+
+    def rel(self, output, target):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_temp, target_temp = output[..., :1, *self.dims], target[..., :1, *self.dims]
+        output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        batch_dims = output_temp.shape[:self.ch_dim]
+        output_temp = torch.flatten(output_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        target_temp = torch.flatten(target_temp, start_dim=0, end_dim=self.ch_dim - 1)
+        output_grad = self.grad_module(output_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        target_grad = self.grad_module(target_temp).nanmean(-(2 + self.n_dim))  # average over gauss points
+        output_temp = torch.unflatten(output_temp, dim=0, sizes=batch_dims)
+        target_temp = torch.unflatten(target_temp, dim=0, sizes=batch_dims)
+        loss = torch.sqrt(
+            torch.linalg.norm((output_grad - target_grad) * (output_flux - target_flux), dim=self.ch_dim).nanmean(self.dims_list)
+            / torch.linalg.norm(target_grad * target_flux, dim=self.ch_dim).nanmean(self.dims_list)
+        )
+        loss = self.reduce(loss)
+        return loss
+
+    def __call__(self, output_disp: torch.Tensor, target_disp: torch.Tensor, param_field=None):
+        return self.abs(output_disp, target_disp)
+
+    def __str__(self):
+        return f"ThermEnergy({self.reduction})"
+
+
+class HeatCondResidualLoss(Loss):
+    """
+    Homogenized stress loss function
+    """
+
+    def __init__(self, div_module, n_dim=2, reduction="sum", residual_mode="mean"):
+        super().__init__(n_dim=n_dim, reduction=reduction)
+        self.div_module = div_module
+        self.residual_mode = residual_mode
+
+    def abs(self, output, target=None):
+        """
+        Compute absolute error in strain norm
+
+        :param output:
+        :param target:
+        :return:
+        """
+        output, target = self.unsqueeze(output, target)
+        output_flux, target_flux = output[..., 1:, *self.dims], target[..., 1:, *self.dims]
+        batch_dims = target_flux.shape[:self.ch_dim]
+        output_flux = torch.flatten(output_flux, start_dim=0, end_dim=self.ch_dim - 1).unsqueeze(self.ch_dim - 1)
+        output_residual = self.div_module(output_flux)
+        output_residual = torch.unflatten(output_residual, dim=0, sizes=batch_dims)
+        if self.residual_mode == "sum":
+            loss = torch.abs(output_residual).nansum(self.dims_list)
+        elif self.residual_mode == "mean":
+            loss = torch.abs(output_residual).nanmean(self.dims_list)
+        else:
+            raise ValueError("Unknown residual_mode")
+        loss = self.reduce(loss).squeeze(-1)
+        return loss
+
+    def __call__(self, output: torch.Tensor, target):
+        return self.abs(output, target)
+
+    def __str__(self):
+        return f"HeatCondResidual({self.reduction})"

{unocg-0.0.3 → unocg-0.0.4/unocg.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unocg
-Version: 0.0.3
+Version: 0.0.4
 Summary: UNO-CG
 Author-email: Julius Herb <herb@mib.uni-stuttgart.de>, Felix Fritzen <fritzen@mib.uni-stuttgart.de>
 License-Expression: MIT

{unocg-0.0.3 → unocg-0.0.4}/unocg.egg-info/SOURCES.txt

@@ -28,6 +28,11 @@ unocg/problems/thermal.py
 unocg/solvers/__init__.py
 unocg/solvers/base.py
 unocg/solvers/torch.py
+unocg/training/__init__.py
+unocg/training/losses/__init__.py
+unocg/training/losses/base.py
+unocg/training/losses/mechanical.py
+unocg/training/losses/thermal.py
 unocg/transforms/__init__.py
 unocg/transforms/base.py
 unocg/transforms/fourier.py