reduced-3dgs 1.10.0__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

reduced_3dgs/shculling/gaussian_model.py

@@ -0,0 +1,78 @@
+import torch
+import torch.nn as nn
+from gaussian_splatting import GaussianModel
+
+
+class VariableSHGaussianModel(GaussianModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._degrees = torch.empty(0)
+
+    def to(self, device):
+        self._degrees = self._degrees.to(device)
+        return super().to(device)
+
+    @property
+    def get_features(self):
+        features_dc = self._features_dc
+        # compute SH according to self._degrees
+        n_SH = (self._degrees + 1) ** 2 - 1
+        indices = torch.arange((self.max_sh_degree + 1) ** 2 - 1, device=n_SH.device).expand(n_SH.shape[0], -1) < n_SH.unsqueeze(-1)
+        features_rest = torch.zeros_like(self._features_rest)
+        features_rest[indices, :] = self._features_rest[indices, :]
+        with torch.no_grad():
+            self._features_rest[~indices, :] = 0
+            if self._features_rest.grad is not None:
+                self._features_rest.grad[~indices, :] = 0
+        return torch.cat((features_dc, features_rest), dim=1)
+
+    def init_degrees(self):
+        self._degrees = torch.zeros(self._xyz.shape[0], dtype=torch.int, device=self._xyz.device) + self.max_sh_degree
+
+    def create_from_pcd(self, *args, **kwargs):
+        super().create_from_pcd(*args, **kwargs)
+        self.init_degrees()
+
+    def load_ply(self, *args, **kwargs):
+        super().load_ply(*args, **kwargs)
+        self.init_degrees()
+
+    def update_points_add(
+            self,
+            xyz: nn.Parameter,
+            features_dc: nn.Parameter,
+            features_rest: nn.Parameter,
+            scaling: nn.Parameter,
+            rotation: nn.Parameter,
+            opacity: nn.Parameter,
+    ):
+        super().update_points_add(
+            xyz=xyz,
+            features_dc=features_dc,
+            features_rest=features_rest,
+            scaling=scaling,
+            rotation=rotation,
+            opacity=opacity,
+        )
+        with torch.no_grad():
+            self._degrees = torch.cat((self._degrees, torch.zeros(xyz.shape[0]-self._degrees.shape[0], dtype=self._degrees.dtype, device=xyz.device) + self.max_sh_degree))
+
+    def update_points_remove(
+            self, removed_mask: torch.Tensor,
+            xyz: nn.Parameter,
+            features_dc: nn.Parameter,
+            features_rest: nn.Parameter,
+            scaling: nn.Parameter,
+            rotation: nn.Parameter,
+            opacity: nn.Parameter,):
+        super().update_points_remove(
+            removed_mask=removed_mask,
+            xyz=xyz,
+            features_dc=features_dc,
+            features_rest=features_rest,
+            scaling=scaling,
+            rotation=rotation,
+            opacity=opacity,
+        )
+        with torch.no_grad():
+            self._degrees = self._degrees[~removed_mask]

reduced_3dgs/shculling/trainer.py

@@ -0,0 +1,158 @@
+from typing import List
+import torch
+
+from gaussian_splatting import Camera
+from gaussian_splatting.trainer import AbstractTrainer, TrainerWrapper, BaseTrainer, Trainer
+from gaussian_splatting.dataset import CameraDataset
+from reduced_3dgs.diff_gaussian_rasterization._C import calculate_colours_variance
+
+from .gaussian_model import VariableSHGaussianModel
+
+
+def _low_variance_colour_culling(self: VariableSHGaussianModel, threshold, weighted_variance: torch.Tensor, weighted_mean: torch.Tensor):
+    original_degrees = torch.zeros_like(self._degrees)
+    original_degrees.copy_(self._degrees)
+
+    # Uniform colour culling
+    weighted_colour_std = weighted_variance.sqrt()
+    weighted_colour_std[weighted_colour_std.isnan()] = 0
+    weighted_colour_std = weighted_colour_std.mean(dim=2).squeeze()
+
+    std_mask = weighted_colour_std < threshold
+    self._features_dc[std_mask] = (weighted_mean[std_mask] - 0.5) / 0.28209479177387814
+    self._degrees[std_mask] = 0
+    self._features_rest[std_mask] = 0
+
+
+def _low_distance_colour_culling(self: VariableSHGaussianModel, threshold, colour_distances: torch.Tensor):
+    colour_distances[colour_distances.isnan()] = 0
+
+    # Loop from active_sh_degree - 1 to 0, since the comparisons
+    # are always done based on the max band that corresponds to active_sh_degree
+    for sh_degree in range(self.active_sh_degree - 1, 0, -1):
+        coeffs_num = (sh_degree+1)**2 - 1
+        mask = colour_distances[:, sh_degree] < threshold
+        self._degrees[mask] = torch.min(
+            torch.tensor([sh_degree], device="cuda", dtype=int),
+            self._degrees[mask]
+        ).int()
+
+        # Zero-out the associated SH coefficients for clarity,
+        # as they won't be used in rasterisation due to the degrees field
+        self._features_rest[mask, coeffs_num:] = 0
+
+
+def _cull_sh_bands(self: VariableSHGaussianModel, cameras: List[Camera], threshold=0, std_threshold=0.):
+    camera_positions = torch.stack([cam.camera_center for cam in cameras], dim=0)
+    camera_viewmatrices = torch.stack([cam.world_view_transform for cam in cameras], dim=0)
+    camera_projmatrices = torch.stack([cam.full_proj_transform for cam in cameras], dim=0)
+    camera_fovx = torch.tensor([camera.FoVx for camera in cameras], device="cuda", dtype=torch.float32)
+    camera_fovy = torch.tensor([camera.FoVy for camera in cameras], device="cuda", dtype=torch.float32)
+    image_height = torch.tensor([camera.image_height for camera in cameras], device="cuda", dtype=torch.int32)
+    image_width = torch.tensor([camera.image_width for camera in cameras], device="cuda", dtype=torch.int32)
+
+    # Wrapping in a function since it's called with the same parameters twice
+    def run_calculate_colours_variance():
+        return calculate_colours_variance(
+            camera_positions,
+            self.get_xyz,
+            self._opacity,
+            self.get_scaling,
+            self.get_rotation,
+            camera_viewmatrices,
+            camera_projmatrices,
+            torch.tan(camera_fovx*0.5),
+            torch.tan(camera_fovy*0.5),
+            image_height,
+            image_width,
+            self.get_features,
+            self._degrees,
+            self.active_sh_degree)
+
+    _, weighted_variance, weighted_mean = run_calculate_colours_variance()
+    _low_variance_colour_culling(self, std_threshold, weighted_variance, weighted_mean)
+
+    # Recalculate to account for the changed values
+    colour_distances, _, _ = run_calculate_colours_variance()
+    _low_distance_colour_culling(self, threshold, colour_distances)
+
+
+def cull_sh_bands(self: VariableSHGaussianModel, cameras: List[Camera], threshold=0, std_threshold=0.):
+    with torch.no_grad():
+        _cull_sh_bands(self, cameras, threshold, std_threshold)
+
+
+class SHCuller(TrainerWrapper):
+    def __init__(
+            self, base_trainer: AbstractTrainer,
+            dataset: CameraDataset,
+            cdist_threshold: float = 6,
+            std_threshold: float = 0.04,
+            cull_at_steps=[15000],
+    ):
+        super().__init__(base_trainer)
+        assert isinstance(self.model, VariableSHGaussianModel)
+        self.dataset = dataset
+        self.cdist_threshold = cdist_threshold
+        self.std_threshold = std_threshold
+        self.cull_at_steps = cull_at_steps
+
+    def optim_step(self):
+        ret = super().optim_step()
+        if self.curr_step in self.cull_at_steps:
+            cull_sh_bands(self.model, self.dataset, self.cdist_threshold, self.std_threshold)
+        return ret
+
+
+def SHCullingTrainerWrapper(
+    base_trainer_constructor,
+        model: VariableSHGaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        cdist_threshold: float = 6,
+        std_threshold: float = 0.04,
+        cull_at_steps=[15000],
+        *args, **kwargs):
+    return SHCuller(
+        base_trainer_constructor(model, scene_extent, dataset, *args, **kwargs),
+        dataset,
+        cdist_threshold=cdist_threshold,
+        std_threshold=std_threshold,
+        cull_at_steps=cull_at_steps,
+    )
+
+
+def BaseSHCullingTrainer(
+    model: VariableSHGaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        cdist_threshold: float = 6,
+        std_threshold: float = 0.04,
+        cull_at_steps=[15000],
+        *args, **kwargs):
+    return SHCullingTrainerWrapper(
+        lambda model, scene_extent, dataset, *args, **kwargs: BaseTrainer(model, scene_extent, *args, **kwargs),
+        model, scene_extent, dataset,
+        cdist_threshold=cdist_threshold,
+        std_threshold=std_threshold,
+        cull_at_steps=cull_at_steps,
+        *args, **kwargs,
+    )
+
+
+def SHCullingTrainer(
+    model: VariableSHGaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        cdist_threshold: float = 6,
+        std_threshold: float = 0.04,
+        cull_at_steps=[15000],
+        *args, **kwargs):
+    return SHCullingTrainerWrapper(
+        lambda model, scene_extent, dataset, *args, **kwargs: Trainer(model, scene_extent, *args, **kwargs),
+        model, scene_extent, dataset,
+        cdist_threshold=cdist_threshold,
+        std_threshold=std_threshold,
+        cull_at_steps=cull_at_steps,
+        *args, **kwargs,
+    )

reduced_3dgs/train.py

@@ -0,0 +1,195 @@
+import os
+import random
+import shutil
+from typing import List, Tuple
+import torch
+from tqdm import tqdm
+from argparse import Namespace
+from gaussian_splatting import GaussianModel
+from gaussian_splatting.dataset import CameraDataset, JSONCameraDataset, TrainableCameraDataset
+from gaussian_splatting.utils import psnr
+from gaussian_splatting.dataset.colmap import ColmapCameraDataset, ColmapTrainableCameraDataset, colmap_init
+from gaussian_splatting.trainer import AbstractTrainer
+from gaussian_splatting.trainer.extensions import ScaleRegularizeTrainerWrapper
+from reduced_3dgs.quantization import AbstractQuantizer, VectorQuantizeTrainerWrapper
+from reduced_3dgs.shculling import VariableSHGaussianModel, SHCullingTrainer
+from reduced_3dgs.pruning import PruningTrainer
+from reduced_3dgs.combinations import PrunerInDensifyTrainer, SHCullingDensificationTrainer, SHCullingPruningTrainer, SHCullingPrunerInDensifyTrainer
+from reduced_3dgs.combinations import CameraTrainableVariableSHGaussianModel, CameraSHCullingTrainer, CameraPruningTrainer
+from reduced_3dgs.combinations import CameraPrunerInDensifyTrainer, CameraSHCullingDensifyTrainer, CameraSHCullingPruningTrainer, CameraSHCullingPruningDensifyTrainer
+
+
+basemodes = {
+    "shculling": SHCullingTrainer,
+    "pruning": PruningTrainer,
+    "densify-pruning": PrunerInDensifyTrainer,
+    "densify-shculling": SHCullingDensificationTrainer,
+    "prune-shculling": SHCullingPruningTrainer,
+    "densify-prune-shculling": SHCullingPrunerInDensifyTrainer,
+}
+cameramodes = {
+    "camera-shculling": CameraSHCullingTrainer,
+    "camera-pruning": CameraPruningTrainer,
+    "camera-densify-pruning": CameraPrunerInDensifyTrainer,
+    "camera-densify-shculling": CameraSHCullingDensifyTrainer,
+    "camera-prune-shculling": CameraSHCullingPruningTrainer,
+    "camera-densify-prune-shculling": CameraSHCullingPruningDensifyTrainer,
+}
+
+
+def prepare_quantizer(
+        gaussians: GaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        base_constructor,
+        load_quantized: str = None,
+
+        num_clusters=256,
+        num_clusters_rotation_re=None,
+        num_clusters_rotation_im=None,
+        num_clusters_opacity=None,
+        num_clusters_scaling=None,
+        num_clusters_features_dc=None,
+        num_clusters_features_rest=[],
+
+        quantize_from_iter=5000,
+        quantize_until_iter=30000,
+        quantize_interval=1000,
+        **configs):
+    trainer = VectorQuantizeTrainerWrapper(
+        base_constructor(
+            gaussians,
+            scene_extent=scene_extent,
+            dataset=dataset,
+            **configs
+        ),
+
+        num_clusters=num_clusters,
+        num_clusters_rotation_re=num_clusters_rotation_re,
+        num_clusters_rotation_im=num_clusters_rotation_im,
+        num_clusters_opacity=num_clusters_opacity,
+        num_clusters_scaling=num_clusters_scaling,
+        num_clusters_features_dc=num_clusters_features_dc,
+        num_clusters_features_rest=num_clusters_features_rest,
+
+        quantize_from_iter=quantize_from_iter,
+        quantize_until_iter=quantize_until_iter,
+        quantize_interval=quantize_interval,
+    )
+    if load_quantized:
+        trainer.quantizer.load_quantized(load_quantized)
+    return trainer, trainer.quantizer
+
+
+def prepare_training(sh_degree: int, source: str, device: str, mode: str, load_ply: str = None, load_camera: str = None, load_depth=False, with_scale_reg=False, quantize: bool = False, load_quantized: str = None, configs={}) -> Tuple[CameraDataset, GaussianModel, AbstractTrainer]:
+    quantizer = None
+    if mode in basemodes:
+        gaussians = VariableSHGaussianModel(sh_degree).to(device)
+        gaussians.load_ply(load_ply) if load_ply else colmap_init(gaussians, source)
+        dataset = (JSONCameraDataset(load_camera, load_depth=load_depth) if load_camera else ColmapCameraDataset(source, load_depth=load_depth)).to(device)
+        modes = basemodes
+    elif mode in cameramodes:
+        gaussians = CameraTrainableVariableSHGaussianModel(sh_degree).to(device)
+        gaussians.load_ply(load_ply) if load_ply else colmap_init(gaussians, source)
+        dataset = (TrainableCameraDataset.from_json(load_camera, load_depth=load_depth) if load_camera else ColmapTrainableCameraDataset(source, load_depth=load_depth)).to(device)
+        modes = cameramodes
+    else:
+        raise ValueError(f"Unknown mode: {mode}")
+    constructor = modes[mode]
+    if with_scale_reg:
+        constructor = lambda *args, **kwargs: ScaleRegularizeTrainerWrapper(modes[mode], *args, **kwargs)
+    if quantize:
+        trainer, quantizer = prepare_quantizer(
+            gaussians,
+            scene_extent=dataset.scene_extent(),
+            dataset=dataset,
+            base_constructor=modes[mode],
+            load_quantized=load_quantized,
+            **configs
+        )
+    else:
+        trainer = constructor(
+            gaussians,
+            scene_extent=dataset.scene_extent(),
+            dataset=dataset,
+            **configs
+        )
+    return dataset, gaussians, trainer, quantizer
+
+
+def save_cfg_args(destination: str, sh_degree: int, source: str):
+    os.makedirs(destination, exist_ok=True)
+    with open(os.path.join(destination, "cfg_args"), 'w') as cfg_log_f:
+        cfg_log_f.write(str(Namespace(sh_degree=sh_degree, source_path=source)))
+
+
+def training(dataset: CameraDataset, gaussians: GaussianModel, trainer: AbstractTrainer, quantizer: AbstractQuantizer, destination: str, iteration: int, save_iterations: List[int], device: str, empty_cache_every_step=False):
+    shutil.rmtree(os.path.join(destination, "point_cloud"), ignore_errors=True)  # remove the previous point cloud
+    pbar = tqdm(range(1, iteration+1))
+    epoch = list(range(len(dataset)))
+    epoch_psnr = torch.empty(3, 0, device=device)
+    ema_loss_for_log = 0.0
+    avg_psnr_for_log = 0.0
+    for step in pbar:
+        epoch_idx = step % len(dataset)
+        if epoch_idx == 0:
+            avg_psnr_for_log = epoch_psnr.mean().item()
+            epoch_psnr = torch.empty(3, 0, device=device)
+            random.shuffle(epoch)
+        idx = epoch[epoch_idx]
+        loss, out = trainer.step(dataset[idx])
+        if empty_cache_every_step:
+            torch.cuda.empty_cache()
+        with torch.no_grad():
+            ema_loss_for_log = 0.4 * loss.item() + 0.6 * ema_loss_for_log
+            epoch_psnr = torch.concat([epoch_psnr, psnr(out["render"], dataset[idx].ground_truth_image)], dim=1)
+            if step % 10 == 0:
+                pbar.set_postfix({'epoch': step // len(dataset), 'loss': ema_loss_for_log, 'psnr': avg_psnr_for_log, 'n': gaussians._xyz.shape[0]})
+        if step in save_iterations:
+            save_path = os.path.join(destination, "point_cloud", "iteration_" + str(step))
+            os.makedirs(save_path, exist_ok=True)
+            gaussians.save_ply(os.path.join(save_path, "point_cloud.ply"))
+            dataset.save_cameras(os.path.join(destination, "cameras.json"))
+            if quantizer:
+                quantizer.save_quantized(gaussians, os.path.join(save_path, "point_cloud_quantized.ply"))
+    save_path = os.path.join(destination, "point_cloud", "iteration_" + str(iteration))
+    os.makedirs(save_path, exist_ok=True)
+    gaussians.save_ply(os.path.join(save_path, "point_cloud.ply"))
+    dataset.save_cameras(os.path.join(destination, "cameras.json"))
+    if quantizer:
+        quantizer.save_quantized(gaussians, os.path.join(save_path, "point_cloud_quantized.ply"))
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser, Namespace
+    parser = ArgumentParser()
+    parser.add_argument("--sh_degree", default=3, type=int)
+    parser.add_argument("-s", "--source", required=True, type=str)
+    parser.add_argument("-d", "--destination", required=True, type=str)
+    parser.add_argument("-i", "--iteration", default=30000, type=int)
+    parser.add_argument("-l", "--load_ply", default=None, type=str)
+    parser.add_argument("--load_camera", default=None, type=str)
+    parser.add_argument("--quantize", action='store_true')
+    parser.add_argument("--no_depth_data", action='store_true')
+    parser.add_argument("--with_scale_reg", action="store_true")
+    parser.add_argument("--load_quantized", default=None, type=str)
+    parser.add_argument("--mode", choices=list(basemodes.keys()) + list(cameramodes.keys()), default="densify-prune-shculling")
+    parser.add_argument("--save_iterations", nargs="+", type=int, default=[7000, 30000])
+    parser.add_argument("--device", default="cuda", type=str)
+    parser.add_argument("--empty_cache_every_step", action='store_true')
+    parser.add_argument("-o", "--option", default=[], action='append', type=str)
+    args = parser.parse_args()
+    save_cfg_args(args.destination, args.sh_degree, args.source)
+    torch.autograd.set_detect_anomaly(False)
+
+    configs = {o.split("=", 1)[0]: eval(o.split("=", 1)[1]) for o in args.option}
+    dataset, gaussians, trainer, quantizer = prepare_training(
+        sh_degree=args.sh_degree, source=args.source, device=args.device, mode=args.mode,
+        load_ply=args.load_ply, load_camera=args.load_camera, load_depth=not args.no_depth_data, with_scale_reg=args.with_scale_reg,
+        quantize=args.quantize, load_quantized=args.load_quantized, configs=configs)
+    dataset.save_cameras(os.path.join(args.destination, "cameras.json"))
+    torch.cuda.empty_cache()
+    training(
+        dataset=dataset, gaussians=gaussians, trainer=trainer, quantizer=quantizer,
+        destination=args.destination, iteration=args.iteration, save_iterations=args.save_iterations,
+        device=args.device)

reduced_3dgs-1.10.0.dist-info/LICENSE.md

@@ -0,0 +1,93 @@
+The Reduced 3DGS code is an extension of the 3DGS code; the original 3DGS license applies to the original part of the code. This license in reproduced below. 
+
+Gaussian-Splatting License  
+===========================  
+
+**Inria** and **the Max Planck Institut for Informatik (MPII)** hold all the ownership rights on the *Software* named **gaussian-splatting**.  
+The *Software* is in the process of being registered with the Agence pour la Protection des  
+Programmes (APP).  
+
+The *Software* is still being developed by the *Licensor*.  
+
+*Licensor*'s goal is to allow the research community to use, test and evaluate  
+the *Software*.  
+
+## 1.  Definitions  
+
+*Licensee* means any person or entity that uses the *Software* and distributes  
+its *Work*.  
+
+*Licensor* means the owners of the *Software*, i.e Inria and MPII  
+
+*Software* means the original work of authorship made available under this  
+License ie gaussian-splatting.  
+
+*Work* means the *Software* and any additions to or derivative works of the  
+*Software* that are made available under this License.  
+
+
+## 2.  Purpose  
+This license is intended to define the rights granted to the *Licensee* by  
+Licensors under the *Software*.  
+
+## 3.  Rights granted  
+
+For the above reasons Licensors have decided to distribute the *Software*.  
+Licensors grant non-exclusive rights to use the *Software* for research purposes  
+to research users (both academic and industrial), free of charge, without right  
+to sublicense.. The *Software* may be used "non-commercially", i.e., for research  
+and/or evaluation purposes only.  
+
+Subject to the terms and conditions of this License, you are granted a  
+non-exclusive, royalty-free, license to reproduce, prepare derivative works of,  
+publicly display, publicly perform and distribute its *Work* and any resulting  
+derivative works in any form.  
+
+## 4.  Limitations  
+
+**4.1 Redistribution.** You may reproduce or distribute the *Work* only if (a) you do  
+so under this License, (b) you include a complete copy of this License with  
+your distribution, and (c) you retain without modification any copyright,  
+patent, trademark, or attribution notices that are present in the *Work*.  
+
+**4.2 Derivative Works.** You may specify that additional or different terms apply  
+to the use, reproduction, and distribution of your derivative works of the *Work*  
+("Your Terms") only if (a) Your Terms provide that the use limitation in  
+Section 2 applies to your derivative works, and (b) you identify the specific  
+derivative works that are subject to Your Terms. Notwithstanding Your Terms,  
+this License (including the redistribution requirements in Section 3.1) will  
+continue to apply to the *Work* itself.  
+
+**4.3** Any other use without of prior consent of Licensors is prohibited. Research  
+users explicitly acknowledge having received from Licensors all information  
+allowing to appreciate the adequacy between of the *Software* and their needs and  
+to undertake all necessary precautions for its execution and use.  
+
+**4.4** The *Software* is provided both as a compiled library file and as source  
+code. In case of using the *Software* for a publication or other results obtained  
+through the use of the *Software*, users are strongly encouraged to cite the  
+corresponding publications as explained in the documentation of the *Software*.  
+
+## 5.  Disclaimer  
+
+THE USER CANNOT USE, EXPLOIT OR DISTRIBUTE THE *SOFTWARE* FOR COMMERCIAL PURPOSES  
+WITHOUT PRIOR AND EXPLICIT CONSENT OF LICENSORS. YOU MUST CONTACT INRIA FOR ANY  
+UNAUTHORIZED USE: stip-sophia.transfert@inria.fr . ANY SUCH ACTION WILL  
+CONSTITUTE A FORGERY. THIS *SOFTWARE* IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES  
+OF ANY NATURE AND ANY EXPRESS OR IMPLIED WARRANTIES, WITH REGARDS TO COMMERCIAL  
+USE, PROFESSIONNAL USE, LEGAL OR NOT, OR OTHER, OR COMMERCIALISATION OR  
+ADAPTATION. UNLESS EXPLICITLY PROVIDED BY LAW, IN NO EVENT, SHALL INRIA OR THE  
+AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR  
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE  
+GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION)  
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT  
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING FROM, OUT OF OR  
+IN CONNECTION WITH THE *SOFTWARE* OR THE USE OR OTHER DEALINGS IN THE *SOFTWARE*.  
+
+## 6.  Files subject to permissive licenses
+The contents of the file ```utils/loss_utils.py``` are based on publicly available code authored by Evan Su, which falls under the permissive MIT license. 
+
+Title: pytorch-ssim\
+Project code: https://github.com/Po-Hsun-Su/pytorch-ssim\
+Copyright Evan Su, 2017\
+License: https://github.com/Po-Hsun-Su/pytorch-ssim/blob/master/LICENSE.txt (MIT)