Upload 34 files

data/__init__.py

@@ -0,0 +1,85 @@
+"""
+__init__.py
+Enables dynamic loading of datasets, depending on an argument.
+"""
+import importlib
+import torch.utils.data
+from data.base_dataset import BaseDataset
+
+
+def find_dataset_using_name(dataset_name):
+    """Import the module "data/[dataset_name]_dataset.py".
+
+    In the file, the class called DatasetNameDataset() will
+    be instantiated. It has to be a subclass of BaseDataset,
+    and it is case-insensitive.
+    """
+    dataset_filename = "data." + dataset_name + "_dataset"
+    datasetlib = importlib.import_module(dataset_filename)
+
+    dataset = None
+    target_dataset_name = dataset_name.replace('_', '') + 'dataset'
+    for name, cls in datasetlib.__dict__.items():
+        if name.lower() == target_dataset_name.lower() \
+           and issubclass(cls, BaseDataset):
+            dataset = cls
+
+    if dataset is None:
+        raise NotImplementedError("In %s.py, there should be a subclass of BaseDataset with class name that matches %s in lowercase." % (dataset_filename, target_dataset_name))
+
+    return dataset
+
+
+def create_dataset(opt):
+    """Create a dataset given the option.
+
+    This function wraps the class CustomDatasetDataLoader.
+        This is the main interface between this package and 'train.py'/'remove_duplicate_xml.py'
+
+    Example:
+        >>> from data import create_dataset
+        >>> dataset = create_dataset(opt)
+    """
+    data_loader = CustomDatasetDataLoader(opt)
+    dataset = data_loader.load_data()
+    return dataset
+
+def get_dataset_options(dataset_name):
+    dataset_filename = "data." + dataset_name + "_dataset"
+    datalib = importlib.import_module(dataset_filename)
+    for name, cls in datalib.__dict__.items():
+        if name.lower() == 'datasetoptions':
+            return cls
+    return None
+
+class CustomDatasetDataLoader():
+    """Wrapper class of Dataset class that performs multi-threaded data loading"""
+
+    def __init__(self, opt):
+        """Initialize this class
+
+        Step 1: create a dataset instance given the name [dataset_mode]
+        Step 2: create a multi-threaded data loader.
+        """
+        self.opt = opt
+        dataset_class = find_dataset_using_name(opt.dataset_mode)
+        self.dataset = dataset_class(opt)
+        self.dataloader = torch.utils.data.DataLoader(
+            self.dataset,
+            batch_size=opt.batch_size,
+            shuffle=not opt.serial_batches,
+            num_workers=int(opt.num_threads))
+
+    def load_data(self):
+        return self
+
+    def __len__(self):
+        """Return the number of data in the dataset"""
+        return min(len(self.dataset), self.opt.max_dataset_size)
+
+    def __iter__(self):
+        """Return a batch of data"""
+        for i, data in enumerate(self.dataloader):
+            if i * self.opt.batch_size >= self.opt.max_dataset_size:
+                break
+            yield data

data/base_dataset.py

@@ -0,0 +1,148 @@
+"""
+base_dataset.py:
+All datasets are a subclass of BaseDataset and implement abstract methods.
+Includes augmentation strategies which can be used at sampling time.
+"""
+import random
+import numpy as np
+import torch.utils.data as data
+from PIL import Image
+import torchvision.transforms as transforms
+from abc import ABC, abstractmethod
+import logging
+
+logging.basicConfig(level=logging.WARNING)
+logger = logging.getLogger(__name__)
+
+class BaseDataset(data.Dataset, ABC):
+    """This class is an abstract base class (ABC) for datasets.
+
+    To create a subclass, you need to implement the following four functions:
+    -- <__init__>:                      initialize the class, first call BaseDataset.__init__(self, opt).
+    -- <__len__>:                       return the size of dataset.
+    -- <__getitem__>:                   get a data point.
+    """
+
+    def __init__(self, opt):
+        """Initialize the class; save the options in the class
+
+        Parameters:
+            opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
+        """
+        self.opt = opt
+        self.root = opt.dataroot
+
+    @abstractmethod
+    def __len__(self):
+        """Return the total number of images in the dataset."""
+        return 0
+
+    @abstractmethod
+    def __getitem__(self, index):
+        """Return a data point and its metadata information.
+
+        Parameters:
+            index - - a random integer for data indexing
+
+        Returns:
+            a dictionary of data with their names. It ususally contains the data itself and its metadata information.
+        """
+        pass
+
+
+def get_params(opt, size):
+    w, h = size
+    new_h = h
+    new_w = w
+    if opt.preprocess == 'resize_and_crop':
+        new_h = new_w = opt.load_size
+    elif opt.preprocess == 'scale_width_and_crop':
+        new_w = opt.load_size
+        new_h = opt.load_size * h // w
+
+    x = random.randint(0, np.maximum(0, new_w - opt.crop_size))
+    y = random.randint(0, np.maximum(0, new_h - opt.crop_size))
+    flip = random.random() > 0.5
+
+    return {'crop_pos': (x, y), 'flip': flip}
+
+
+def get_transform(opt, params=None, grayscale=False, method=Image.BICUBIC, convert=True):
+    transform_list = []
+    if grayscale:
+        transform_list.append(transforms.Grayscale(1))
+    if 'resize' in opt.preprocess:
+        osize = [opt.load_size, opt.load_size]
+        transform_list.append(transforms.Resize(osize, method))
+    elif 'scale_width' in opt.preprocess:
+        transform_list.append(transforms.Lambda(lambda img: __scale_width(img, opt.load_size, opt.crop_size, method)))
+
+    if 'crop' in opt.preprocess:
+        if params is None:
+            transform_list.append(transforms.RandomCrop(opt.crop_size))
+        else:
+            transform_list.append(transforms.Lambda(lambda img: __crop(img, params['crop_pos'], opt.crop_size)))
+
+    if opt.preprocess == 'none':
+        transform_list.append(transforms.Lambda(lambda img: __make_power_2(img, base=1, method=method)))
+
+    if not opt.no_flip:
+        if params is None:
+            transform_list.append(transforms.RandomHorizontalFlip())
+        elif params['flip']:
+            transform_list.append(transforms.Lambda(lambda img: __flip(img, params['flip'])))
+
+    if convert:
+        transform_list += [transforms.ToTensor()]
+        if grayscale:
+            transform_list += [transforms.Normalize((0.5,), (0.5,))]
+        else:
+            transform_list += [transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
+    return transforms.Compose(transform_list)
+
+
+def __make_power_2(img, base, method=Image.BICUBIC):
+    ow, oh = img.size
+    h = int(round(oh / base) * base)
+    w = int(round(ow / base) * base)
+    if h == oh and w == ow:
+        return img
+
+    __print_size_warning(ow, oh, w, h)
+    return img.resize((w, h), method)
+
+
+def __scale_width(img, target_size, crop_size, method=Image.BICUBIC):
+    ow, oh = img.size
+    if ow == target_size and oh >= crop_size:
+        return img
+    w = target_size
+    h = int(max(target_size * oh / ow, crop_size))
+    return img.resize((w, h), method)
+
+
+def __crop(img, pos, size):
+    ow, oh = img.size
+    x1, y1 = pos
+    tw = th = size
+    if (ow > tw or oh > th):
+        return img.crop((x1, y1, x1 + tw, y1 + th))
+    return img
+
+
+def __flip(img, flip):
+    if flip:
+        return img.transpose(Image.FLIP_LEFT_RIGHT)
+    return img
+
+
+def __print_size_warning(ow, oh, w, h):
+    """Print warning information about image size (only print once)"""
+    if not hasattr(__print_size_warning, 'has_printed'):
+        logger.warning(
+            f"The image size needs to be a multiple of 4. "
+            f"The loaded image size was ({ow}, {oh}), so it was adjusted to "
+            f"({w}, {h}). This adjustment will be done to all images "
+            f"whose sizes are not multiples of 4"
+        )
+        __print_size_warning.has_printed = True

data/day2timelapse_dataset.py

@@ -0,0 +1,173 @@
+"""
+day2timelapse_dataset.py:
+Dataset loader for day2timelapse. It loads images belonging to Waymo
+Day/Dusk/Dawn/Night splits and it applies a tone mapping operator to
+the "Day" ones in order to drive learning with CoMoGAN.
+It has support for custom options in DatasetOptions.
+"""
+
+import os.path
+
+import numpy as np
+import math
+from data.base_dataset import BaseDataset, get_transform
+from PIL import Image
+import random
+from torchvision.transforms import ToTensor
+import torch
+import munch
+
+
+def DatasetOptions():
+    do = munch.Munch()
+    do.num_threads = 4
+    do.batch_size = 1
+    do.preprocess = 'none'
+    do.max_dataset_size = float('inf')
+    do.no_flip = False
+    do.serial_batches = False
+    return do
+
+
+class Day2TimelapseDataset(BaseDataset):
+    """
+    This dataset class can load unaligned/unpaired datasets.
+
+    It requires two directories to host training images from domain A '/path/to/data/trainA'
+    and from domain B '/path/to/data/trainB' respectively.
+    You can train the model with the dataset flag '--dataroot /path/to/data'.
+    Similarly, you need to prepare two directories:
+    '/path/to/data/testA' and '/path/to/data/testB' during test time.
+    """
+
+    def __init__(self, opt):
+        """Initialize this dataset class.
+
+        Parameters:
+            opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions
+        """
+        BaseDataset.__init__(self, opt)
+        self.dir_day = os.path.join(opt.dataroot, 'sunny', 'Day')
+        self.dir_dusk = os.path.join(opt.dataroot, 'sunny', 'Dawn', 'Dusk')
+        self.dir_night = os.path.join(opt.dataroot, 'sunny', 'Night')
+        self.A_paths = [os.path.join(self.dir_day, x) for x in os.listdir(self.dir_day)]   # load images from '/path/to/data/trainA'
+        self.B_paths = [os.path.join(self.dir_dusk, x) for x in os.listdir(self.dir_dusk)]    # load images from '/path/to/data/trainB'
+        self.B_paths += [os.path.join(self.dir_night, x) for x in os.listdir(self.dir_night)]    # load images from '/path/to/data/trainB'
+
+        self.A_size = len(self.A_paths)  # get the size of dataset A
+        self.B_size = len(self.B_paths)  # get the size of dataset B
+        self.A_paths.sort()
+        self.B_paths.sort()
+        self.transform_A = get_transform(self.opt, grayscale=(opt.input_nc == 1), convert=False)
+        self.transform_B = get_transform(self.opt, grayscale=(opt.output_nc == 1), convert=False)
+
+        self.__tonemapping = torch.tensor(np.loadtxt('./data/daytime_model_lut.csv', delimiter=','),
+                                   dtype=torch.float32)
+
+        self.__xyz_matrix = torch.tensor([[0.5149,   0.3244,   0.1607],
+                                   [0.2654,   0.6704,   0.0642],
+                                   [0.0248,   0.1248,   0.8504]])
+
+    def __getitem__(self, index):
+        """Return a data point and its metadata information.
+
+        Parameters:
+            index (int)      -- a random integer for data indexing
+
+        Returns a dictionary that contains A, B, A_paths and B_paths
+            A (tensor)       -- an image in the input domain
+            B (tensor)       -- its corresponding image in the target domain
+            A_paths (str)    -- image paths
+            B_paths (str)    -- image paths
+        """
+        A_path = self.A_paths[index % self.A_size]  # make sure index is within then range
+        index_B = random.randint(0, self.B_size - 1)
+        B_path = self.B_paths[index_B]
+
+        A_img = Image.open(A_path).convert('RGB')
+        B_img = Image.open(B_path).convert('RGB')
+
+        # apply image transformation
+        A = self.transform_A(A_img)
+        B = self.transform_B(B_img)
+
+        # Define continuity normalization
+        A = ToTensor()(A)
+        B = ToTensor()(B)
+
+        phi = random.random() * 2 * math.pi
+        continuity_sin = math.sin(phi)
+        cos_phi = math.cos(phi)
+
+        A_cont = self.__apply_colormap(A, cos_phi, continuity_sin)
+
+        phi_prime = random.random() * 2 * math.pi
+        sin_phi_prime = math.sin(phi_prime)
+        cos_phi_prime = math.cos(phi_prime)
+
+        A_cont_compare = self.__apply_colormap(A, cos_phi_prime, sin_phi_prime)
+
+        # Normalization between -1 and 1
+        A = (A * 2) - 1
+        B = (B * 2) - 1
+        A_cont = (A_cont * 2) - 1
+        A_cont_compare = (A_cont_compare * 2) - 1
+
+
+        return {'A': A, 'B': B, 'A_cont': A_cont, 'A_paths': A_path, 'B_paths': B_path, 'cos_phi': float(cos_phi),
+                'sin_phi': float(continuity_sin), 'sin_phi_prime': float(sin_phi_prime),
+                'cos_phi_prime': float(cos_phi_prime), 'A_cont_compare': A_cont_compare, 'phi': phi,
+                'phi_prime': phi_prime,}
+
+    def __len__(self):
+        """Return the total number of images in the dataset.
+
+        As we have two datasets with potentially different number of images,
+        we take a maximum of
+        """
+        return max(self.A_size, self.B_size)
+
+    def __apply_colormap(self, im, cos_phi, sin_phi, eps = 1e-8):
+        size_0, size_1, size_2 = im.size()
+        cos_phi_norm = 1 - (cos_phi + 1) / 2 # 0 in 0, 1 in pi
+        im_buf = im.permute(1, 2, 0).view(-1, 3)
+        im_buf = torch.matmul(im_buf, self.__xyz_matrix)
+
+        X = im_buf[:, 0] + eps
+        Y = im_buf[:, 1]
+        Z = im_buf[:, 2]
+
+        V = Y * (1.33 * (1 + (Y + Z) / X) - 1.68)
+
+        tmp_index_lower = int(cos_phi_norm * self.__tonemapping.size(0))
+
+        if tmp_index_lower < self.__tonemapping.size(0) - 1:
+            tmp_index_higher = tmp_index_lower + 1
+        else:
+            tmp_index_higher = tmp_index_lower
+        interp_index = cos_phi_norm * self.__tonemapping.size(0) - tmp_index_lower
+        try:
+            color_lower = self.__tonemapping[tmp_index_lower, :3]
+        except IndexError:
+            color_lower = self.__tonemapping[-2, :3]
+        try:
+            color_higher = self.__tonemapping[tmp_index_higher, :3]
+        except IndexError:
+            color_higher = self.__tonemapping[-2, :3]
+        color = color_lower * (1 - interp_index) + color_higher * interp_index
+
+
+        if sin_phi >= 0:
+            # red shift
+            corr = torch.tensor([0.1, 0, 0.1]) * sin_phi # old one was 0.03
+        if sin_phi < 0:
+            # purple shift
+            corr = torch.tensor([0.1, 0, 0]) * (- sin_phi)
+
+        color += corr
+        im_degree = V.unsqueeze(1) * torch.matmul(color, self.__xyz_matrix)
+        im_degree = torch.matmul(im_degree, self.__xyz_matrix.inverse()).view(size_1, size_2, size_0).permute(2, 0, 1)
+        im_final = im_degree * cos_phi_norm + im * (1 - cos_phi_norm) + corr.unsqueeze(-1).unsqueeze(-1).repeat(1, im_degree.size(1), im_degree.size(2))
+
+        im_final = im_final.clamp(0, 1)
+        return im_final

data/daytime_model_lut.csv

@@ -0,0 +1,550 @@
+0.459730327129364,0.5753538012504578,0.7307513356208801
+0.4594928026199341,0.5749730467796326,0.7301026582717896
+0.4592478573322296,0.5745759606361389,0.7294389009475708
+0.458999365568161,0.5741816163063049,0.7287785410881042
+0.458759605884552,0.573775589466095,0.7281114459037781
+0.45850908756256104,0.5733696222305298,0.7274336218833923
+0.4582521319389343,0.5729745030403137,0.7267529964447021
+0.4580022394657135,0.5725727081298828,0.7260730862617493
+0.4577447474002838,0.5721668601036072,0.7253925204277039
+0.4574819803237915,0.5717566609382629,0.7247171998023987
+0.4572221636772156,0.5713460445404053,0.7240318655967712
+0.4569593071937561,0.5709385275840759,0.723334014415741
+0.4566876292228699,0.5705302357673645,0.7226318717002869
+0.456419438123703,0.5701059699058533,0.7219248414039612
+0.45614975690841675,0.5696818232536316,0.7212276458740234
+0.45587342977523804,0.5692545175552368,0.7205167412757874
+0.4555920660495758,0.5688228011131287,0.7198204398155212
+0.45531001687049866,0.5684027075767517,0.7190941572189331
+0.45502665638923645,0.5679745674133301,0.7183746695518494
+0.4547405242919922,0.5675432682037354,0.7176563739776611
+0.4544476568698883,0.5671043395996094,0.7169240713119507
+0.4541616141796112,0.5666742324829102,0.7161986231803894
+0.45386913418769836,0.5662345290184021,0.7154660820960999
+0.45357248187065125,0.565789520740509,0.7147201895713806
+0.45327311754226685,0.565341591835022,0.713971734046936
+0.452972412109375,0.5648908019065857,0.7132329344749451
+0.45267778635025024,0.5644432902336121,0.7124903202056885
+0.45237043499946594,0.5639790892601013,0.7117367386817932
+0.45206570625305176,0.5635237693786621,0.7109693288803101
+0.45175883173942566,0.563062310218811,0.7101975083351135
+0.4514491856098175,0.5626062750816345,0.7094336152076721
+0.45112910866737366,0.5621491074562073,0.7086634635925293
+0.45080673694610596,0.5616856813430786,0.7078953981399536
+0.45049235224723816,0.5612045526504517,0.707120418548584
+0.45016390085220337,0.5607321262359619,0.7063286900520325
+0.44983530044555664,0.5602567791938782,0.7055374979972839
+0.4495112895965576,0.5597798228263855,0.7047412991523743
+0.4491833746433258,0.5593019723892212,0.7039420008659363
+0.44884371757507324,0.5588300824165344,0.7031435966491699
+0.4485161304473877,0.5583317279815674,0.7023458480834961
+0.4481812119483948,0.5578548312187195,0.7015211582183838
+0.44783902168273926,0.5573652386665344,0.7006900906562805
+0.44750285148620605,0.5568601489067078,0.6998854875564575
+0.44716599583625793,0.5563632845878601,0.6990556120872498
+0.4468209147453308,0.5558644533157349,0.6982278227806091
+0.4464694857597351,0.5553638935089111,0.6973857879638672
+0.44611290097236633,0.554855227470398,0.6965429782867432
+0.44575873017311096,0.5543461441993713,0.6956973671913147
+0.44539836049079895,0.5538337826728821,0.6948440670967102
+0.44503751397132874,0.5533230900764465,0.6939923763275146
+0.4446791708469391,0.5528026223182678,0.6931226849555969
+0.4443178176879883,0.5522757768630981,0.6922490000724792
+0.44394853711128235,0.5517544746398926,0.6913824081420898
+0.44358089566230774,0.551224946975708,0.6905091404914856
+0.44321173429489136,0.5507016181945801,0.6896212100982666
+0.44284260272979736,0.5501687526702881,0.6887242197990417
+0.4424705505371094,0.5496318340301514,0.687828540802002
+0.4420968294143677,0.5491050481796265,0.6869293451309204
+0.4417157471179962,0.5485673546791077,0.6860166192054749
+0.44132229685783386,0.5480145215988159,0.6851045489311218
+0.4409382939338684,0.5474622249603271,0.684185802936554
+0.4405543804168701,0.5469011664390564,0.6832549571990967
+0.44016018509864807,0.5463506579399109,0.6823207139968872
+0.43976613879203796,0.5457964539527893,0.6813837289810181
+0.439370721578598,0.5452314615249634,0.6804408431053162
+0.4389679431915283,0.5446683168411255,0.679487407207489
+0.43856877088546753,0.5441105961799622,0.6785308122634888
+0.43817123770713806,0.5435311794281006,0.6775607466697693
+0.43776628375053406,0.5429514646530151,0.6765934228897095
+0.4373634457588196,0.5423672795295715,0.6756237149238586
+0.4369603097438812,0.5417906641960144,0.6746310591697693
+0.43654337525367737,0.5412123203277588,0.6736356019973755
+0.43612799048423767,0.5406161546707153,0.6726331114768982
+0.43570569157600403,0.5400263667106628,0.6716299057006836
+0.43528664112091064,0.5394323468208313,0.670623779296875
+0.4348626732826233,0.5388368368148804,0.6695924401283264
+0.4344364404678345,0.5382305383682251,0.6685694456100464
+0.43401214480400085,0.5376153588294983,0.6675337553024292
+0.433585524559021,0.537000298500061,0.6664865016937256
+0.433156281709671,0.5363917350769043,0.6654470562934875
+0.43273061513900757,0.5357779860496521,0.6643723249435425
+0.4322899281978607,0.5351535081863403,0.6633078455924988
+0.431845486164093,0.5345269441604614,0.6622382998466492
+0.4313971996307373,0.5338884592056274,0.6611512899398804
+0.43095406889915466,0.5332503914833069,0.660057783126831
+0.43050533533096313,0.5326089262962341,0.6589553952217102
+0.4300559163093567,0.5319759845733643,0.6578448414802551
+0.42960599064826965,0.5313165187835693,0.6567374467849731
+0.42915093898773193,0.5306854844093323,0.655599057674408
+0.42869460582733154,0.5300273299217224,0.6544656157493591
+0.42823490500450134,0.5293539762496948,0.6533178687095642
+0.42778128385543823,0.5286882519721985,0.6521674394607544
+0.4273095428943634,0.5280155539512634,0.6510041952133179
+0.42683160305023193,0.5273396372795105,0.6498340368270874
+0.42636018991470337,0.5266631841659546,0.6486470699310303
+0.42588356137275696,0.5259905457496643,0.6474630832672119
+0.42541661858558655,0.5252941846847534,0.6462488770484924
+0.42492032051086426,0.5246042013168335,0.6450435519218445
+0.4244424104690552,0.5239027738571167,0.6438180804252625
+0.42396286129951477,0.5231947302818298,0.6425884366035461
+0.4234755039215088,0.5224864482879639,0.6413478255271912
+0.4229883551597595,0.5217775106430054,0.6400837302207947
+0.42249560356140137,0.5210569500923157,0.638817548751831
+0.4219900071620941,0.5203303694725037,0.6375637054443359
+0.4214840233325958,0.5195984840393066,0.6362555623054504
+0.420978307723999,0.518863320350647,0.6349571347236633
+0.42047688364982605,0.5181199908256531,0.6336472630500793
+0.4199632704257965,0.5173732042312622,0.6323349475860596
+0.4194590151309967,0.5166250467300415,0.6309912800788879
+0.4189481735229492,0.5158714056015015,0.6296461224555969
+0.41842934489250183,0.5150937438011169,0.6282913684844971
+0.41790279746055603,0.5143157243728638,0.6269145607948303
+0.41737210750579834,0.5135502219200134,0.6255266666412354
+0.41685158014297485,0.5127615928649902,0.624131977558136
+0.41631534695625305,0.5119665861129761,0.6227325201034546
+0.4157761037349701,0.5111815333366394,0.6212867498397827
+0.41524171829223633,0.5103685259819031,0.6198469400405884
+0.41469940543174744,0.5095604062080383,0.6184101700782776
+0.4141487181186676,0.5087331533432007,0.6169341802597046
+0.41360774636268616,0.5079103112220764,0.6154453158378601
+0.41305631399154663,0.5070822238922119,0.6139618754386902
+0.41250190138816833,0.5062423944473267,0.6124515533447266
+0.4119435250759125,0.5053935050964355,0.6109218001365662
+0.4113782048225403,0.5045426487922668,0.6093810796737671
+0.4108012318611145,0.5036604404449463,0.6078344583511353
+0.41021865606307983,0.5027989149093628,0.6062476634979248
+0.40964311361312866,0.5019211769104004,0.6046628355979919
+0.4090559482574463,0.5010314583778381,0.6030641794204712
+0.40848174691200256,0.5001277923583984,0.6014267206192017
+0.4078844487667084,0.4992227256298065,0.5997909903526306
+0.40730759501457214,0.49830612540245056,0.598132848739624
+0.40671131014823914,0.49738460779190063,0.5964401364326477
+0.40611180663108826,0.4964587688446045,0.5947580337524414
+0.40548941493034363,0.4955010712146759,0.5930367708206177
+0.40487435460090637,0.49454042315483093,0.5913069844245911
+0.40426012873649597,0.49358218908309937,0.5895541310310364
+0.40364205837249756,0.4926128387451172,0.5877792239189148
+0.403017520904541,0.49162688851356506,0.5859869718551636
+0.40238481760025024,0.4906262755393982,0.5841830968856812
+0.4017612040042877,0.4896088242530823,0.5823368430137634
+0.40111586451530457,0.4885888397693634,0.5804885625839233
+0.40046021342277527,0.48756441473960876,0.5786120891571045
+0.3997982442378998,0.4865255057811737,0.5767055153846741
+0.3991381525993347,0.48545724153518677,0.5747894644737244
+0.39847657084465027,0.4843839108943939,0.5728437900543213
+0.39780861139297485,0.483305960893631,0.5708560943603516
+0.3971324861049652,0.48220762610435486,0.5688844323158264
+0.39645910263061523,0.481110543012619,0.5668579339981079
+0.39577189087867737,0.47997036576271057,0.5648245215415955
+0.3950742483139038,0.4788309633731842,0.5627452731132507
+0.3943650722503662,0.47768348455429077,0.5606535077095032
+0.39365389943122864,0.47651612758636475,0.5585283637046814
+0.3929373323917389,0.4753277897834778,0.5563767552375793
+0.39221417903900146,0.47412094473838806,0.5542060732841492
+0.3914814591407776,0.4729042649269104,0.5519970059394836
+0.39075806736946106,0.4716648459434509,0.5497605204582214
+0.3900115489959717,0.47042933106422424,0.5475006103515625
+0.3892611861228943,0.46914219856262207,0.5451998710632324
+0.38850077986717224,0.4678474962711334,0.5428621768951416
+0.3877239525318146,0.46654823422431946,0.5405064821243286
+0.3869464695453644,0.46522289514541626,0.538112461566925
+0.3861497938632965,0.4638678729534149,0.5356920957565308
+0.3853657841682434,0.4624985158443451,0.5332329273223877
+0.38455796241760254,0.46110445261001587,0.5307305455207825
+0.3837466537952423,0.4596961438655853,0.5282090902328491
+0.38293153047561646,0.45825865864753723,0.5256560444831848
+0.3821004629135132,0.4567857086658478,0.5230585932731628
+0.38125377893447876,0.4553035795688629,0.5204059481620789
+0.38039880990982056,0.45381414890289307,0.5177400708198547
+0.37953537702560425,0.4522625207901001,0.51502925157547
+0.3786587119102478,0.45070064067840576,0.5122591257095337
+0.37777724862098694,0.4491199254989624,0.5094778537750244
+0.3768831491470337,0.4475046694278717,0.5066356658935547
+0.3759765923023224,0.44584921002388,0.5037559270858765
+0.3750581443309784,0.44417664408683777,0.5008141398429871
+0.3741254210472107,0.4424605667591095,0.49784529209136963
+0.3731728792190552,0.4407256543636322,0.49482280015945435
+0.3722169101238251,0.43895307183265686,0.49173426628112793
+0.3712415397167206,0.437146931886673,0.4886254668235779
+0.3702535331249237,0.4353068768978119,0.48544999957084656
+0.3692600429058075,0.4334242045879364,0.48222681879997253
+0.36825886368751526,0.43151819705963135,0.4789440333843231
+0.3672138452529907,0.4295523762702942,0.4756050109863281
+0.3661661744117737,0.42755672335624695,0.47219815850257874
+0.36509427428245544,0.4255349636077881,0.4687524437904358
+0.3640132248401642,0.42343634366989136,0.46522557735443115
+0.36291468143463135,0.4213179647922516,0.46163472533226013
+0.361807644367218,0.4191555678844452,0.4579890966415405
+0.3606717586517334,0.416931688785553,0.45428794622421265
+0.3595023453235626,0.41466543078422546,0.4504820704460144
+0.35832664370536804,0.41234973073005676,0.4466261863708496
+0.35711705684661865,0.4099692702293396,0.4426766335964203
+0.35588809847831726,0.4075412154197693,0.4386715292930603
+0.35465407371520996,0.40505969524383545,0.43457621335983276
+0.3533867597579956,0.4025226831436157,0.4303874671459198
+0.35206907987594604,0.39990124106407166,0.4261210262775421
+0.3507366180419922,0.39723485708236694,0.4217650294303894
+0.3493753671646118,0.3945018947124481,0.41731685400009155
+0.34797582030296326,0.39169758558273315,0.412770539522171
+0.3465687334537506,0.38880959153175354,0.4081324338912964
+0.3450928330421448,0.38585978746414185,0.4033951163291931
+0.3435814380645752,0.3828301429748535,0.3985316753387451
+0.34203478693962097,0.3797179162502289,0.3935818076133728
+0.34045159816741943,0.3765098750591278,0.38850077986717224
+0.3388141989707947,0.3732281029224396,0.3833079934120178
+0.33710336685180664,0.3698435425758362,0.37798795104026794
+0.3353625237941742,0.36637309193611145,0.37254491448402405
+0.3335549533367157,0.36279526352882385,0.3669710159301758
+0.3316671550273895,0.35910558700561523,0.3612686097621918
+0.3297062814235687,0.35532188415527344,0.355435848236084
+0.32766276597976685,0.3513968288898468,0.3494633734226227
+0.3255484998226166,0.34735408425331116,0.3433668315410614
+0.3232938051223755,0.34319281578063965,0.33710920810699463
+0.3209540843963623,0.33887505531311035,0.33072924613952637
+0.3184846043586731,0.33441248536109924,0.32422009110450745
+0.3158607482910156,0.3297947347164154,0.31760966777801514
+0.3130861818790436,0.32502415776252747,0.3108745515346527
+0.31010496616363525,0.32008421421051025,0.30407488346099854
+0.30692198872566223,0.31495949625968933,0.2972620725631714
+0.30347248911857605,0.3096488118171692,0.29043811559677124
+0.29973623156547546,0.30414119362831116,0.2837555706501007
+0.2956545352935791,0.2984755039215088,0.2773210108280182
+0.2911142408847809,0.2926393747329712,0.27137941122055054
+0.2860235571861267,0.28671175241470337,0.26624587178230286
+0.2802514433860779,0.2808597981929779,0.26253658533096313
+0.2736779451370239,0.27554765343666077,0.2614668607711792
+0.2717041075229645,0.2730359733104706,0.2575526833534241
+0.26287510991096497,0.2601219117641449,0.23883278667926788
+0.24991470575332642,0.24898554384708405,0.23122084140777588
+0.2362339198589325,0.23734308779239655,0.2233717292547226
+0.22170411050319672,0.22508057951927185,0.2152479737997055
+0.20608031749725342,0.2121061235666275,0.20679286122322083
+0.18908119201660156,0.19821850955486298,0.1979656219482422
+0.17017780244350433,0.18320739269256592,0.18870970606803894
+0.14857418835163116,0.1667228788137436,0.17891544103622437
+0.1224466860294342,0.14806653559207916,0.16848649084568024
+0.1157052144408226,0.1434480845928192,0.16584351658821106
+0.11541308462619781,0.1431066393852234,0.16541849076747894
+0.11511941254138947,0.14277100563049316,0.16503721475601196
+0.11482298374176025,0.14245407283306122,0.16464921832084656
+0.11456697434186935,0.14208628237247467,0.16424468159675598
+0.1142779067158699,0.14172402024269104,0.16386310756206512
+0.11400596797466278,0.14137032628059387,0.1634616255760193
+0.11372455209493637,0.14102306962013245,0.16305187344551086
+0.1134345605969429,0.14065253734588623,0.16262774169445038
+0.11316171288490295,0.14030128717422485,0.16221247613430023
+0.11287751793861389,0.13994424045085907,0.16180670261383057
+0.11260131001472473,0.1395883858203888,0.16140402853488922
+0.11232449859380722,0.13923928141593933,0.1610090136528015
+0.11203785985708237,0.13889294862747192,0.16057752072811127
+0.1117628738284111,0.1385435312986374,0.16015218198299408
+0.11146491020917892,0.13817943632602692,0.15973569452762604
+0.11116664856672287,0.1378205418586731,0.15932902693748474
+0.11088062077760696,0.13746285438537598,0.15890979766845703
+0.11058665812015533,0.13711130619049072,0.15851260721683502
+0.11027919501066208,0.1367616057395935,0.1581237018108368
+0.10998125374317169,0.13638892769813538,0.15768671035766602
+0.10970167070627213,0.13604319095611572,0.15725676715373993
+0.10939911752939224,0.13565398752689362,0.15681979060173035
+0.10909074544906616,0.1352950930595398,0.1564066857099533
+0.10879003256559372,0.13489913940429688,0.1559758335351944
+0.10849147289991379,0.1345341056585312,0.15554526448249817
+0.10821433365345001,0.13415195047855377,0.15510676801204681
+0.1079074963927269,0.13379794359207153,0.15468142926692963
+0.10759484022855759,0.13342680037021637,0.15426495671272278
+0.10731127858161926,0.13305748999118805,0.15383288264274597
+0.10699524730443954,0.13268664479255676,0.15340934693813324
+0.10669667273759842,0.13230416178703308,0.1529696136713028
+0.1064268946647644,0.13193699717521667,0.15254120528697968
+0.10611913353204727,0.13156461715698242,0.1521192193031311
+0.1058175191283226,0.13117694854736328,0.1516743004322052
+0.10551097989082336,0.1308014988899231,0.15122537314891815
+0.10521639138460159,0.1304609775543213,0.15079358220100403
+0.10489363223314285,0.13008800148963928,0.15031340718269348
+0.10458341985940933,0.12965714931488037,0.1498822569847107
+0.10426678508520126,0.12927864491939545,0.14943453669548035
+0.1039581149816513,0.12887810170650482,0.1490085870027542
+0.10364361852407455,0.12848612666130066,0.14856210350990295
+0.10331320762634277,0.12810029089450836,0.1481168419122696
+0.10299043357372284,0.12771719694137573,0.14766763150691986
+0.10267441719770432,0.1273200362920761,0.14721347391605377
+0.1023675799369812,0.12692315876483917,0.14676974713802338
+0.10203593969345093,0.12652996182441711,0.14631898701190948
+0.10171746462583542,0.12615300714969635,0.14586883783340454
+0.10139041393995285,0.12573960423469543,0.14537948369979858
+0.10108970105648041,0.12536202371120453,0.14490973949432373
+0.10079051554203033,0.12496238201856613,0.14444120228290558
+0.1004457101225853,0.12456829100847244,0.14399471879005432
+0.10012386739253998,0.12417691946029663,0.14353936910629272
+0.09980478882789612,0.12376443296670914,0.14306899905204773
+0.09949151426553726,0.12334918975830078,0.14258088171482086
+0.09916509687900543,0.12293273210525513,0.14212672412395477
+0.09884171187877655,0.12251226603984833,0.1416735053062439
+0.09852078557014465,0.12210836261510849,0.1411985605955124
+0.09817750006914139,0.12170232087373734,0.1407385915517807
+0.09784004837274551,0.12129472941160202,0.14023515582084656
+0.09749983251094818,0.12088468670845032,0.13974520564079285
+0.09715135395526886,0.1204562708735466,0.1392613649368286
+0.09680776298046112,0.12002327293157578,0.13878118991851807
+0.09647521376609802,0.11962549388408661,0.1383046954870224
+0.09612242877483368,0.11921942979097366,0.1378043293952942
+0.09578743577003479,0.11879591643810272,0.13732844591140747
+0.09543250501155853,0.1183813065290451,0.13683202862739563
+0.09508984535932541,0.11794216930866241,0.13635770976543427
+0.09476371854543686,0.11751621216535568,0.1358637511730194
+0.09443452209234238,0.1170816719532013,0.13537929952144623
+0.09406889230012894,0.11664438247680664,0.1348535120487213
+0.09372377395629883,0.11621322482824326,0.134351909160614
+0.09337314963340759,0.11576368659734726,0.13386225700378418
+0.09304028749465942,0.1153288409113884,0.133339524269104
+0.09269976615905762,0.11487900465726852,0.13282445073127747
+0.0923454537987709,0.11445211619138718,0.13231703639030457
+0.09199421107769012,0.11400656402111053,0.1318105310201645
+0.09161267429590225,0.11357906460762024,0.13130740821361542
+0.09124826639890671,0.11312799900770187,0.13080213963985443
+0.09087098389863968,0.11269347369670868,0.1302950233221054
+0.0905022844672203,0.11225984990596771,0.12975728511810303
+0.09014523774385452,0.11179438978433609,0.12923914194107056
+0.08976306766271591,0.11132708936929703,0.12870876491069794
+0.08938886225223541,0.11086255311965942,0.12817132472991943
+0.08902323246002197,0.11039526015520096,0.12762410938739777
+0.08864809572696686,0.10992548614740372,0.12708179652690887
+0.08828185498714447,0.10947319865226746,0.12655629217624664
+0.0879003033041954,0.10898998379707336,0.12603938579559326
+0.08754109591245651,0.10854779183864594,0.12550778687000275
+0.08715925365686417,0.10806671530008316,0.12495075911283493
+0.08681657910346985,0.10758838802576065,0.12442434579133987
+0.08642704784870148,0.10712629556655884,0.12387222796678543
+0.08604917675256729,0.10667002946138382,0.12330418825149536
+0.0856575071811676,0.10619384795427322,0.12273460626602173
+0.08524961024522781,0.10569407045841217,0.12216013669967651
+0.08483836054801941,0.1052025780081749,0.12161166965961456
+0.08444516360759735,0.10469333827495575,0.12104639410972595
+0.08404585719108582,0.10420826822519302,0.12048505991697311
+0.08364071696996689,0.10371893644332886,0.11991548538208008
+0.08322608470916748,0.10320570319890976,0.11934958398342133
+0.0828365683555603,0.10271328687667847,0.11880083382129669
+0.08243387192487717,0.10221292823553085,0.11820460110902786
+0.08202169835567474,0.10170641541481018,0.11760316789150238
+0.08161503076553345,0.10121677070856094,0.11699624359607697
+0.08121601492166519,0.10073293745517731,0.11640949547290802
+0.0808185338973999,0.10021143406629562,0.11582309007644653
+0.08041829615831375,0.09968657046556473,0.11523452401161194
+0.07999968528747559,0.09916139394044876,0.1146303340792656
+0.07957036048173904,0.09863561391830444,0.11403869092464447
+0.07915082573890686,0.09810125827789307,0.11345718801021576
+0.07870067656040192,0.09754912555217743,0.11282391101121902
+0.07826031744480133,0.09702548384666443,0.11217807978391647
+0.07782057672739029,0.09648560732603073,0.11155429482460022
+0.0773756355047226,0.09595002233982086,0.11092717200517654
+0.07693282514810562,0.0954236164689064,0.1103067398071289
+0.07648970931768417,0.0948687344789505,0.10966303944587708
+0.07605241984128952,0.09435121715068817,0.10905120521783829
+0.07559767365455627,0.09377827495336533,0.10842254757881165
+0.07517079263925552,0.09321480989456177,0.10779201239347458
+0.07470226287841797,0.09263850748538971,0.10710086673498154
+0.07428242266178131,0.09207534790039062,0.10644432157278061
+0.07383013516664505,0.09148313105106354,0.10578931123018265
+0.07337813079357147,0.09090618789196014,0.10509509593248367
+0.07289184629917145,0.0903424397110939,0.10442569106817245
+0.07240494340658188,0.08976029604673386,0.10379272699356079
+0.07192478328943253,0.08917172253131866,0.1031138226389885
+0.07142409682273865,0.08859387785196304,0.10243583470582962
+0.07093475013971329,0.08801420032978058,0.10173121094703674
+0.07044325768947601,0.08741123974323273,0.10102904587984085
+0.06995910406112671,0.08676818013191223,0.10030879825353622
+0.06947772204875946,0.08615327626466751,0.09958089888095856
+0.06896509230136871,0.08553499728441238,0.09889496862888336
+0.06848003715276718,0.08491000533103943,0.09818513691425323
+0.06798884272575378,0.08427488803863525,0.09745294600725174
+0.06751113384962082,0.0836452916264534,0.09674250334501266
+0.06700585782527924,0.08303101360797882,0.09599654376506805
+0.06646904349327087,0.08239223062992096,0.09523190557956696
+0.06592732667922974,0.08174791932106018,0.09444766491651535
+0.0653623417019844,0.08108188956975937,0.09370844066143036
+0.06484022736549377,0.08038890361785889,0.09295084327459335
+0.06428411602973938,0.07972194254398346,0.09216352552175522
+0.06372066587209702,0.07903385162353516,0.09142736345529556
+0.06318140774965286,0.07833933085203171,0.09062627702951431
+0.06263478845357895,0.07766930758953094,0.0897899866104126
+0.062071334570646286,0.0769805982708931,0.08896960318088531
+0.061534520238637924,0.07629863172769547,0.08817525953054428
+0.06096555292606354,0.07558420300483704,0.08734385669231415
+0.060398418456315994,0.07484344393014908,0.08652285486459732
+0.059790559113025665,0.0740959420800209,0.08572086691856384
+0.059174131602048874,0.07335303723812103,0.08482055366039276
+0.058550044894218445,0.07259542495012283,0.08393312245607376
+0.05792197212576866,0.07185190171003342,0.08306373655796051
+0.05730707570910454,0.07108970731496811,0.0821729376912117
+0.056691866368055344,0.07033699005842209,0.08129469305276871
+0.05607237294316292,0.06957050412893295,0.08042500168085098
+0.055435724556446075,0.06874828785657883,0.0794643834233284
+0.05481715500354767,0.06790462881326675,0.07851538807153702
+0.054182350635528564,0.0670781210064888,0.07756548374891281
+0.05346854031085968,0.06624824553728104,0.07659352570772171
+0.05276361107826233,0.06540275365114212,0.07565678656101227
+0.05205194652080536,0.06458421051502228,0.07468605041503906
+0.05134119465947151,0.06373504549264908,0.07364580035209656
+0.05062953010201454,0.06281912326812744,0.07259513437747955
+0.04989795759320259,0.061891257762908936,0.07154660671949387
+0.04918720945715904,0.060972586274147034,0.07051646709442139
+0.04847554489970207,0.060027871280908585,0.06944466382265091
+0.04772529378533363,0.05909694358706474,0.06834499537944794
+0.046907056123018265,0.05815959349274635,0.06719602644443512
+0.046073514968156815,0.05716956779360771,0.06604368984699249
+0.04524242505431175,0.056131161749362946,0.06491249054670334
+0.044410716742277145,0.055077437311410904,0.06375158578157425
+0.043564312160015106,0.05403565987944603,0.06249513849616051
+0.04272831603884697,0.05296080932021141,0.06120256334543228
+0.0418776273727417,0.051906172186136246,0.05995253846049309
+0.04095129668712616,0.050736699253320694,0.05867007002234459
+0.039960961788892746,0.049539968371391296,0.05731777474284172
+0.038953784853219986,0.04831783473491669,0.05587637424468994
+0.0379573218524456,0.04711682349443436,0.05445212125778198
+0.036944933235645294,0.04588426649570465,0.05303368717432022
+0.035924892872571945,0.0445328913629055,0.051456935703754425
+0.034868404269218445,0.04312395304441452,0.049866095185279846
+0.03364961966872215,0.04169970005750656,0.04824923351407051
+0.03240327537059784,0.04026351124048233,0.0465429425239563
+0.03115847148001194,0.038714926689863205,0.0447101853787899
+0.029900187626481056,0.03702608868479729,0.0428403802216053
+0.02859964594244957,0.035308461636304855,0.040890950709581375
+0.027002375572919846,0.0335911326110363,0.03868337348103523
+0.025380603969097137,0.03152747079730034,0.03650704026222229
+0.023741384968161583,0.029405318200588226,0.033972397446632385
+0.021979982033371925,0.02722162753343582,0.03135690093040466
+0.01972923055291176,0.02449806034564972,0.02834027074277401
+0.017425181344151497,0.02169947512447834,0.025121228769421577
+0.014567777514457703,0.017999667674303055,0.02086562104523182
+0.010865208692848682,0.013364309445023537,0.015476967208087444
+0.00415243161842227,0.004356072284281254,0.004636881407350302
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0
+0.0,0.0,0.0

logs/pretrained/tensorboard/default/version_0/checkpoints/iter_000000.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0986dd0ac3cf8ff8147304359fba9fa198155c3ba08875aef37ee3da15d1b841
+size 741391945

logs/pretrained/tensorboard/default/version_0/hparams.yaml

@@ -0,0 +1,105 @@
+batch_size: 1
+beta1: 0.5
+dataroot: /datasets_local/datasets_fpizzati/waymo/train
+dataset_mode: day2timelapse
+decay_iters_step: 100000
+decay_step_gamma: 0.5
+disc_activ: lrelu
+disc_dim: 64
+disc_n_layer: 4
+disc_norm: none
+disc_pad_type: reflect
+display_freq: 10000
+gan_mode: lsgan
+gen_activ: relu
+gen_dim: 64
+gen_pad_type: reflect
+gpu_ids:
+- 4
+init_gain: 0.02
+init_type_disc: normal
+init_type_gen: kaiming
+input_nc: 3
+lambda_Phinet_A: 1
+lambda_compare: 10
+lambda_gan: 1
+lambda_idt: 1
+lambda_physics: 10
+lambda_physics_compare: 1
+lambda_rec_content: 1
+lambda_rec_cycle: 10
+lambda_rec_image: 10
+lambda_rec_style: 1
+lambda_vgg: 0.1
+lr: 0.0001
+lr_policy: step
+max_dataset_size: .inf
+mlp_dim: 256
+model: comomunit
+n_downsample: 2
+n_res: 4
+no_flip: false
+num_scales: 3
+num_threads: 4
+opt: !munch.Munch
+  batch_size: 1
+  beta1: 0.5
+  dataroot: /datasets_local/datasets_fpizzati/waymo/train
+  dataset_mode: day2timelapse
+  decay_iters_step: 100000
+  decay_step_gamma: 0.5
+  disc_activ: lrelu
+  disc_dim: 64
+  disc_n_layer: 4
+  disc_norm: none
+  disc_pad_type: reflect
+  display_freq: 10000
+  gan_mode: lsgan
+  gen_activ: relu
+  gen_dim: 64
+  gen_pad_type: reflect
+  gpu_ids:
+  - 4
+  init_gain: 0.02
+  init_type_disc: normal
+  init_type_gen: kaiming
+  input_nc: 3
+  lambda_Phinet_A: 1
+  lambda_compare: 10
+  lambda_gan: 1
+  lambda_idt: 1
+  lambda_physics: 10
+  lambda_physics_compare: 1
+  lambda_rec_content: 1
+  lambda_rec_cycle: 10
+  lambda_rec_image: 10
+  lambda_rec_style: 1
+  lambda_vgg: 0.1
+  lr: 0.0001
+  lr_policy: step
+  max_dataset_size: .inf
+  mlp_dim: 256
+  model: comomunit
+  n_downsample: 2
+  n_res: 4
+  no_flip: false
+  num_scales: 3
+  num_threads: 4
+  output_nc: 3
+  preprocess: none
+  print_freq: 10
+  resblocks_cont: 1
+  save_epoch_freq: 5
+  save_latest_freq: 35000
+  serial_batches: false
+  style_dim: 8
+  total_iterations: 30000000
+output_nc: 3
+preprocess: none
+print_freq: 10
+resblocks_cont: 1
+save_epoch_freq: 5
+save_latest_freq: 35000
+serial_batches: false
+style_dim: 8
+total_iterations: 30000000

networks/__init__.py

@@ -0,0 +1,52 @@
+"""
+This enables dynamic loading of models, similarly to what happens with the dataset.
+"""
+
+import importlib
+from networks.base_model import BaseModel
+
+
+def find_model_using_name(model_name):
+    """Import the module "networks/[model_name]_model.py".
+
+    In the file, the class called DatasetNameModel() will
+    be instantiated. It has to be a subclass of BaseModel,
+    and it is case-insensitive.
+    """
+    model_filename = "networks." + model_name + "_model"
+    modellib = importlib.import_module(model_filename)
+    model = None
+    target_model_name = model_name.replace('_', '') + 'model'
+    for name, cls in modellib.__dict__.items():
+        if name.lower() == target_model_name.lower() \
+           and issubclass(cls, BaseModel):
+            model = cls
+
+    if model is None:
+        print("In %s.py, there should be a subclass of BaseModel with class name that matches %s in lowercase." % (model_filename, target_model_name))
+        exit(0)
+
+    return model
+
+
+def get_model_options(model_name):
+    model_filename = "networks." + model_name + "_model"
+    modellib = importlib.import_module(model_filename)
+    for name, cls in modellib.__dict__.items():
+        if name.lower() == 'modeloptions':
+            return cls
+    return None
+
+def create_model(opt):
+    """Create a model given the option.
+
+    This function warps the class CustomDatasetDataLoader.
+    This is the main interface between this package and 'train.py'/'remove_duplicate_xml.py'
+
+    Example:
+        >>> from networks import create_model
+        >>> model = create_model(opt)
+    """
+    model = find_model_using_name(opt.model)
+    instance = model(opt)
+    return instance

networks/backbones/__init__.py

@@ -0,0 +1 @@
+from .functions import *

networks/backbones/comomunit.py

@@ -0,0 +1,706 @@
+"""
+comomunit.py
+In this file all architectural components of CoMo-MUNIT are defined. The *logic* is not defined here, but in the *_model.py files.
+Most of the code is copied from https://github.com/NVlabs/MUNIT
+Thttps://github.com/junyanz/pytorch-CycleGAN-and-pix2pixhere are some additional function to get compatibility with the CycleGAN codebase (https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix)
+"""
+
+import torch
+import torch.nn as nn
+from torch.nn import init
+import functools
+from torch.optim import lr_scheduler
+import torch.nn.functional as F
+from .functions import init_net, init_weights, get_scheduler
+
+
+########################################################################################################################
+# MUNIT architecture
+########################################################################################################################
+
+## Functions to get generator / discriminator / DRB
+def define_G_munit(input_nc, output_nc, gen_dim, style_dim, n_downsample, n_res,
+                   pad_type, mlp_dim, activ='relu', init_type = 'kaiming', init_gain=0.02, gpu_ids=[]):
+    gen = AdaINGen(input_nc, output_nc, gen_dim, style_dim, n_downsample, n_res, activ, pad_type, mlp_dim)
+    return init_net(gen, init_type=init_type, init_gain = init_gain, gpu_ids = gpu_ids)
+
+def define_D_munit(input_nc, disc_dim, norm, activ, n_layer, gan_type, num_scales, pad_type,
+                   init_type = 'kaiming', init_gain = 0.02, gpu_ids = [], output_channels = 1, final_function = None):
+    disc = MsImageDis(input_nc, n_layer, gan_type, disc_dim, norm, activ, num_scales, pad_type, output_channels, final_function = final_function)
+    return init_net(disc, init_type=init_type, init_gain = init_gain, gpu_ids = gpu_ids)
+
+def define_DRB_munit(resblocks, dim, norm, activation, pad_type,
+                       init_type = 'kaiming', init_gain = 0.02, gpu_ids = []):
+    demux = DRB(resblocks, dim, norm, activation, pad_type)
+    return init_net(demux, init_type = init_type, init_gain = init_gain, gpu_ids = gpu_ids)
+
+# This class has been strongly modified from MUNIT default version. We split the default MUNIT decoder
+# in AdaINBlock + DecoderNoAdain because the DRB must be placed between the two. encode/assign_adain/decode
+# are called by the network logic following CoMo-MUNIT implementation.
+class AdaINGen(nn.Module):
+    # AdaIN auto-encoder architecture
+    def __init__(self, input_dim, output_dim, dim, style_dim, n_downsample, n_res, activ, pad_type, mlp_dim):
+        super(AdaINGen, self).__init__()
+
+        # style encoder
+        self.enc_style = StyleEncoder(4, input_dim, dim, style_dim, norm='none', activ=activ, pad_type=pad_type)
+
+        # content encoder
+        self.enc_content = ContentEncoder(n_downsample, n_res, input_dim, dim, 'instance', activ, pad_type=pad_type)
+        self.adainblock = AdaINBlock(n_downsample, n_res, self.enc_content.output_dim, output_dim, res_norm='adain', activ=activ, pad_type=pad_type)
+        self.dec = DecoderNoAdain(n_downsample, n_res, self.enc_content.output_dim, output_dim, res_norm='adain', activ=activ, pad_type=pad_type)
+        # MLP to generate AdaIN parameters
+        self.mlp = MLP(style_dim, self.get_num_adain_params(self.adainblock), mlp_dim, 3, norm='none', activ=activ)
+
+    def forward(self, images):
+        # reconstruct an image
+        content, style_fake = self.encode(images)
+        images_recon = self.decode(content, style_fake)
+        return images_recon
+
+    def encode(self, images):
+        # encode an image to its content and style codes
+        style_fake = self.enc_style(images)
+        content = self.enc_content(images)
+        return content, style_fake
+
+    def assign_adain(self, content, style):
+        # decode content and style codes to an image
+        adain_params = self.mlp(style)
+        self.assign_adain_params(adain_params, self.adainblock)
+        features = self.adainblock(content)
+        return features
+
+    def decode(self, features):
+        return self.dec(features)
+
+    def assign_adain_params(self, adain_params, model):
+        # assign the adain_params to the AdaIN layers in model
+        for m in model.modules():
+            if m.__class__.__name__ == "AdaptiveInstanceNorm2d":
+                mean = adain_params[:, :m.num_features]
+                std = adain_params[:, m.num_features:2*m.num_features]
+                m.bias = mean.contiguous().view(-1)
+                m.weight = std.contiguous().view(-1)
+                if adain_params.size(1) > 2*m.num_features:
+                    adain_params = adain_params[:, 2*m.num_features:]
+
+    def get_num_adain_params(self, model):
+        # return the number of AdaIN parameters needed by the model
+        num_adain_params = 0
+        for m in model.modules():
+            if m.__class__.__name__ == "AdaptiveInstanceNorm2d":
+                num_adain_params += 2*m.num_features
+        return num_adain_params
+
+# This is the FIN layer for cyclic encoding. It's our contribution and it does not exist in MUNIT.
+class FIN2dCyclic(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.instance_norm = nn.InstanceNorm2d(dim, affine=False)
+        self.a_gamma = nn.Parameter(torch.zeros(dim))
+        self.b_gamma = nn.Parameter(torch.ones(dim))
+        self.a_beta = nn.Parameter(torch.zeros(dim))
+        self.b_beta = nn.Parameter(torch.zeros(dim))
+
+    def forward(self, x, cos, sin):
+        # The only way to encode something cyclic is to map gamma and beta to an ellipse point (x,y).
+        # We are trying to learn their cyclic manner associating cos(continuity) to gamma and sin(continuity to beta)
+        # Sin and cos are randomly sampled between -1 and 1, we know that they will be associated to one point
+        gamma = self.a_gamma * cos.unsqueeze(-1) + self.b_gamma
+        beta = self.a_beta * sin.unsqueeze(-1) + self.b_beta
+
+        return self.instance_norm(x) * gamma.unsqueeze(-1).unsqueeze(-1) + beta.unsqueeze(-1).unsqueeze(-1)
+
+# This is the DRB implementation, and it does not exist in MUNIT.
+class DRB(nn.Module):
+    def __init__(self, n_resblocks, dim, norm, activation, pad_type):
+        super().__init__()
+        self.common_features = []
+        self.physical_features = []
+        self.real_features = []
+        self.continuous_features = nn.ModuleList()
+
+        for i in range(0, n_resblocks):
+            self.common_features += [ResBlock(dim, norm=norm, activation=activation, pad_type=pad_type)]
+        for i in range(0, n_resblocks):
+            self.physical_features += [ResBlock(dim, norm=norm, activation=activation, pad_type=pad_type)]
+        for i in range(0, n_resblocks):
+            self.real_features += [ResBlock(dim, norm=norm, activation=activation, pad_type=pad_type)]
+        for i in range(0, n_resblocks):
+            self.continuous_features.append(ResBlockContinuous(dim, norm='fin', activation=activation, pad_type=pad_type))
+
+        self.common_features = nn.Sequential(*self.common_features)
+        self.physical_features = nn.Sequential(*self.physical_features)
+        self.real_features = nn.Sequential(*self.real_features)
+
+    def forward(self, input_features, continuity_cos, continuity_sin):
+        common_features = self.common_features(input_features)
+        physical_features = self.physical_features(input_features)
+        real_features = self.real_features(input_features)
+        continuous_features = input_features
+        for layer in self.continuous_features:
+            continuous_features = layer(continuous_features, continuity_cos, continuity_sin)
+
+        physical_output_features = common_features + physical_features + continuous_features + input_features
+        real_output_features = common_features + real_features + continuous_features + input_features
+
+        return real_output_features, physical_output_features
+
+# Again, the default decoder is with adain, but we separated the two.
+class DecoderNoAdain(nn.Module):
+    def __init__(self, n_upsample, n_res, dim, output_dim, res_norm='adain', activ='relu', pad_type='zero'):
+        super(DecoderNoAdain, self).__init__()
+
+        self.model = []
+        # upsampling blocks
+        for i in range(n_upsample):
+            self.model += [nn.Upsample(scale_factor=2),
+                           Conv2dBlock(dim, dim // 2, 5, 1, 2, norm='layer', activation=activ, pad_type=pad_type)]
+            dim //= 2
+        # use reflection padding in the last conv layer
+        self.model += [Conv2dBlock(dim, output_dim, 7, 1, 3, norm='none', activation='tanh', pad_type=pad_type)]
+        self.model = nn.Sequential(*self.model)
+
+    def forward(self, x):
+        return self.model(x)
+
+# This is a residual block with FIN layers inserted.
+class ResBlockContinuous(nn.Module):
+    def __init__(self, dim, norm='instance', activation='relu', pad_type='zero'):
+        super(ResBlockContinuous, self).__init__()
+
+        self.model = nn.ModuleList()
+        self.model.append(Conv2dBlockContinuous(dim ,dim, 3, 1, 1, norm='fin', activation=activation, pad_type=pad_type))
+        self.model.append(Conv2dBlockContinuous(dim ,dim, 3, 1, 1, norm='fin', activation='none', pad_type=pad_type))
+
+    def forward(self, x, cos_phi, sin_phi):
+        residual = x
+        for layer in self.model:
+            x = layer(x, cos_phi, sin_phi)
+
+        x += residual
+        return x
+
+# This is a convolutional block+nonlinear+norm with support for FIN layers as normalization strategy.
+class Conv2dBlockContinuous(nn.Module):
+    def __init__(self, input_dim ,output_dim, kernel_size, stride,
+                 padding=0, norm='none', activation='relu', pad_type='zero'):
+        super(Conv2dBlockContinuous, self).__init__()
+        self.use_bias = True
+        # initialize padding
+        if pad_type == 'reflect':
+            self.pad = nn.ReflectionPad2d(padding)
+        elif pad_type == 'replicate':
+            self.pad = nn.ReplicationPad2d(padding)
+        elif pad_type == 'zero':
+            self.pad = nn.ZeroPad2d(padding)
+        else:
+            assert 0, "Unsupported padding type: {}".format(pad_type)
+
+        # initialize normalization
+        norm_dim = output_dim
+        if norm == 'batch':
+            self.norm = nn.BatchNorm2d(norm_dim)
+        elif norm == 'instance':
+            #self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=True)
+            self.norm = nn.InstanceNorm2d(norm_dim)
+        elif norm == 'layer':
+            self.norm = LayerNorm(norm_dim)
+        elif norm == 'adain':
+            self.norm = AdaptiveInstanceNorm2d(norm_dim)
+        elif norm == 'fin':
+            self.norm = FIN2dCyclic(norm_dim)
+        elif norm == 'none' or norm == 'spectral':
+            self.norm = None
+        else:
+            assert 0, "Unsupported normalization: {}".format(norm)
+
+        # initialize activation
+        if activation == 'relu':
+            self.activation = nn.ReLU(inplace=True)
+        elif activation == 'lrelu':
+            self.activation = nn.LeakyReLU(0.2, inplace=True)
+        elif activation == 'prelu':
+            self.activation = nn.PReLU()
+        elif activation == 'selu':
+            self.activation = nn.SELU(inplace=True)
+        elif activation == 'tanh':
+            self.activation = nn.Tanh()
+        elif activation == 'none':
+            self.activation = None
+        else:
+            assert 0, "Unsupported activation: {}".format(activation)
+
+        # initialize convolution
+        if norm == 'spectral':
+            self.conv = SpectralNorm(nn.Conv2d(input_dim, output_dim, kernel_size, stride, bias=self.use_bias))
+        else:
+            self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride, bias=self.use_bias)
+
+    def forward(self, x, continuity_cos, continuity_sin):
+        x = self.conv(self.pad(x))
+        if self.norm:
+            x = self.norm(x, continuity_cos, continuity_sin)
+        if self.activation:
+            x = self.activation(x)
+        return x
+
+
+
+##################################################################################
+# All below there are MUNIT default blocks.
+##################################################################################
+class ResBlocks(nn.Module):
+    def __init__(self, num_blocks, dim, norm='instance', activation='relu', pad_type='zero'):
+        super(ResBlocks, self).__init__()
+        self.model = []
+        for i in range(num_blocks):
+            self.model += [ResBlock(dim, norm=norm, activation=activation, pad_type=pad_type)]
+        self.model = nn.Sequential(*self.model)
+
+    def forward(self, x):
+        return self.model(x)
+
+class MLP(nn.Module):
+    def __init__(self, input_dim, output_dim, dim, n_blk, norm='none', activ='relu'):
+
+        super(MLP, self).__init__()
+        self.model = []
+        self.model += [LinearBlock(input_dim, dim, norm=norm, activation=activ)]
+        for i in range(n_blk - 2):
+            self.model += [LinearBlock(dim, dim, norm=norm, activation=activ)]
+        self.model += [LinearBlock(dim, output_dim, norm='none', activation='none')] # no output activations
+        self.model = nn.Sequential(*self.model)
+
+    def forward(self, x):
+        return self.model(x.view(x.size(0), -1))
+
+
+
+class ResBlock(nn.Module):
+    def __init__(self, dim, norm='instance', activation='relu', pad_type='zero'):
+        super(ResBlock, self).__init__()
+
+        model = []
+        model += [Conv2dBlock(dim ,dim, 3, 1, 1, norm=norm, activation=activation, pad_type=pad_type)]
+        model += [Conv2dBlock(dim ,dim, 3, 1, 1, norm=norm, activation='none', pad_type=pad_type)]
+        self.model = nn.Sequential(*model)
+
+    def forward(self, x):
+        residual = x
+        out = self.model(x)
+        out += residual
+        return out
+
+class Conv2dBlock(nn.Module):
+    def __init__(self, input_dim ,output_dim, kernel_size, stride,
+                 padding=0, norm='none', activation='relu', pad_type='zero'):
+        super(Conv2dBlock, self).__init__()
+        self.use_bias = True
+        # initialize padding
+        if pad_type == 'reflect':
+            self.pad = nn.ReflectionPad2d(padding)
+        elif pad_type == 'replicate':
+            self.pad = nn.ReplicationPad2d(padding)
+        elif pad_type == 'zero':
+            self.pad = nn.ZeroPad2d(padding)
+        else:
+            assert 0, "Unsupported padding type: {}".format(pad_type)
+
+        # initialize normalization
+        norm_dim = output_dim
+        if norm == 'batch':
+            self.norm = nn.BatchNorm2d(norm_dim)
+        elif norm == 'instance':
+            #self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=True)
+            self.norm = nn.InstanceNorm2d(norm_dim)
+        elif norm == 'layer':
+            self.norm = LayerNorm(norm_dim)
+        elif norm == 'adain':
+            self.norm = AdaptiveInstanceNorm2d(norm_dim)
+        elif norm == 'none' or norm == 'spectral':
+            self.norm = None
+        else:
+            assert 0, "Unsupported normalization: {}".format(norm)
+
+        # initialize activation
+        if activation == 'relu':
+            self.activation = nn.ReLU(inplace=True)
+        elif activation == 'lrelu':
+            self.activation = nn.LeakyReLU(0.2, inplace=True)
+        elif activation == 'prelu':
+            self.activation = nn.PReLU()
+        elif activation == 'selu':
+            self.activation = nn.SELU(inplace=True)
+        elif activation == 'tanh':
+            self.activation = nn.Tanh()
+        elif activation == 'none':
+            self.activation = None
+        else:
+            assert 0, "Unsupported activation: {}".format(activation)
+
+        # initialize convolution
+        if norm == 'spectral':
+            self.conv = SpectralNorm(nn.Conv2d(input_dim, output_dim, kernel_size, stride, bias=self.use_bias))
+        else:
+            self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride, bias=self.use_bias)
+
+    def forward(self, x):
+        x = self.conv(self.pad(x))
+        if self.norm:
+            x = self.norm(x)
+        if self.activation:
+            x = self.activation(x)
+        return x
+
+
+class LinearBlock(nn.Module):
+    def __init__(self, input_dim, output_dim, norm='none', activation='relu'):
+        super(LinearBlock, self).__init__()
+        use_bias = True
+        # initialize fully connected layer
+        if norm == 'spectral':
+            self.fc = SpectralNorm(nn.Linear(input_dim, output_dim, bias=use_bias))
+        else:
+            self.fc = nn.Linear(input_dim, output_dim, bias=use_bias)
+
+        # initialize normalization
+        norm_dim = output_dim
+        if norm == 'batch':
+            self.norm = nn.BatchNorm1d(norm_dim)
+        elif norm == 'instance':
+            self.norm = nn.InstanceNorm1d(norm_dim)
+        elif norm == 'layer':
+            self.norm = LayerNorm(norm_dim)
+        elif norm == 'none' or norm == 'spectral':
+            self.norm = None
+        else:
+            assert 0, "Unsupported normalization: {}".format(norm)
+
+        # initialize activation
+        if activation == 'relu':
+            self.activation = nn.ReLU(inplace=True)
+        elif activation == 'lrelu':
+            self.activation = nn.LeakyReLU(0.2, inplace=True)
+        elif activation == 'prelu':
+            self.activation = nn.PReLU()
+        elif activation == 'selu':
+            self.activation = nn.SELU(inplace=True)
+        elif activation == 'tanh':
+            self.activation = nn.Tanh()
+        elif activation == 'none':
+            self.activation = None
+        else:
+            assert 0, "Unsupported activation: {}".format(activation)
+
+    def forward(self, x):
+        out = self.fc(x)
+        if self.norm:
+            out = self.norm(out)
+        if self.activation:
+            out = self.activation(out)
+        return out
+
+
+class Vgg16(nn.Module):
+    def __init__(self):
+        super(Vgg16, self).__init__()
+        self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
+        self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
+
+        self.conv2_1 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
+        self.conv2_2 = nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)
+
+        self.conv3_1 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
+        self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
+        self.conv3_3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
+
+        self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)
+        self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
+        self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
+
+        self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
+        self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
+        self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, X):
+        h = F.relu(self.conv1_1(X), inplace=True)
+        h = F.relu(self.conv1_2(h), inplace=True)
+        # relu1_2 = h
+        h = F.max_pool2d(h, kernel_size=2, stride=2)
+
+        h = F.relu(self.conv2_1(h), inplace=True)
+        h = F.relu(self.conv2_2(h), inplace=True)
+        # relu2_2 = h
+        h = F.max_pool2d(h, kernel_size=2, stride=2)
+
+        h = F.relu(self.conv3_1(h), inplace=True)
+        h = F.relu(self.conv3_2(h), inplace=True)
+        h = F.relu(self.conv3_3(h), inplace=True)
+        # relu3_3 = h
+        h = F.max_pool2d(h, kernel_size=2, stride=2)
+
+        h = F.relu(self.conv4_1(h), inplace=True)
+        h = F.relu(self.conv4_2(h), inplace=True)
+        h = F.relu(self.conv4_3(h), inplace=True)
+        # relu4_3 = h
+
+        h = F.relu(self.conv5_1(h), inplace=True)
+        h = F.relu(self.conv5_2(h), inplace=True)
+        h = F.relu(self.conv5_3(h), inplace=True)
+        relu5_3 = h
+
+        return relu5_3
+        # return [relu1_2, relu2_2, relu3_3, relu4_3]
+
+
+class AdaptiveInstanceNorm2d(nn.Module):
+    def __init__(self, num_features, eps=1e-5, momentum=0.1):
+        super(AdaptiveInstanceNorm2d, self).__init__()
+        self.num_features = num_features
+        self.eps = eps
+        self.momentum = momentum
+        # weight and bias are dynamically assigned
+        self.weight = None
+        self.bias = None
+        # just dummy buffers, not used
+        self.register_buffer('running_mean', torch.zeros(num_features))
+        self.register_buffer('running_var', torch.ones(num_features))
+
+    def forward(self, x):
+        assert self.weight is not None and self.bias is not None, "Please assign weight and bias before calling AdaIN!"
+        b, c = x.size(0), x.size(1)
+
+        if self.weight.type() == 'torch.cuda.HalfTensor':
+            running_mean = self.running_mean.repeat(b).to(torch.float16)
+            running_var = self.running_var.repeat(b).to(torch.float16)
+        else:
+            running_mean = self.running_mean.repeat(b)
+            running_var = self.running_var.repeat(b)
+
+        # Apply instance norm
+        x_reshaped = x.contiguous().view(1, b * c, *x.size()[2:])
+
+        out = F.batch_norm(
+            x_reshaped, running_mean, running_var, self.weight, self.bias,
+            True, self.momentum, self.eps)
+
+        return out.view(b, c, *x.size()[2:])
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(' + str(self.num_features) + ')'
+
+
+class LayerNorm(nn.Module):
+    def __init__(self, num_features, eps=1e-5, affine=True):
+        super(LayerNorm, self).__init__()
+        self.num_features = num_features
+        self.affine = affine
+        self.eps = eps
+
+        if self.affine:
+            self.gamma = nn.Parameter(torch.Tensor(num_features).uniform_())
+            self.beta = nn.Parameter(torch.zeros(num_features))
+
+    def forward(self, x):
+        shape = [-1] + [1] * (x.dim() - 1)
+        # print(x.size())
+        if x.size(0) == 1:
+            # These two lines run much faster in pytorch 0.4 than the two lines listed below.
+            mean = x.view(-1).mean().view(*shape)
+            std = x.view(-1).std().view(*shape)
+        else:
+            mean = x.view(x.size(0), -1).mean(1).view(*shape)
+            std = x.view(x.size(0), -1).std(1).view(*shape)
+
+        x = (x - mean) / (std + self.eps)
+
+        if self.affine:
+            shape = [1, -1] + [1] * (x.dim() - 2)
+            x = x * self.gamma.view(*shape) + self.beta.view(*shape)
+        return x
+
+def l2normalize(v, eps=1e-12):
+    return v / (v.norm() + eps)
+
+
+class SpectralNorm(nn.Module):
+    """
+    Based on the paper "Spectral Normalization for Generative Adversarial Networks" by Takeru Miyato, Toshiki Kataoka, Masanori Koyama, Yuichi Yoshida
+    and the Pytorch implementation https://github.com/christiancosgrove/pytorch-spectral-normalization-gan
+    """
+    def __init__(self, module, name='weight', power_iterations=1):
+        super(SpectralNorm, self).__init__()
+        self.module = module
+        self.name = name
+        self.power_iterations = power_iterations
+        if not self._made_params():
+            self._make_params()
+
+    def _update_u_v(self):
+        u = getattr(self.module, self.name + "_u")
+        v = getattr(self.module, self.name + "_v")
+        w = getattr(self.module, self.name + "_bar")
+
+        height = w.data.shape[0]
+        for _ in range(self.power_iterations):
+            v.data = l2normalize(torch.mv(torch.t(w.view(height,-1).data), u.data))
+            u.data = l2normalize(torch.mv(w.view(height,-1).data, v.data))
+
+        # sigma = torch.dot(u.data, torch.mv(w.view(height,-1).data, v.data))
+        sigma = u.dot(w.view(height, -1).mv(v))
+        setattr(self.module, self.name, w / sigma.expand_as(w))
+
+    def _made_params(self):
+        try:
+            u = getattr(self.module, self.name + "_u")
+            v = getattr(self.module, self.name + "_v")
+            w = getattr(self.module, self.name + "_bar")
+            return True
+        except AttributeError:
+            return False
+
+
+    def _make_params(self):
+        w = getattr(self.module, self.name)
+
+        height = w.data.shape[0]
+        width = w.view(height, -1).data.shape[1]
+
+        u = nn.Parameter(w.data.new(height).normal_(0, 1), requires_grad=False)
+        v = nn.Parameter(w.data.new(width).normal_(0, 1), requires_grad=False)
+        u.data = l2normalize(u.data)
+        v.data = l2normalize(v.data)
+        w_bar = nn.Parameter(w.data)
+
+        del self.module._parameters[self.name]
+
+        self.module.register_parameter(self.name + "_u", u)
+        self.module.register_parameter(self.name + "_v", v)
+        self.module.register_parameter(self.name + "_bar", w_bar)
+
+
+    def forward(self, *args):
+        self._update_u_v()
+        return self.module.forward(*args)
+
+class MsImageDis(nn.Module):
+    # Multi-scale discriminator architecture
+    def __init__(self, input_dim, n_layer, gan_type, dim, norm, activ, num_scales, pad_type, output_channels = 1, final_function = None):
+        super(MsImageDis, self).__init__()
+        self.n_layer = n_layer
+        self.gan_type = gan_type
+        self.output_channels = output_channels
+        self.dim = dim
+        self.norm = norm
+        self.activ = activ
+        self.num_scales = num_scales
+        self.pad_type = pad_type
+        self.input_dim = input_dim
+        self.downsample = nn.AvgPool2d(3, stride=2, padding=[1, 1], count_include_pad=False)
+        self.cnns = nn.ModuleList()
+        self.final_function = final_function
+        for _ in range(self.num_scales):
+            self.cnns.append(self._make_net())
+
+    def _make_net(self):
+        dim = self.dim
+        cnn_x = []
+        cnn_x += [Conv2dBlock(self.input_dim, dim, 4, 2, 1, norm='none', activation=self.activ, pad_type=self.pad_type)]
+        for i in range(self.n_layer - 1):
+            cnn_x += [Conv2dBlock(dim, dim * 2, 4, 2, 1, norm=self.norm, activation=self.activ, pad_type=self.pad_type)]
+            dim *= 2
+        cnn_x += [nn.Conv2d(dim, self.output_channels, 1, 1, 0)]
+        cnn_x = nn.Sequential(*cnn_x)
+        return cnn_x
+
+    def forward(self, x):
+        outputs = []
+        for model in self.cnns:
+            output = model(x)
+            if self.final_function is not None:
+                output = self.final_function(output)
+            outputs.append(output)
+            x = self.downsample(x)
+        return outputs
+
+    def calc_dis_loss(self, input_fake, input_real):
+        # calculate the loss to train D
+        outs0 = self.forward(input_fake)
+        outs1 = self.forward(input_real)
+        loss = 0
+
+        for it, (out0, out1) in enumerate(zip(outs0, outs1)):
+            if self.gan_type == 'lsgan':
+                loss += torch.mean((out0 - 0)**2) + torch.mean((out1 - 1)**2)
+            elif self.gan_type == 'nsgan':
+                all0 = torch.zeros_like(out0)
+                all1 = torch.ones_like(out1)
+                loss += torch.mean(F.binary_cross_entropy(F.sigmoid(out0), all0) +
+                                   F.binary_cross_entropy(F.sigmoid(out1), all1))
+            else:
+                assert 0, "Unsupported GAN type: {}".format(self.gan_type)
+        return loss
+
+    def calc_gen_loss(self, input_fake):
+        # calculate the loss to train G
+        outs0 = self.forward(input_fake)
+        loss = 0
+        for it, (out0) in enumerate(outs0):
+            if self.gan_type == 'lsgan':
+                loss += torch.mean((out0 - 1)**2) # LSGAN
+            elif self.gan_type == 'nsgan':
+                all1 = torch.ones_like(out0.data)
+                loss += torch.mean(F.binary_cross_entropy(F.sigmoid(out0), all1))
+            else:
+                assert 0, "Unsupported GAN type: {}".format(self.gan_type)
+        return loss
+
+class StyleEncoder(nn.Module):
+    def __init__(self, n_downsample, input_dim, dim, style_dim, norm, activ, pad_type):
+        super(StyleEncoder, self).__init__()
+        self.model = []
+        self.model += [Conv2dBlock(input_dim, dim, 7, 1, 3, norm=norm, activation=activ, pad_type=pad_type)]
+        for i in range(2):
+            self.model += [Conv2dBlock(dim, 2 * dim, 4, 2, 1, norm=norm, activation=activ, pad_type=pad_type)]
+            dim *= 2
+        for i in range(n_downsample - 2):
+            self.model += [Conv2dBlock(dim, dim, 4, 2, 1, norm=norm, activation=activ, pad_type=pad_type)]
+        self.model += [nn.AdaptiveAvgPool2d(1)] # global average pooling
+        self.model += [nn.Conv2d(dim, style_dim, 1, 1, 0)]
+        self.model = nn.Sequential(*self.model)
+        self.output_dim = dim
+
+    def forward(self, x):
+        return self.model(x)
+
+class ContentEncoder(nn.Module):
+    def __init__(self, n_downsample, n_res, input_dim, dim, norm, activ, pad_type):
+        super(ContentEncoder, self).__init__()
+        self.model = []
+        self.model += [Conv2dBlock(input_dim, dim, 7, 1, 3, norm=norm, activation=activ, pad_type=pad_type)]
+        # downsampling blocks
+        for i in range(n_downsample):
+            self.model += [Conv2dBlock(dim, 2 * dim, 4, 2, 1, norm=norm, activation=activ, pad_type=pad_type)]
+            dim *= 2
+        # residual blocks
+        self.model += [ResBlocks(n_res, dim, norm=norm, activation=activ, pad_type=pad_type)]
+        self.model = nn.Sequential(*self.model)
+        self.output_dim = dim
+
+    def forward(self, x):
+        return self.model(x)
+
+class AdaINBlock(nn.Module):
+    def __init__(self, n_upsample, n_res, dim, output_dim, res_norm='adain', activ='relu', pad_type='zero'):
+        super(AdaINBlock, self).__init__()
+
+        self.model = []
+        # AdaIN residual blocks
+        self.model += [ResBlocks(n_res, dim, res_norm, activ, pad_type=pad_type)]
+        self.model = nn.Sequential(*self.model)
+
+    def forward(self, x):
+        return self.model(x)
+

networks/backbones/functions.py

@@ -0,0 +1,87 @@
+"""
+functions.py
+Here we get helper functions to 1) get schedulers given an option 2) initialize the network weights.
+"""
+
+import torch
+from torch.nn import init
+from torch.optim import lr_scheduler
+
+###############################################################################
+# Helper Functions
+###############################################################################
+
+def get_scheduler(optimizer, opt):
+    """Return a learning rate scheduler
+
+    Parameters:
+        optimizer          -- the optimizer of the network
+        opt (option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions．　
+                              opt.lr_policy is the name of learning rate policy: linear | step | plateau | cosine
+
+    For 'linear', we keep the same learning rate for the first <opt.n_epochs> epochs
+    and linearly decay the rate to zero over the next <opt.n_epochs_decay> epochs.
+    For other schedulers (step, plateau, and cosine), we use the default PyTorch schedulers.
+    See https://pytorch.org/docs/stable/optim.html for more details.
+    """
+    if opt.lr_policy == 'linear':
+        def lambda_rule(iteration):
+            lr_l = 1.0 - max(0, logger.get_global_step() - opt.static_iters) / float(opt.decay_iters + 1)
+            return lr_l
+        scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)
+    elif opt.lr_policy == 'step':
+        scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.decay_iters_step, gamma=0.1)
+    elif opt.lr_policy == 'plateau':
+        scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5)
+    elif opt.lr_policy == 'cosine':
+        scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.n_epochs, eta_min=0)
+    else:
+        return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy)
+    return scheduler
+
+
+def init_weights(net, init_type='normal', init_gain=0.02):
+    """Initialize network weights.
+
+    Parameters:
+        net (network)   -- network to be initialized
+        init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
+        init_gain (float)    -- scaling factor for normal, xavier and orthogonal.
+
+    We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might
+    work better for some applications. Feel free to try yourself.
+    """
+    def init_func(m):  # define the initialization function
+        classname = m.__class__.__name__
+        if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):
+            if init_type == 'normal':
+                init.normal_(m.weight.data, 0.0, init_gain)
+            elif init_type == 'xavier':
+                init.xavier_normal_(m.weight.data, gain=init_gain)
+            elif init_type == 'kaiming':
+                init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
+            elif init_type == 'orthogonal':
+                init.orthogonal_(m.weight.data, gain=init_gain)
+            else:
+                raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
+            if hasattr(m, 'bias') and m.bias is not None:
+                init.constant_(m.bias.data, 0.0)
+        elif classname.find('BatchNorm2d') != -1:  # BatchNorm Layer's weight is not a matrix; only normal distribution applies.
+            init.normal_(m.weight.data, 1.0, init_gain)
+            init.constant_(m.bias.data, 0.0)
+
+    net.apply(init_func)  # apply the initialization function <init_func>
+
+
+def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[]):
+    """Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights
+    Parameters:
+        net (network)      -- the network to be initialized
+        init_type (str)    -- the name of an initialization method: normal | xavier | kaiming | orthogonal
+        gain (float)       -- scaling factor for normal, xavier and orthogonal.
+        gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
+
+    Return an initialized network.
+    """
+    init_weights(net, init_type, init_gain=init_gain)
+    return net

networks/base_model.py

@@ -0,0 +1,113 @@
+"""
+base_model.py
+Abstract definition of a model, where helper functions as image extraction and gradient propagation are defined.
+"""
+
+from collections import OrderedDict
+from abc import abstractmethod
+
+import pytorch_lightning as pl
+from torch.optim import lr_scheduler
+
+from torchvision.transforms import ToPILImage
+
+class BaseModel(pl.LightningModule):
+
+    def __init__(self, opt):
+        super().__init__()
+        self.opt = opt
+        self.gpu_ids = opt.gpu_ids
+        self.loss_names = []
+        self.model_names = []
+        self.visual_names = []
+        self.image_paths = []
+        self.save_hyperparameters()
+        self.schedulers = []
+        self.metric = 0  # used for learning rate policy 'plateau'
+
+    @abstractmethod
+    def set_input(self, input):
+        pass
+
+    def eval(self):
+        for name in self.model_names:
+            if isinstance(name, str):
+                net = getattr(self, 'net' + name)
+                net.eval()
+
+    def compute_visuals(self):
+        pass
+
+    def get_image_paths(self):
+        return self.image_paths
+
+    def update_learning_rate(self):
+        for scheduler in self.schedulers:
+            if self.opt.lr_policy == 'plateau':
+                scheduler.step(self.metric)
+            else:
+                scheduler.step()
+
+        lr = self.optimizers[0].param_groups[0]['lr']
+        return lr
+
+    def get_current_visuals(self):
+        visual_ret = OrderedDict()
+        for name in self.visual_names:
+            if isinstance(name, str):
+                visual_ret[name] = (getattr(self, name).detach() + 1) / 2
+        return visual_ret
+
+    def log_current_losses(self):
+        losses = '\n'
+        for name in self.loss_names:
+            if isinstance(name, str):
+                loss_value = float(getattr(self, 'loss_' + name))
+                self.logger.log_metrics({'loss_{}'.format(name): loss_value}, self.trainer.global_step)
+                losses += 'loss_{}={:.4f}\t'.format(name, loss_value)
+        print(losses)
+
+    def log_current_visuals(self):
+        visuals = self.get_current_visuals()
+        for key, viz in visuals.items():
+            self.logger.experiment.add_image('img_{}'.format(key), viz[0].cpu(), self.trainer.global_step)
+
+    def get_scheduler(self, opt, optimizer):
+        if opt.lr_policy == 'linear':
+            def lambda_rule(iter):
+                lr_l = 1.0 - max(0, self.trainer.global_step - opt.static_iters) / float(opt.decay_iters + 1)
+                return lr_l
+
+            scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)
+        elif opt.lr_policy == 'step':
+            scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.decay_iters_step, gamma=0.5)
+        elif opt.lr_policy == 'plateau':
+            scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5)
+        elif opt.lr_policy == 'cosine':
+            scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.n_epochs, eta_min=0)
+        else:
+            return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy)
+        return scheduler
+
+    def print_networks(self):
+        for name in self.model_names:
+            if isinstance(name, str):
+                net = getattr(self, 'net' + name)
+                num_params = 0
+                for param in net.parameters():
+                    num_params += param.numel()
+                print('[Network %s] Total number of parameters : %.3f M' % (name, num_params / 1e6))
+
+    def get_optimizer_dict(self):
+        return_dict = {}
+        for index, opt in enumerate(self.optimizers):
+            return_dict['Optimizer_{}'.format(index)] = opt
+        return return_dict
+
+    def set_requires_grad(self, nets, requires_grad=False):
+        if not isinstance(nets, list):
+            nets = [nets]
+        for net in nets:
+            if net is not None:
+                for param in net.parameters():
+                    param.requires_grad = requires_grad

networks/comomunit_model.py

@@ -0,0 +1,396 @@
+"""
+continuous_munit_cyclepoint_residual.py
+This is CoMo-MUNIT *logic*, so how the network is trained.
+"""
+
+import math
+import torch
+import itertools
+from .base_model import BaseModel
+from .backbones import comomunit as networks
+import random
+import munch
+
+
+def ModelOptions():
+    mo = munch.Munch()
+    # Generator
+    mo.gen_dim = 64
+    mo.style_dim = 8
+    mo.gen_activ = 'relu'
+    mo.n_downsample = 2
+    mo.n_res = 4
+    mo.gen_pad_type = 'reflect'
+    mo.mlp_dim = 256
+
+    # Discriminiator
+    mo.disc_dim = 64
+    mo.disc_norm = 'none'
+    mo.disc_activ = 'lrelu'
+    mo.disc_n_layer = 4
+    mo.num_scales = 3 # TODO change for other experiments!
+    mo.disc_pad_type = 'reflect'
+
+    # Initialization
+    mo.init_type_gen = 'kaiming'
+    mo.init_type_disc = 'normal'
+    mo.init_gain = 0.02
+
+    # Weights
+    mo.lambda_gan = 1
+    mo.lambda_rec_image = 10
+    mo.lambda_rec_style = 1
+    mo.lambda_rec_content = 1
+    mo.lambda_rec_cycle = 10
+    mo.lambda_vgg = 0.1
+    mo.lambda_idt = 1
+    mo.lambda_Phinet_A = 1
+    # Continuous settings
+    mo.resblocks_cont = 1
+    mo.lambda_physics = 10
+    mo.lambda_compare = 10
+    mo.lambda_physics_compare = 1
+
+    return mo
+
+
+class CoMoMUNITModel(BaseModel):
+
+    def __init__(self, opt):
+        BaseModel.__init__(self, opt)
+        # specify the training losses you want to print out. The training/test scripts will call <BaseModel.get_current_losses>
+        self.loss_names = ['D_A', 'G_A', 'cycle_A', 'rec_A', 'rec_style_B', 'rec_content_A', 'vgg_A', 'phi_net_A',
+                           'D_B', 'G_B', 'cycle_B', 'rec_B', 'rec_style_A', 'rec_content_B', 'vgg_B', 'idt_B',
+                           'recon_physics', 'phi_net']
+        # specify the images you want to save/display. The training/test scripts will call <BaseModel.get_current_visuals>
+        visual_names_A = ['x', 'y', 'rec_A_img', 'rec_A_cycle', 'y_M_tilde', 'y_M']
+        visual_names_B = ['y_tilde', 'fake_A', 'rec_B_img', 'rec_B_cycle', 'idt_B_img']
+
+        self.visual_names = visual_names_A + visual_names_B  # combine visualizations for A and B
+        # specify the models you want to save to the disk. The training/test scripts will call <BaseModel.save_networks> and <BaseModel.load_networks>.
+        self.model_names = ['G_A', 'D_A', 'G_B', 'D_B', 'DRB', 'Phi_net', 'Phi_net_A']
+
+        self.netG_A = networks.define_G_munit(opt.input_nc, opt.output_nc, opt.gen_dim, opt.style_dim, opt.n_downsample,
+                                              opt.n_res, opt.gen_pad_type, opt.mlp_dim, opt.gen_activ, opt.init_type_gen,
+                                              opt.init_gain, self.gpu_ids)
+        self.netG_B = networks.define_G_munit(opt.output_nc, opt.input_nc, opt.gen_dim, opt.style_dim, opt.n_downsample,
+                                              opt.n_res, opt.gen_pad_type, opt.mlp_dim, opt.gen_activ, opt.init_type_gen,
+                                              opt.init_gain, self.gpu_ids)
+
+        self.netDRB = networks.define_DRB_munit(opt.resblocks_cont, opt.gen_dim * (2 ** opt.n_downsample), 'instance', opt.gen_activ,
+                                                opt.gen_pad_type, opt.init_type_gen, opt.init_gain, self.gpu_ids)
+        # define discriminators
+        self.netD_A = networks.define_D_munit(opt.output_nc, opt.disc_dim, opt.disc_norm, opt.disc_activ, opt.disc_n_layer,
+                                              opt.gan_mode, opt.num_scales, opt.disc_pad_type, opt.init_type_disc,
+                                              opt.init_gain, self.gpu_ids)
+
+        self.netD_B = networks.define_D_munit(opt.input_nc, opt.disc_dim, opt.disc_norm, opt.disc_activ, opt.disc_n_layer,
+                                              opt.gan_mode, opt.num_scales, opt.disc_pad_type, opt.init_type_disc,
+                                              opt.init_gain, self.gpu_ids)
+
+        # We use munit style encoder as phinet/phinet_A
+        self.netPhi_net = networks.init_net(networks.StyleEncoder(4, opt.input_nc * 2, opt.gen_dim, 2, norm='instance',
+                                                                  activ='lrelu', pad_type=opt.gen_pad_type), init_type=opt.init_type_gen,
+                                            init_gain = opt.init_gain, gpu_ids = opt.gpu_ids)
+
+        self.netPhi_net_A = networks.init_net(networks.StyleEncoder(4, opt.input_nc, opt.gen_dim, 1, norm='instance',
+                                                                    activ='lrelu', pad_type=opt.gen_pad_type), init_type=opt.init_type_gen,
+                                              init_gain = opt.init_gain, gpu_ids = opt.gpu_ids)
+
+        # define loss functions
+        self.reconCriterion = torch.nn.L1Loss()
+        self.criterionPhysics = torch.nn.L1Loss()
+        self.criterionIdt = torch.nn.L1Loss()
+
+        # initialize optimizers; schedulers will be automatically created by function <BaseModel.setup>.
+
+        if opt.lambda_vgg > 0:
+            self.instance_norm = torch.nn.InstanceNorm2d(512)
+            self.vgg = networks.Vgg16()
+            self.vgg.load_state_dict(torch.load('res/vgg_imagenet.pth'))
+            self.vgg.eval()
+            for param in self.vgg.parameters():
+                param.requires_grad = False
+
+    def configure_optimizers(self):
+        opt_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters(),
+                                                 self.netDRB.parameters(), self.netPhi_net.parameters(),
+                                                 self.netPhi_net_A.parameters()),
+                                 weight_decay=0.0001, lr=self.opt.lr, betas=(self.opt.beta1, 0.999))
+        opt_D = torch.optim.Adam(itertools.chain(self.netD_A.parameters(), self.netD_B.parameters()),
+                                            weight_decay=0.0001, lr=self.opt.lr, betas=(self.opt.beta1, 0.999))
+
+        scheduler_G = self.get_scheduler(self.opt, opt_G)
+        scheduler_D = self.get_scheduler(self.opt, opt_D)
+        return [opt_D, opt_G], [scheduler_D, scheduler_G]
+
+    def set_input(self, input):
+        # Input image. everything is mixed so we only have one style
+        self.x = input['A']
+        # Paths just because maybe they are needed
+        self.image_paths = input['A_paths']
+        # Desired continuity value which is used to render self.y_M_tilde
+        # Desired continuity value which is used to render self.y_M_tilde
+        self.phi = input['phi'].float()
+        self.cos_phi = input['cos_phi'].float()
+        self.sin_phi = input['sin_phi'].float()
+        # Term used to train SSN
+        self.phi_prime = input['phi_prime'].float()
+        self.cos_phi_prime = input['cos_phi_prime'].float()
+        self.sin_phi_prime = input['sin_phi_prime'].float()
+        # physical model applied to self.x with continuity self.continuity
+        self.y_M_tilde = input['A_cont']
+        # physical model applied to self.x with continuity self.continuity_compare
+        self.y_M_tilde_prime = input['A_cont_compare']
+        # Other image, in reality the two will belong to the same domain
+        self.y_tilde = input['B']
+
+    def __vgg_preprocess(self, batch):
+        tensortype = type(batch)
+        (r, g, b) = torch.chunk(batch, 3, dim=1)
+        batch = torch.cat((b, g, r), dim=1)  # convert RGB to BGR
+        batch = (batch + 1) * 255 * 0.5  # [-1, 1] -> [0, 255]
+        mean = tensortype(batch.data.size()).to(self.device)
+
+        mean[:, 0, :, :] = 103.939
+        mean[:, 1, :, :] = 116.779
+        mean[:, 2, :, :] = 123.680
+        batch = batch.sub(mean)  # subtract mean
+        return batch
+
+    def __compute_vgg_loss(self, img, target):
+        img_vgg = self.__vgg_preprocess(img)
+        target_vgg = self.__vgg_preprocess(target)
+        img_fea = self.vgg(img_vgg)
+        target_fea = self.vgg(target_vgg)
+        return torch.mean((self.instance_norm(img_fea) - self.instance_norm(target_fea)) ** 2)
+
+
+    def forward(self, img, phi = None, style_B_fake = None):
+        """Run forward pass; called by both functions <optimize_parameters> and <test>."""
+        # Random style sampling
+        if style_B_fake is None:
+            style_B_fake = torch.randn(img.size(0), self.opt.style_dim, 1, 1).to(self.device)
+        if phi is None:
+            phi = torch.zeros(1).fill_(random.random()).to(self.device) * math.pi * 2
+
+        self.cos_phi = torch.cos(phi)
+        self.sin_phi = torch.sin(phi)
+
+        # Encoding
+        self.content_A, self.style_A_real = self.netG_A.encode(img)
+
+        features_A = self.netG_B.assign_adain(self.content_A, style_B_fake)
+        features_A_real, features_A_physics = self.netDRB(features_A, self.cos_phi, self.sin_phi)
+        fake_B = self.netG_B.decode(features_A_real)
+        return fake_B
+
+    def training_step_D(self):
+        with torch.no_grad():
+            # Random style sampling
+            self.style_A_fake = torch.randn(self.x.size(0), self.opt.style_dim, 1, 1).to(self.device)
+            self.style_B_fake = torch.randn(self.y_tilde.size(0), self.opt.style_dim, 1, 1).to(self.device)
+
+            self.content_A, self.style_A_real = self.netG_A.encode(self.x)
+            features_A = self.netG_B.assign_adain(self.content_A, self.style_B_fake)
+            features_A_real, features_A_physics = self.netDRB(features_A, self.cos_phi, self.sin_phi)
+            self.y = self.netG_B.decode(features_A_real)
+
+            # Encoding
+            self.content_B, self.style_B_real = self.netG_B.encode(self.y_tilde)
+            features_B = self.netG_A.assign_adain(self.content_B, self.style_A_fake)
+            features_B_real, _ = self.netDRB(features_B,
+                                             torch.ones(self.cos_phi.size()).to(self.device),
+                                             torch.zeros(self.sin_phi.size()).to(self.device)
+                                             )
+            self.fake_A = self.netG_A.decode(features_B_real)
+
+        self.loss_D_A = self.netD_A.calc_dis_loss(self.y, self.y_tilde) * self.opt.lambda_gan
+        self.loss_D_B = self.netD_B.calc_dis_loss(self.fake_A, self.x) * self.opt.lambda_gan
+
+        loss_D = self.loss_D_A + self.loss_D_B
+        return loss_D
+
+
+    def phi_loss_fn(self):
+        # the distance between the generated image and the image at the output of the
+        # physical model should be zero
+
+        input_zerodistance = torch.cat((self.y, self.y_M_tilde), dim = 1)
+
+        # Distance between generated image and other image of the physical model should be
+        # taken from the ground truth value
+        input_normaldistance = torch.cat((self.y, self.y_M_tilde_prime), dim = 1)
+
+        # same for this, but this does not depend on a GAN generation so it's used as a regularization term
+        input_regolarize = torch.cat((self.y_M_tilde, self.y_M_tilde_prime), dim = 1)
+        # essentailly, ground truth distance given by the physical model renderings
+        # Cosine distance, we are trying to encode cyclic stuff
+
+        distance_cos = (torch.cos(self.phi) - torch.cos(self.phi_prime)) / 2
+        distance_sin = (torch.sin(self.phi) - torch.sin(self.phi_prime)) / 2
+
+        # We evaluate the angle distance and we normalize it in -1/1
+        output_zerodistance = torch.tanh(self.netPhi_net(input_zerodistance))#[0])
+        output_normaldistance = torch.tanh(self.netPhi_net(input_normaldistance))#[0])
+        output_regolarize = torch.tanh(self.netPhi_net(input_regolarize))#[0])
+
+        loss_cos = torch.pow(output_zerodistance[:, 0] - 0, 2).mean()
+        loss_cos += torch.pow(output_normaldistance[:, 0] - distance_cos, 2).mean()
+        loss_cos += torch.pow(output_regolarize[:, 0] - distance_cos, 2).mean()
+
+        loss_sin = torch.pow(output_zerodistance[:, 1] - 0, 2).mean()
+        loss_sin += torch.pow(output_normaldistance[:, 1] - distance_sin, 2).mean()
+        loss_sin += torch.pow(output_regolarize[:, 1] - distance_sin, 2).mean()
+
+
+        # additional terms on the other image generated by the GAN, i.e. something that should resemble exactly
+        # the image generated by the physical model
+        # This terms follow the same reasoning as before and weighted differently
+        input_physics_zerodistance = torch.cat((self.y_M, self.y_M_tilde), dim = 1)
+        input_physics_regolarize = torch.cat((self.y_M, self.y_M_tilde_prime), dim = 1)
+        output_physics_zerodistance = torch.tanh(self.netPhi_net(input_physics_zerodistance))#[0])
+        output_physics_regolarize = torch.tanh(self.netPhi_net(input_physics_regolarize))#[0])
+
+        loss_cos += torch.pow(output_physics_zerodistance[:, 0] - 0, 2).mean() * self.opt.lambda_physics_compare
+        loss_cos += torch.pow(output_physics_regolarize[:, 0] - distance_cos,
+                          2).mean() * self.opt.lambda_physics_compare
+        loss_sin += torch.pow(output_physics_zerodistance[:, 1] - 0, 2).mean() * self.opt.lambda_physics_compare
+        loss_sin += torch.pow(output_physics_regolarize[:, 1] - distance_sin,
+                          2).mean() * self.opt.lambda_physics_compare
+
+        # Also distance between the two outputs of the gan should be 0
+        input_twoheads = torch.cat((self.y_M, self.y), dim = 1)
+        output_twoheads = torch.tanh(self.netPhi_net(input_twoheads))#[0])
+
+        loss_cos += torch.pow(output_twoheads[:, 0] - 0, 2).mean()
+        loss_sin += torch.pow(output_twoheads[:, 1] - 0, 2).mean()
+
+        loss = loss_cos + loss_sin * 0.5
+
+        return loss
+
+    def training_step_G(self):
+        self.style_B_fake = torch.randn(self.y_tilde.size(0), self.opt.style_dim, 1, 1).to(self.device)
+        self.style_A_fake = torch.randn(self.x.size(0), self.opt.style_dim, 1, 1).to(self.device)
+
+        self.content_A, self.style_A_real = self.netG_A.encode(self.x)
+        self.content_B, self.style_B_real = self.netG_B.encode(self.y_tilde)
+        self.phi_est = torch.sigmoid(self.netPhi_net_A.forward(self.y_tilde).view(self.y_tilde.size(0), -1)).view(self.y_tilde.size(0)) * 2 * math.pi
+        self.estimated_cos_B = torch.cos(self.phi_est)
+        self.estimated_sin_B = torch.sin(self.phi_est)
+
+        # Reconstruction
+        features_A_reconstruction = self.netG_A.assign_adain(self.content_A, self.style_A_real)
+        features_A_reconstruction, _ = self.netDRB(features_A_reconstruction,
+                                                   torch.ones(self.estimated_cos_B.size()).to(self.device),
+                                                   torch.zeros(self.estimated_sin_B.size()).to(self.device))
+
+        self.rec_A_img = self.netG_A.decode(features_A_reconstruction)
+
+        features_B_reconstruction = self.netG_B.assign_adain(self.content_B, self.style_B_real)
+        features_B_reconstruction, _ = self.netDRB(features_B_reconstruction, self.estimated_cos_B, self.estimated_sin_B)
+
+        self.rec_B_img = self.netG_B.decode(features_B_reconstruction)
+
+        # Cross domain
+        features_A = self.netG_B.assign_adain(self.content_A, self.style_B_fake)
+        features_A_real, features_A_physics = self.netDRB(features_A, self.cos_phi, self.sin_phi)
+        self.y_M = self.netG_B.decode(features_A_physics)
+        self.y = self.netG_B.decode(features_A_real)
+
+        features_B = self.netG_A.assign_adain(self.content_B, self.style_A_fake)
+        features_B_real, _ = self.netDRB(features_B,
+                                         torch.ones(self.cos_phi.size()).to(self.device),
+                                         torch.zeros(self.sin_phi.size()).to(self.device))
+        self.fake_A = self.netG_A.decode(features_B_real)
+
+        self.rec_content_B, self.rec_style_A = self.netG_A.encode(self.fake_A)
+        self.rec_content_A, self.rec_style_B = self.netG_B.encode(self.y)
+
+        if self.opt.lambda_rec_cycle > 0:
+            features_A_reconstruction_cycle = self.netG_A.assign_adain(self.rec_content_A, self.style_A_real)
+            features_A_reconstruction_cycle, _ = self.netDRB(features_A_reconstruction_cycle,
+                                                             torch.ones(self.cos_phi.size()).to(self.device),
+                                                             torch.zeros(self.sin_phi.size()).to(self.device))
+            self.rec_A_cycle = self.netG_A.decode(features_A_reconstruction_cycle)
+
+            features_B_reconstruction_cycle = self.netG_B.assign_adain(self.rec_content_B, self.style_B_real)
+            features_B_reconstruction_cycle, _ = self.netDRB(features_B_reconstruction_cycle, self.estimated_cos_B, self.estimated_sin_B)
+            self.rec_B_cycle = self.netG_B.decode(features_B_reconstruction_cycle)
+        if self.opt.lambda_idt > 0:
+            features_B_identity = self.netG_B.assign_adain(self.content_A, torch.randn(self.style_B_fake.size()).to(self.device))
+            features_B_identity, _ = self.netDRB(features_B_identity,
+                                                 torch.ones(self.estimated_cos_B.size()).to(self.device),
+                                                 torch.zeros(self.estimated_sin_B.size()).to(self.device))
+            self.idt_B_img = self.netG_B.decode(features_B_identity)
+
+
+        if self.opt.lambda_idt > 0:
+            self.loss_idt_A = 0
+            self.loss_idt_B = self.criterionIdt(self.idt_B_img, self.x) * self.opt.lambda_gan * self.opt.lambda_idt
+        else:
+            self.loss_idt_A = 0
+            self.loss_idt_B = 0
+
+        continuity_angle_fake = torch.sigmoid(self.netPhi_net_A.forward(self.y).view(self.y_tilde.size(0), -1)).view(self.y_tilde.size(0)) * 2 * math.pi
+
+        continuity_cos_fake = 1 - ((torch.cos(continuity_angle_fake) + 1) / 2)
+        continuity_cos_gt = 1 - ((torch.cos(self.phi) + 1) / 2)
+        continuity_sin_fake = 1 - ((torch.sin(continuity_angle_fake) + 1) / 2)
+        continuity_sin_gt = 1 - ((torch.sin(self.phi) + 1) / 2)
+        distance_cos_fake = (continuity_cos_fake - continuity_cos_gt)
+        distance_sin_fake = (continuity_sin_fake - continuity_sin_gt)
+
+        self.loss_phi_net_A = (distance_cos_fake ** 2) * self.opt.lambda_Phinet_A
+        self.loss_phi_net_A += (distance_sin_fake ** 2) * self.opt.lambda_Phinet_A
+
+        self.loss_rec_A = self.reconCriterion(self.rec_A_img, self.x) * self.opt.lambda_rec_image
+        self.loss_rec_B = self.reconCriterion(self.rec_B_img, self.y_tilde) * self.opt.lambda_rec_image
+
+        self.loss_rec_style_B = self.reconCriterion(self.rec_style_B, self.style_B_fake) * self.opt.lambda_rec_style
+        self.loss_rec_style_A = self.reconCriterion(self.rec_style_A, self.style_A_fake) * self.opt.lambda_rec_style
+
+        self.loss_rec_content_A = self.reconCriterion(self.rec_content_A, self.content_A) * self.opt.lambda_rec_content
+        self.loss_rec_content_B = self.reconCriterion(self.rec_content_B, self.content_B) * self.opt.lambda_rec_content
+
+        if self.opt.lambda_rec_cycle > 0:
+            self.loss_cycle_A = self.reconCriterion(self.rec_A_cycle, self.x) * self.opt.lambda_rec_cycle
+            self.loss_cycle_B = self.reconCriterion(self.rec_B_cycle, self.y_tilde) * self.opt.lambda_rec_cycle
+        else:
+            self.loss_cycle_A = 0
+
+        self.loss_G_A = self.netD_A.calc_gen_loss(self.y) * self.opt.lambda_gan
+        self.loss_G_B = self.netD_B.calc_gen_loss(self.fake_A) * self.opt.lambda_gan
+
+        self.loss_recon_physics = self.opt.lambda_physics * self.criterionPhysics(self.y_M, self.y_M_tilde)
+        self.loss_phi_net = self.phi_loss_fn() * self.opt.lambda_compare
+
+        if self.opt.lambda_vgg > 0:
+            self.loss_vgg_A = self.__compute_vgg_loss(self.fake_A, self.y_tilde) * self.opt.lambda_vgg
+            self.loss_vgg_B = self.__compute_vgg_loss(self.y, self.x) * self.opt.lambda_vgg
+        else:
+            self.loss_vgg_A = 0
+            self.loss_vgg_B = 0
+
+        self.loss_G = self.loss_rec_A + self.loss_rec_style_B + self.loss_rec_content_A + \
+                      self.loss_cycle_A + self.loss_G_B + self.loss_vgg_A + \
+                      self.loss_rec_B + self.loss_rec_style_A + self.loss_rec_content_B + \
+                      self.loss_cycle_B + self.loss_G_A + self.loss_vgg_B + \
+                      self.loss_recon_physics + self.loss_phi_net + self.loss_idt_B + self.loss_phi_net_A
+
+        return self.loss_G
+
+    def training_step(self, batch, batch_idx, optimizer_idx):
+
+        self.set_input(batch)
+        if optimizer_idx == 0:
+            self.set_requires_grad([self.netD_A, self.netD_B], True)
+            self.set_requires_grad([self.netG_A, self.netG_B], False)
+
+            return self.training_step_D()
+        elif optimizer_idx == 1:
+            self.set_requires_grad([self.netD_A, self.netD_B], False)  # Ds require no gradients when optimizing Gs
+            self.set_requires_grad([self.netG_A, self.netG_B], True)
+
+            return self.training_step_G()

options/__init__.py

@@ -0,0 +1,39 @@
+"""This package options includes option modules: training options, test options, and basic options (used in both training and test)."""
+
+from argparse import ArgumentParser as AP
+from .train_options import TrainOptions
+from .log_options import LogOptions
+from networks import get_model_options
+from data import get_dataset_options
+import munch
+
+
+def get_options(cmdline_opt):
+
+    bo = munch.Munch()
+    # Set the number of channels of input image
+    # Set the number of channels of output image
+    bo.input_nc = 3
+    bo.output_nc = 3
+    bo.gpu_ids = cmdline_opt.gpus
+    # Dataset options
+    bo.dataroot = cmdline_opt.path_data
+    bo.dataset_mode = cmdline_opt.data_importer
+    bo.model = cmdline_opt.model
+    # Scheduling policies
+    bo.lr = cmdline_opt.learning_rate
+    bo.lr_policy = cmdline_opt.scheduler_policy
+    bo.decay_iters_step = cmdline_opt.decay_iters_step
+    bo.decay_step_gamma = cmdline_opt.decay_step_gamma
+
+    opts = []
+    opts.append(get_model_options(bo.model)())
+    opts.append(get_dataset_options(bo.dataset_mode)())
+    opts.append(LogOptions())
+    opts.append(TrainOptions())
+
+    # Checks for Nones
+    opts = [x for x in opts if x]
+    for x in opts:
+        bo.update(x)
+    return bo

options/log_options.py

@@ -0,0 +1,10 @@
+import munch
+
+def LogOptions():
+    lo = munch.Munch()
+    # Save images each x iters
+    lo.display_freq = 10000
+
+    # Print info each x iters
+    lo.print_freq = 10
+    return lo

options/train_options.py

@@ -0,0 +1,21 @@
+import munch
+
+
+def TrainOptions():
+    to = munch.Munch()
+    # Iterations
+    to.total_iterations = 30000000
+
+    # Save checkpoint every x iters
+    to.save_latest_freq = 35000
+
+    # Save checkpoint every x epochs
+    to.save_epoch_freq = 5
+
+    # Adam settings
+    to.beta1 = 0.5
+
+    # gan type
+    to.gan_mode = 'lsgan'
+
+    return to

res/vgg_imagenet.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:364cfae76a51a908502d7b285bf047ce54da423e75fcdc8505312b00c5105c9e
+size 58862394

scripts/dump_waymo.py

@@ -0,0 +1,63 @@
+import os
+import sys
+import math
+import itertools
+import numpy as np
+import tensorflow as tf
+
+from PIL import Image
+from argparse import ArgumentParser as AP
+from waymo_open_dataset.utils import range_image_utils
+from waymo_open_dataset.utils import transform_utils
+from waymo_open_dataset.utils import  frame_utils
+from waymo_open_dataset import dataset_pb2 as open_dataset
+
+def printProgressBar(i, max, postText):
+    n_bar = 20 #size of progress bar
+    j= i/max
+    sys.stdout.write('\r')
+    sys.stdout.write(f"[{'=' * int(n_bar * j):{n_bar}s}] {int(100 * j)}%  {postText}")
+    sys.stdout.flush()
+
+
+def main(cmdline_opt):
+    DS_PATH = cmdline_opt.load_path
+    files = os.listdir(DS_PATH)
+    files = [os.path.join(DS_PATH,x) for x in files]
+    
+    with open('sunny_sequences.txt') as file:
+        sunny_sequences = file.read().splitlines()
+
+    for index_file, file in enumerate(files):
+        if not os.path.basename(file).split('_with_camera_labels.tfrecord')[0] in sunny_sequences: # Some sequences are wrongly annotated as sunny. We annotated a subset of really sunny images.
+            continue
+        dataset = tf.data.TFRecordDataset(file, compression_type='')
+        printProgressBar(index_file, len(files), "Files done")
+
+        for index_data, data in enumerate(dataset):
+            frame = open_dataset.Frame()
+            frame.ParseFromString(bytearray(data.numpy()))
+
+            if frame.context.stats.weather == 'sunny':
+                (range_images, camera_projections, range_image_top_pose) = frame_utils.parse_range_image_and_camera_projection(frame)
+
+                for label in frame.camera_labels:
+                    if label.name == open_dataset.CameraName.FRONT:
+                        path = os.path.join(cmdline_opt.save_path,
+                                            frame.context.stats.weather,
+                                            frame.context.stats.time_of_day,
+                                            '{}-{:06}.png'.format(os.path.basename(file), index_data))
+
+                        im = tf.image.decode_png(frame.images[0].image)
+                        pil_im = Image.fromarray(im.numpy())
+                        res_img = pil_im.resize((480, 320), Image.BILINEAR)
+                        os.makedirs(os.path.dirname(path), exist_ok=True)
+                        res_img.save(path)
+            else:
+                break
+
+if __name__ == '__main__':
+    ap = AP()
+    ap.add_argument('--load_path', default='/datasets_master/waymo_open_dataset_v_1_2_0/validation', type=str, help='Set a path to load the Waymo dataset')
+    ap.add_argument('--save_path', default='/datasets_local/datasets_fpizzati/waymo_480x320/val', type=str, help='Set a path to save the dataset')
+    main(ap.parse_args())

scripts/sunny_sequences.txt

@@ -0,0 +1,850 @@
+segment-11486225968269855324_92_000_112_000
+segment-11566385337103696871_5740_000_5760_000
+segment-7000927478052605119_1052_330_1072_330
+segment-2975249314261309142_6540_000_6560_000
+segment-8031709558315183746_491_220_511_220
+segment-10723911392655396041_860_000_880_000
+segment-1022527355599519580_4866_960_4886_960
+segment-15644354861949427452_3645_350_3665_350
+segment-16801666784196221098_2480_000_2500_000
+segment-11967272535264406807_580_000_600_000
+segment-4266984864799709257_720_000_740_000
+segment-15445436653637630344_3957_561_3977_561
+segment-13182548552824592684_4160_250_4180_250
+segment-10498013744573185290_1240_000_1260_000
+segment-12551320916264703416_1420_000_1440_000
+segment-2036908808378190283_4340_000_4360_000
+segment-10750135302241325253_180_000_200_000
+segment-15696964848687303249_4615_200_4635_200
+segment-4167304237516228486_5720_000_5740_000
+segment-14810689888487451189_720_000_740_000
+segment-8158128948493708501_7477_230_7497_230
+segment-1382515516588059826_780_000_800_000
+segment-7768517933263896280_1120_000_1140_000
+segment-16345319168590318167_1420_000_1440_000
+segment-8663006751916427679_1520_000_1540_000
+segment-15795616688853411272_1245_000_1265_000
+segment-454855130179746819_4580_000_4600_000
+segment-12174529769287588121_3848_440_3868_440
+segment-5446766520699850364_157_000_177_000
+segment-11183906854663518829_2294_000_2314_000
+segment-13238419657658219864_4630_850_4650_850
+segment-3154510051521049916_7000_000_7020_000
+segment-7727809428114700355_2960_000_2980_000
+segment-9016865488168499365_4780_000_4800_000
+segment-10588771936253546636_2300_000_2320_000
+segment-16977844994272847523_2140_000_2160_000
+segment-4447423683538547117_536_022_556_022
+segment-14777753086917826209_4147_000_4167_000
+segment-15550613280008674010_1780_000_1800_000
+segment-11070802577416161387_740_000_760_000
+segment-16534202648288984983_900_000_920_000
+segment-15448466074775525292_2920_000_2940_000
+segment-17647858901077503501_1500_000_1520_000
+segment-15717839202171538526_1124_920_1144_920
+segment-16093022852977039323_2981_100_3001_100
+segment-12681651284932598380_3585_280_3605_280
+segment-15868625208244306149_4340_000_4360_000
+segment-10625026498155904401_200_000_220_000
+segment-7189996641300362130_3360_000_3380_000
+segment-11623618970700582562_2840_367_2860_367
+segment-2684088316387726629_180_000_200_000
+segment-14964131310266936779_3292_850_3312_850
+segment-5349843997395815699_1040_000_1060_000
+segment-3988957004231180266_5566_500_5586_500
+segment-16034875274658204340_240_000_260_000
+segment-6280779486809627179_760_000_780_000
+segment-10094743350625019937_3420_000_3440_000
+segment-5214491533551928383_1918_780_1938_780
+segment-2570264768774616538_860_000_880_000
+segment-5459113827443493510_380_000_400_000
+segment-14424804287031718399_1281_030_1301_030
+segment-5222336716599194110_8940_000_8960_000
+segment-4414235478445376689_2020_000_2040_000
+segment-2206505463279484253_476_189_496_189
+segment-5458962501360340931_3140_000_3160_000
+segment-574762194520856849_1660_000_1680_000
+segment-9465500459680839281_1100_000_1120_000
+segment-9907794657177651763_1126_570_1146_570
+segment-15803855782190483017_1060_000_1080_000
+segment-17750787536486427868_560_000_580_000
+segment-14763701469114129880_2260_000_2280_000
+segment-14369250836076988112_7249_040_7269_040
+segment-80599353855279550_2604_480_2624_480
+segment-4487677815262010875_4940_000_4960_000
+segment-7999729608823422351_1483_600_1503_600
+segment-16608525782988721413_100_000_120_000
+segment-15458436361042752328_3549_030_3569_030
+segment-2711351338963414257_1360_000_1380_000
+segment-3132641021038352938_1937_160_1957_160
+segment-15903544160717261009_3961_870_3981_870
+segment-14348136031422182645_3360_000_3380_000
+segment-17958696356648515477_1660_000_1680_000
+segment-4114454788208078028_660_000_680_000
+segment-2598465433001774398_740_670_760_670
+segment-10676267326664322837_311_180_331_180
+segment-8811210064692949185_3066_770_3086_770
+segment-12365808668068790137_2920_000_2940_000
+segment-2508530288521370100_3385_660_3405_660
+segment-4747171543583769736_425_544_445_544
+segment-5835049423600303130_180_000_200_000
+segment-2259324582958830057_3767_030_3787_030
+segment-16191439239940794174_2245_000_2265_000
+segment-13363977648531075793_343_000_363_000
+segment-4672649953433758614_2700_000_2720_000
+segment-3060057659029579482_420_000_440_000
+segment-1172406780360799916_1660_000_1680_000
+segment-6456165750159303330_1770_080_1790_080
+segment-12257951615341726923_2196_690_2216_690
+segment-10275144660749673822_5755_561_5775_561
+segment-3437741670889149170_1411_550_1431_550
+segment-17159836069183024120_640_000_660_000
+segment-15834329472172048691_2956_760_2976_760
+segment-1051897962568538022_238_170_258_170
+segment-5602237689147924753_760_000_780_000
+segment-11199484219241918646_2810_030_2830_030
+segment-4781039348168995891_280_000_300_000
+segment-16042842363202855955_265_000_285_000
+segment-7447927974619745860_820_000_840_000
+segment-7019385869759035132_4270_850_4290_850
+segment-13085453465864374565_2040_000_2060_000
+segment-16042886962142359737_1060_000_1080_000
+segment-11318901554551149504_520_000_540_000
+segment-915935412356143375_1740_030_1760_030
+segment-9747453753779078631_940_000_960_000
+segment-14824622621331930560_2395_420_2415_420
+segment-18096167044602516316_2360_000_2380_000
+segment-2547899409721197155_1380_000_1400_000
+segment-12581809607914381746_1219_547_1239_547
+segment-11379226583756500423_6230_810_6250_810
+segment-5100136784230856773_2517_300_2537_300
+segment-13402473631986525162_5700_000_5720_000
+segment-5127440443725457056_2921_340_2941_340
+segment-14561791273891593514_2558_030_2578_030
+segment-2618605158242502527_1860_000_1880_000
+segment-1357883579772440606_2365_000_2385_000
+segment-9015546800913584551_4431_180_4451_180
+segment-17885096890374683162_755_580_775_580
+segment-14388269713149187289_1994_280_2014_280
+segment-1994338527906508494_3438_100_3458_100
+segment-8323028393459455521_2105_000_2125_000
+segment-10327752107000040525_1120_000_1140_000
+segment-13258835835415292197_965_000_985_000
+segment-16102220208346880_1420_000_1440_000
+segment-11454085070345530663_1905_000_1925_000
+segment-15270638100874320175_2720_000_2740_000
+segment-17388121177218499911_2520_000_2540_000
+segment-7761658966964621355_1000_000_1020_000
+segment-514687114615102902_6240_000_6260_000
+segment-17850487901509155700_9065_000_9085_000
+segment-16202688197024602345_3818_820_3838_820
+segment-18331713844982117868_2920_900_2940_900
+segment-6417523992887712896_1180_000_1200_000
+segment-10770759614217273359_1465_000_1485_000
+segment-12858738411692807959_2865_000_2885_000
+segment-3068522656378006650_540_000_560_000
+segment-8207498713503609786_3005_450_3025_450
+segment-10072231702153043603_5725_000_5745_000
+segment-7934693355186591404_73_000_93_000
+segment-57132587708734824_1020_000_1040_000
+segment-15365821471737026848_1160_000_1180_000
+segment-10964956617027590844_1584_680_1604_680
+segment-1972128316147758939_2500_000_2520_000
+segment-8659567063494726263_2480_000_2500_000
+segment-9529958888589376527_640_000_660_000
+segment-14818835630668820137_1780_000_1800_000
+segment-3224923476345749285_4480_000_4500_000
+segment-14791260641858988448_1018_000_1038_000
+segment-10786629299947667143_3440_000_3460_000
+segment-3270384983482134275_3220_000_3240_000
+segment-7239123081683545077_4044_370_4064_370
+segment-3195159706851203049_2763_790_2783_790
+segment-8123909110537564436_7220_000_7240_000
+segment-17778522338768131809_5920_000_5940_000
+segment-15202102284304593700_1900_000_1920_000
+segment-13177337129001451839_9160_000_9180_000
+segment-7324192826315818756_620_000_640_000
+segment-4971817041565280127_780_500_800_500
+segment-3220249619779692045_505_000_525_000
+segment-9521653920958139982_940_000_960_000
+segment-1146261869236413282_1680_000_1700_000
+segment-11918003324473417938_1400_000_1420_000
+segment-10061305430875486848_1080_000_1100_000
+segment-15349503153813328111_2160_000_2180_000
+segment-17790754307864212354_1520_000_1540_000
+segment-17759280403078053118_6060_580_6080_580
+segment-4575961016807404107_880_000_900_000
+segment-10455472356147194054_1560_000_1580_000
+segment-6904827860701329567_960_000_980_000
+segment-6229371035421550389_2220_000_2240_000
+segment-6390847454531723238_6000_000_6020_000
+segment-4537254579383578009_3820_000_3840_000
+segment-5144634012371033641_920_000_940_000
+segment-9547911055204230158_1567_950_1587_950
+segment-1737018592744049492_1960_000_1980_000
+segment-6193696614129429757_2420_000_2440_000
+segment-550171902340535682_2640_000_2660_000
+segment-744006317457557752_2080_000_2100_000
+segment-4655005625668154134_560_000_580_000
+segment-3591015878717398163_1381_280_1401_280
+segment-3441838785578020259_1300_000_1320_000
+segment-10235335145367115211_5420_000_5440_000
+segment-12321865437129862911_3480_000_3500_000
+segment-1918764220984209654_5680_000_5700_000
+segment-13840133134545942567_1060_000_1080_000
+segment-7890808800227629086_6162_700_6182_700
+segment-2656110181316327570_940_000_960_000
+segment-990914685337955114_980_000_1000_000
+segment-10940952441434390507_1888_710_1908_710
+segment-473735159277431842_630_095_650_095
+segment-3543045673995761051_460_000_480_000
+segment-11126313430116606120_1439_990_1459_990
+segment-7290499689576448085_3960_000_3980_000
+segment-18311996733670569136_5880_000_5900_000
+segment-4916527289027259239_5180_000_5200_000
+segment-17552108427312284959_3200_000_3220_000
+segment-5200186706748209867_80_000_100_000
+segment-1265122081809781363_2879_530_2899_530
+segment-6303332643743862144_5600_000_5620_000
+segment-3112630089558008159_7280_000_7300_000
+segment-2088865281951278665_4460_000_4480_000
+segment-13310437789759009684_2645_000_2665_000
+segment-13944915979337652825_4260_668_4280_668
+segment-10526338824408452410_5714_660_5734_660
+segment-9062286840846668802_31_000_51_000
+segment-16911037681440249335_700_000_720_000
+segment-4960194482476803293_4575_960_4595_960
+segment-16336545122307923741_486_637_506_637
+segment-2101027554826767753_2504_580_2524_580
+segment-2922309829144504838_1840_000_1860_000
+segment-809159138284604331_3355_840_3375_840
+segment-15646511153936256674_1620_000_1640_000
+segment-5870668058140631588_1180_000_1200_000
+segment-3872781118550194423_3654_670_3674_670
+segment-7996500550445322129_2333_304_2353_304
+segment-16625429321676352815_1543_860_1563_860
+segment-16208935658045135756_4412_730_4432_730
+segment-6207195415812436731_805_000_825_000
+segment-15482064737890453610_5180_000_5200_000
+segment-11674150664140226235_680_000_700_000
+segment-4604173119409817302_2820_000_2840_000
+segment-9653249092275997647_980_000_1000_000
+segment-11928449532664718059_1200_000_1220_000
+segment-9758342966297863572_875_230_895_230
+segment-6037403592521973757_3260_000_3280_000
+segment-4114548607314119333_2780_000_2800_000
+segment-12894036666871194216_787_000_807_000
+segment-7741361323303179462_1230_310_1250_310
+segment-10517728057304349900_3360_000_3380_000
+segment-14619874262915043759_2801_090_2821_090
+segment-3490810581309970603_11125_000_11145_000
+segment-16485056021060230344_1576_741_1596_741
+segment-9415086857375798767_4760_000_4780_000
+segment-11119453952284076633_1369_940_1389_940
+segment-2752216004511723012_260_000_280_000
+segment-6625150143263637936_780_000_800_000
+segment-169115044301335945_480_000_500_000
+segment-12251442326766052580_1840_000_1860_000
+segment-15844593126368860820_3260_000_3280_000
+segment-16600468011801266684_1500_000_1520_000
+segment-10023947602400723454_1120_000_1140_000
+segment-1773696223367475365_1060_000_1080_000
+segment-1887497421568128425_94_000_114_000
+segment-18441113814326864765_725_000_745_000
+segment-10444454289801298640_4360_000_4380_000
+segment-2791302832590946720_1900_000_1920_000
+segment-10963653239323173269_1924_000_1944_000
+segment-11839652018869852123_2565_000_2585_000
+segment-14004546003548947884_2331_861_2351_861
+segment-1306458236359471795_2524_330_2544_330
+segment-17386718718413812426_1763_140_1783_140
+segment-8424573439186068308_3460_000_3480_000
+segment-9058545212382992974_5236_200_5256_200
+segment-5576800480528461086_1000_000_1020_000
+segment-13679757109245957439_4167_170_4187_170
+segment-16403578704435467513_5133_870_5153_870
+segment-4164064449185492261_400_000_420_000
+segment-3461811179177118163_1161_000_1181_000
+segment-2415873247906962761_5460_000_5480_000
+segment-13965460994524880649_2842_050_2862_050
+segment-18397511418934954408_620_000_640_000
+segment-11925224148023145510_1040_000_1060_000
+segment-12027892938363296829_4086_280_4106_280
+segment-33101359476901423_6720_910_6740_910
+segment-12879640240483815315_5852_605_5872_605
+segment-17818548625922145895_1372_430_1392_430
+segment-4324227028219935045_1520_000_1540_000
+segment-5083516879091912247_3600_000_3620_000
+segment-1758724094753801109_1251_037_1271_037
+segment-1730266523558914470_305_260_325_260
+segment-5072733804607719382_5807_570_5827_570
+segment-1231623110026745648_480_000_500_000
+segment-4348478035380346090_1000_000_1020_000
+segment-912496333665446669_1680_000_1700_000
+segment-1940032764689855266_3690_210_3710_210
+segment-7940496892864900543_4783_540_4803_540
+segment-4723255145958809564_741_350_761_350
+segment-17144150788361379549_2720_000_2740_000
+segment-2739239662326039445_5890_320_5910_320
+segment-14705303724557273004_3105_000_3125_000
+segment-8722413665055769182_2840_000_2860_000
+segment-16793466851577046940_2800_000_2820_000
+segment-15331851695963211598_1620_000_1640_000
+segment-3002379261592154728_2256_691_2276_691
+segment-1208303279778032257_1360_000_1380_000
+segment-3584210979358667442_2880_000_2900_000
+segment-10500357041547037089_1474_800_1494_800
+segment-2265177645248606981_2340_000_2360_000
+segment-13619063687271391084_1519_680_1539_680
+segment-7313718849795510302_280_000_300_000
+segment-14076089808269682731_54_730_74_730
+segment-11846396154240966170_3540_000_3560_000
+segment-17330200445788773877_2700_000_2720_000
+segment-4784689467343773295_1700_000_1720_000
+segment-6142170920525844857_2080_000_2100_000
+segment-14869732972903148657_2420_000_2440_000
+segment-9105380625923157726_4420_000_4440_000
+segment-11847506886204460250_1640_000_1660_000
+segment-4292360793125812833_3080_000_3100_000
+segment-6128311556082453976_2520_000_2540_000
+segment-1255991971750044803_1700_000_1720_000
+segment-6694593639447385226_1040_000_1060_000
+segment-11718898130355901268_2300_000_2320_000
+segment-11343624116265195592_5910_530_5930_530
+segment-9123867659877264673_3569_950_3589_950
+segment-4641822195449131669_380_000_400_000
+segment-3364861183015885008_1720_000_1740_000
+segment-5614471637960666943_6955_675_6975_675
+segment-3966447614090524826_320_000_340_000
+segment-12161824480686739258_1813_380_1833_380
+segment-7120839653809570957_1060_000_1080_000
+segment-4392459808686681511_5006_200_5026_200
+segment-1422926405879888210_51_310_71_310
+segment-7670103006580549715_360_000_380_000
+segment-10072140764565668044_4060_000_4080_000
+segment-16262849101474060261_3459_585_3479_585
+segment-14964691552976940738_2219_229_2239_229
+segment-1988987616835805847_3500_000_3520_000
+segment-786582060300383668_2944_060_2964_060
+segment-10734565072045778791_440_000_460_000
+segment-17993467596234560701_4940_000_4960_000
+segment-11004685739714500220_2300_000_2320_000
+segment-9509506420470671704_4049_100_4069_100
+segment-10485926982439064520_4980_000_5000_000
+segment-1352150727715827110_3710_250_3730_250
+segment-4457475194088194008_3100_000_3120_000
+segment-10664823084372323928_4360_000_4380_000
+segment-6813611334239274394_535_000_555_000
+segment-5718418936283106890_1200_000_1220_000
+segment-2114574223307001959_1163_280_1183_280
+segment-15125792363972595336_4960_000_4980_000
+segment-14183710428479823719_3140_000_3160_000
+segment-8603916601243187272_540_000_560_000
+segment-12896629105712361308_4520_000_4540_000
+segment-4323857429732097807_1005_000_1025_000
+segment-2935377810101940676_300_000_320_000
+segment-14143054494855609923_4529_100_4549_100
+segment-2151482270865536784_900_000_920_000
+segment-17987556068410436875_520_610_540_610
+segment-3425716115468765803_977_756_997_756
+segment-17066133495361694802_1220_000_1240_000
+segment-6792191642931213648_1522_000_1542_000
+segment-15578655130939579324_620_000_640_000
+segment-5268267801500934740_2160_000_2180_000
+segment-6771783338734577946_6105_840_6125_840
+segment-10231929575853664160_1160_000_1180_000
+segment-11489533038039664633_4820_000_4840_000
+segment-18380281348728758158_4820_000_4840_000
+segment-9288629315134424745_4360_000_4380_000
+segment-15374821596407640257_3388_480_3408_480
+segment-18111897798871103675_320_000_340_000
+segment-9110125340505914899_380_000_400_000
+segment-7458568461947999548_700_000_720_000
+segment-54293441958058219_2335_200_2355_200
+segment-11060291335850384275_3761_210_3781_210
+segment-12339284075576056695_1920_000_1940_000
+segment-17160696560226550358_6229_820_6249_820
+segment-3031519073799366723_1140_000_1160_000
+segment-13271285919570645382_5320_000_5340_000
+segment-8763126149209091146_1843_320_1863_320
+segment-3156155872654629090_2474_780_2494_780
+segment-9350921499281634194_2403_251_2423_251
+segment-16578409328451172992_3780_000_3800_000
+segment-11940460932056521663_1760_000_1780_000
+segment-14830022845193837364_3488_060_3508_060
+segment-17270469718624587995_5202_030_5222_030
+segment-17959337482465423746_2840_000_2860_000
+segment-16651261238721788858_2365_000_2385_000
+segment-4458730539804900192_535_000_555_000
+segment-15832924468527961_1564_160_1584_160
+segment-11392401368700458296_1086_429_1106_429
+segment-2336233899565126347_1180_000_1200_000
+segment-16873108320324977627_780_000_800_000
+segment-13622747960068272448_1678_930_1698_930
+segment-17216329305659006368_4800_000_4820_000
+segment-7950869827763684964_8685_000_8705_000
+segment-3657581213864582252_340_000_360_000
+segment-2899357195020129288_3723_163_3743_163
+segment-9179922063516210200_157_000_177_000
+segment-16087604685956889409_40_000_60_000
+segment-17342274091983078806_80_000_100_000
+segment-6742105013468660925_3645_000_3665_000
+segment-1999080374382764042_7094_100_7114_100
+segment-8582923946352460474_2360_000_2380_000
+segment-15379350264706417068_3120_000_3140_000
+segment-204421859195625800_1080_000_1100_000
+segment-6242822583398487496_73_000_93_000
+segment-6350707596465488265_2393_900_2413_900
+segment-16121633832852116614_240_000_260_000
+segment-13731697468004921673_4920_000_4940_000
+segment-12505030131868863688_1740_000_1760_000
+segment-12337317986514501583_5346_260_5366_260
+segment-6234738900256277070_320_000_340_000
+segment-12566399510596872945_2078_320_2098_320
+segment-7921369793217703814_1060_000_1080_000
+segment-3418007171190630157_3585_530_3605_530
+segment-15053781258223091665_3192_117_3212_117
+segment-15787777881771177481_8820_000_8840_000
+segment-13862220583747475906_1260_000_1280_000
+segment-9311322119128915594_5285_000_5305_000
+segment-6606076833441976341_1340_000_1360_000
+segment-7331965392247645851_1005_940_1025_940
+segment-11113047206980595400_2560_000_2580_000
+segment-15535062863944567958_1100_000_1120_000
+segment-2692887320656885771_2480_000_2500_000
+segment-8099457465580871094_4764_380_4784_380
+segment-13033853066564892960_1040_000_1060_000
+segment-9385013624094020582_2547_650_2567_650
+segment-3504776317009340435_6920_000_6940_000
+segment-2660301763960988190_3742_580_3762_580
+segment-13186511704021307558_2000_000_2020_000
+segment-16435050660165962165_3635_310_3655_310
+segment-1939881723297238689_6848_040_6868_040
+segment-11799592541704458019_9828_750_9848_750
+segment-18403940760739364047_920_000_940_000
+segment-2555987917096562599_1620_000_1640_000
+segment-4337887720320812223_1857_930_1877_930
+segment-9568394837328971633_466_365_486_365
+segment-3635081602482786801_900_000_920_000
+segment-17761959194352517553_5448_420_5468_420
+segment-8938046348067069210_3800_000_3820_000
+segment-5592790652933523081_667_770_687_770
+segment-1191788760630624072_3880_000_3900_000
+segment-12979718722917614085_1039_490_1059_490
+segment-17547795428359040137_5056_070_5076_070
+segment-16331619444570993520_1020_000_1040_000
+segment-16646502593577530501_4878_080_4898_080
+segment-6410495600874495447_5287_500_5307_500
+segment-6177474146670383260_4200_000_4220_000
+segment-13823509240483976870_1514_190_1534_190
+segment-8120716761799622510_862_120_882_120
+segment-5215905243049326497_20_000_40_000
+segment-7543690094688232666_4945_350_4965_350
+segment-13196796799137805454_3036_940_3056_940
+segment-2961247865039433386_920_000_940_000
+segment-17674974223808194792_8787_692_8807_692
+segment-5526948896847934178_1039_000_1059_000
+segment-4931036732523207946_10755_600_10775_600
+segment-7089765864827567005_1020_000_1040_000
+segment-5005815668926224220_2194_330_2214_330
+segment-15266427834976906738_1620_000_1640_000
+segment-6104545334635651714_2780_000_2800_000
+segment-4546515828974914709_922_040_942_040
+segment-9985243312780923024_3049_720_3069_720
+segment-7566697458525030390_1440_000_1460_000
+segment-10923963890428322967_1445_000_1465_000
+segment-6638427309837298695_220_000_240_000
+segment-17941839888833418904_1240_000_1260_000
+segment-17407069523496279950_4354_900_4374_900
+segment-7517545172000568481_2325_000_2345_000
+segment-10596949720463106554_1933_530_1953_530
+segment-15628918650068847391_8077_670_8097_670
+segment-5846229052615948000_2120_000_2140_000
+segment-18286677872269962604_3520_000_3540_000
+segment-16951470340360921766_2840_000_2860_000
+segment-1863454917318776530_1040_000_1060_000
+segment-14098605172844003779_5084_630_5104_630
+segment-8327447186504415549_5200_000_5220_000
+segment-11388947676680954806_5427_320_5447_320
+segment-12179768245749640056_5561_070_5581_070
+segment-2590213596097851051_460_000_480_000
+segment-1442753028323350651_4065_000_4085_000
+segment-8399876466981146110_2560_000_2580_000
+segment-16646360389507147817_3320_000_3340_000
+segment-10793018113277660068_2714_540_2734_540
+segment-14018515129165961775_483_260_503_260
+segment-2863984611797967753_3200_000_3220_000
+segment-13909033332341079321_4007_930_4027_930
+segment-13390791323468600062_6718_570_6738_570
+segment-13476374534576730229_240_000_260_000
+segment-18141076662151909970_2755_710_2775_710
+segment-7101099554331311287_5320_000_5340_000
+segment-2224716024428969146_1420_000_1440_000
+segment-8700094808505895018_7272_488_7292_488
+segment-5731414711882954246_1990_250_2010_250
+segment-4733704239941053266_960_000_980_000
+segment-634378055350569306_280_000_300_000
+segment-6172160122069514875_6866_560_6886_560
+segment-15942468615931009553_1243_190_1263_190
+segment-16224018017168210482_6353_500_6373_500
+segment-18025338595059503802_571_216_591_216
+segment-7885161619764516373_289_280_309_280
+segment-9820553434532681355_2820_000_2840_000
+segment-207754730878135627_1140_000_1160_000
+segment-15882343134097151256_4820_000_4840_000
+segment-9325580606626376787_4509_140_4529_140
+segment-13254498462985394788_980_000_1000_000
+segment-16676683078119047936_300_000_320_000
+segment-3911646355261329044_580_000_600_000
+segment-6740694556948402155_3040_000_3060_000
+segment-14233522945839943589_100_000_120_000
+segment-4017824591066644473_3000_000_3020_000
+segment-14250544550818363063_880_000_900_000
+segment-8822503619482926605_1080_000_1100_000
+segment-6814918034011049245_134_170_154_170
+segment-10391312872392849784_4099_400_4119_400
+segment-4468278022208380281_455_820_475_820
+segment-1005081002024129653_5313_150_5333_150
+segment-2577669988012459365_1640_000_1660_000
+segment-13506499849906169066_120_000_140_000
+segment-8148053503558757176_4240_000_4260_000
+segment-12273083120751993429_7285_000_7305_000
+segment-9250355398701464051_4166_132_4186_132
+segment-15533468984793020049_800_000_820_000
+segment-5451442719480728410_5660_000_5680_000
+segment-12511696717465549299_4209_630_4229_630
+segment-1926967104529174124_5214_780_5234_780
+segment-15903184480576180688_3160_000_3180_000
+segment-15265053588821562107_60_000_80_000
+segment-6378340771722906187_1120_000_1140_000
+segment-7861168750216313148_1305_290_1325_290
+segment-13142190313715360621_3888_090_3908_090
+segment-972142630887801133_642_740_662_740
+segment-13145971249179441231_1640_000_1660_000
+segment-4702302448560822815_927_380_947_380
+segment-3461228720457810721_4511_120_4531_120
+segment-4058410353286511411_3980_000_4000_000
+segment-11588853832866011756_2184_462_2204_462
+segment-5495302100265783181_80_000_100_000
+segment-3711598698808133144_2060_000_2080_000
+segment-16372013171456210875_5631_040_5651_040
+segment-15062351272945542584_5921_360_5941_360
+segment-6935841224766931310_2770_310_2790_310
+segment-3644145307034257093_3000_400_3020_400
+segment-12012663867578114640_820_000_840_000
+segment-16080705915014211452_620_000_640_000
+segment-7912728502266478772_1202_200_1222_200
+segment-1857377326903987736_80_000_100_000
+segment-3919438171935923501_280_000_300_000
+segment-5129792222840846899_2145_000_2165_000
+segment-12974838039736660070_4586_990_4606_990
+segment-2342300897175196823_1179_360_1199_360
+segment-7344536712079322768_1360_000_1380_000
+segment-3338044015505973232_1804_490_1824_490
+segment-13181198025433053194_2620_770_2640_770
+segment-16504318334867223853_480_000_500_000
+segment-5973788713714489548_2179_770_2199_770
+segment-3078075798413050298_890_370_910_370
+segment-6561206763751799279_2348_600_2368_600
+segment-3451017128488170637_5280_000_5300_000
+segment-13207915841618107559_2980_000_3000_000
+segment-17912777897400903477_2047_500_2067_500
+segment-8126606965364870152_985_090_1005_090
+segment-6433401807220119698_4560_000_4580_000
+segment-7837172662136597262_1140_000_1160_000
+segment-1305342127382455702_3720_000_3740_000
+segment-2919021496271356282_2300_000_2320_000
+segment-16735938448970076374_1126_430_1146_430
+segment-8806931859563747931_1160_000_1180_000
+segment-7554208726220851641_380_000_400_000
+segment-14940138913070850675_5755_330_5775_330
+segment-5076950993715916459_3265_000_3285_000
+segment-16797668128356194527_2430_390_2450_390
+segment-7038362761309539946_4207_130_4227_130
+segment-14766384747691229841_6315_730_6335_730
+segment-10876852935525353526_1640_000_1660_000
+segment-14276116893664145886_1785_080_1805_080
+segment-8487809726845917818_4779_870_4799_870
+segment-14358192009676582448_3396_400_3416_400
+segment-3563349510410371738_7465_000_7485_000
+segment-12212767626682531382_2100_150_2120_150
+segment-6559997992780479765_1039_000_1059_000
+segment-3698685523057788592_4303_630_4323_630
+segment-1432918953215186312_5101_320_5121_320
+segment-13585809231635721258_1910_770_1930_770
+segment-8345535260120974350_1980_000_2000_000
+segment-4138614210962611770_2459_360_2479_360
+segment-15943938987133888575_2767_300_2787_300
+segment-15036582848618865396_3752_830_3772_830
+segment-11252086830380107152_1540_000_1560_000
+segment-141184560845819621_10582_560_10602_560
+segment-6150191934425217908_2747_800_2767_800
+segment-14430914081327266277_6480_000_6500_000
+segment-8543158371164842559_4131_530_4151_530
+segment-10212406498497081993_5300_000_5320_000
+segment-14503113925613619599_975_506_995_506
+segment-16341778301681295961_178_800_198_800
+segment-14734824171146590110_880_000_900_000
+segment-17752423643206316420_920_850_940_850
+segment-13005562150845909564_3141_360_3161_360
+segment-16470190748368943792_4369_490_4389_490
+segment-12281202743097872109_3387_370_3407_370
+segment-4013698638848102906_7757_240_7777_240
+segment-3276301746183196185_436_450_456_450
+segment-13519445614718437933_4060_000_4080_000
+segment-1891390218766838725_4980_000_5000_000
+segment-200287570390499785_2102_000_2122_000
+segment-16473613811052081539_1060_000_1080_000
+segment-3928923269768424494_3060_000_3080_000
+segment-2475623575993725245_400_000_420_000
+segment-4305539677513798673_2200_000_2220_000
+segment-575209926587730008_3880_000_3900_000
+segment-11017034898130016754_697_830_717_830
+segment-8796914080594559459_4284_170_4304_170
+segment-16552287303455735122_7587_380_7607_380
+segment-1907783283319966632_3221_000_3241_000
+segment-5525943706123287091_4100_000_4120_000
+segment-12856053589272984699_1020_000_1040_000
+segment-16153607877566142572_2262_000_2282_000
+segment-2217043033232259972_2720_000_2740_000
+segment-7466751345307077932_585_000_605_000
+segment-5691636094473163491_6889_470_6909_470
+segment-8859409804103625626_2760_000_2780_000
+segment-6290334089075942139_1340_000_1360_000
+segment-2698953791490960477_2660_000_2680_000
+segment-3665329186611360820_2329_010_2349_010
+segment-268278198029493143_1400_000_1420_000
+segment-14466332043440571514_6530_560_6550_560
+segment-8633296376655504176_514_000_534_000
+segment-15367782110311024266_2103_310_2123_310
+segment-15090871771939393635_1266_320_1286_320
+segment-7850521592343484282_4576_090_4596_090
+segment-12200383401366682847_2552_140_2572_140
+segment-2400780041057579262_660_000_680_000
+segment-12988666890418932775_5516_730_5536_730
+segment-14073491244121877213_4066_056_4086_056
+segment-10082223140073588526_6140_000_6160_000
+segment-17782258508241656695_1354_000_1374_000
+segment-4191035366928259953_1732_708_1752_708
+segment-4967385055468388261_720_000_740_000
+segment-2025831330434849594_1520_000_1540_000
+segment-10975280749486260148_940_000_960_000
+segment-7187601925763611197_4384_300_4404_300
+segment-8513241054672631743_115_960_135_960
+segment-16652690380969095006_2580_000_2600_000
+segment-13517115297021862252_2680_000_2700_000
+segment-2107164705125601090_3920_000_3940_000
+segment-10226164909075980558_180_000_200_000
+segment-2323851946122476774_7240_000_7260_000
+segment-7920326980177504058_2454_310_2474_310
+segment-7799671367768576481_260_000_280_000
+segment-17874036087982478403_733_674_753_674
+segment-2273990870973289942_4009_680_4029_680
+segment-2330686858362435307_603_210_623_210
+segment-1473681173028010305_1780_000_1800_000
+segment-10724020115992582208_7660_400_7680_400
+segment-10241508783381919015_2889_360_2909_360
+segment-6674547510992884047_1560_000_1580_000
+segment-6771922013310347577_4249_290_4269_290
+segment-17356174167372765800_1720_000_1740_000
+segment-3417928259332148981_7018_550_7038_550
+segment-6148393791213790916_4960_000_4980_000
+segment-7007702792982559244_4400_000_4420_000
+segment-12956664801249730713_2840_000_2860_000
+segment-14753089714893635383_873_600_893_600
+segment-4986495627634617319_2980_000_3000_000
+segment-10206293520369375008_2796_800_2816_800
+segment-3927294516406132977_792_740_812_740
+segment-13940755514149579648_821_157_841_157
+segment-5572351910320677279_3980_000_4000_000
+segment-580580436928611523_792_500_812_500
+segment-12900898236728415654_1906_686_1926_686
+segment-18136695827203527782_2860_000_2880_000
+segment-18244334282518155052_2360_000_2380_000
+segment-4384676699661561426_1662_670_1682_670
+segment-6386303598440879824_1520_000_1540_000
+segment-13667377240304615855_500_000_520_000
+segment-175830748773502782_1580_000_1600_000
+segment-6763005717101083473_3880_000_3900_000
+segment-9175749307679169289_5933_260_5953_260
+segment-14739149465358076158_4740_000_4760_000
+segment-7732779227944176527_2120_000_2140_000
+segment-3126522626440597519_806_440_826_440
+segment-16229547658178627464_380_000_400_000
+segment-17612470202990834368_2800_000_2820_000
+segment-12102100359426069856_3931_470_3951_470
+segment-30779396576054160_1880_000_1900_000
+segment-8907419590259234067_1960_000_1980_000
+segment-15021599536622641101_556_150_576_150
+segment-11450298750351730790_1431_750_1451_750
+segment-17539775446039009812_440_000_460_000
+segment-346889320598157350_798_187_818_187
+segment-9443948810903981522_6538_870_6558_870
+segment-8956556778987472864_3404_790_3424_790
+segment-4195774665746097799_7300_960_7320_960
+segment-4854173791890687260_2880_000_2900_000
+segment-6707256092020422936_2352_392_2372_392
+segment-14383152291533557785_240_000_260_000
+segment-2551868399007287341_3100_000_3120_000
+segment-12866817684252793621_480_000_500_000
+segment-3015436519694987712_1300_000_1320_000
+segment-9024872035982010942_2578_810_2598_810
+segment-17962792089966876718_2210_933_2230_933
+segment-3577352947946244999_3980_000_4000_000
+segment-5832416115092350434_60_000_80_000
+segment-7253952751374634065_1100_000_1120_000
+segment-17344036177686610008_7852_160_7872_160
+segment-14165166478774180053_1786_000_1806_000
+segment-14333744981238305769_5658_260_5678_260
+segment-8302000153252334863_6020_000_6040_000
+segment-6074871217133456543_1000_000_1020_000
+segment-8506432817378693815_4860_000_4880_000
+segment-5990032395956045002_6600_000_6620_000
+segment-366934253670232570_2229_530_2249_530
+segment-13573359675885893802_1985_970_2005_970
+segment-13469905891836363794_4429_660_4449_660
+segment-89454214745557131_3160_000_3180_000
+segment-12831741023324393102_2673_230_2693_230
+segment-1105338229944737854_1280_000_1300_000
+segment-15611747084548773814_3740_000_3760_000
+segment-933621182106051783_4160_000_4180_000
+segment-2834723872140855871_1615_000_1635_000
+segment-10837554759555844344_6525_000_6545_000
+segment-12306251798468767010_560_000_580_000
+segment-12374656037744638388_1412_711_1432_711
+segment-15224741240438106736_960_000_980_000
+segment-1943605865180232897_680_000_700_000
+segment-17065833287841703_2980_000_3000_000
+segment-2736377008667623133_2676_410_2696_410
+segment-5183174891274719570_3464_030_3484_030
+segment-1457696187335927618_595_027_615_027
+segment-10289507859301986274_4200_000_4220_000
+segment-15724298772299989727_5386_410_5406_410
+segment-17860546506509760757_6040_000_6060_000
+segment-14127943473592757944_2068_000_2088_000
+segment-18446264979321894359_3700_000_3720_000
+segment-4575389405178805994_4900_000_4920_000
+segment-2105808889850693535_2295_720_2315_720
+segment-2367305900055174138_1881_827_1901_827
+segment-8133434654699693993_1162_020_1182_020
+segment-14262448332225315249_1280_000_1300_000
+segment-15496233046893489569_4551_550_4571_550
+segment-13178092897340078601_5118_604_5138_604
+segment-10868756386479184868_3000_000_3020_000
+segment-5302885587058866068_320_000_340_000
+segment-11048712972908676520_545_000_565_000
+segment-7119831293178745002_1094_720_1114_720
+segment-5372281728627437618_2005_000_2025_000
+segment-902001779062034993_2880_000_2900_000
+segment-14956919859981065721_1759_980_1779_980
+segment-7493781117404461396_2140_000_2160_000
+segment-3731719923709458059_1540_000_1560_000
+segment-9472420603764812147_850_000_870_000
+segment-13356997604177841771_3360_000_3380_000
+segment-4423389401016162461_4235_900_4255_900
+segment-2094681306939952000_2972_300_2992_300
+segment-14244512075981557183_1226_840_1246_840
+segment-14486517341017504003_3406_349_3426_349
+segment-17135518413411879545_1480_000_1500_000
+segment-1024360143612057520_3580_000_3600_000
+segment-2506799708748258165_6455_000_6475_000
+segment-4759225533437988401_800_000_820_000
+segment-13299463771883949918_4240_000_4260_000
+segment-8331804655557290264_4351_740_4371_740
+segment-11434627589960744626_4829_660_4849_660
+segment-260994483494315994_2797_545_2817_545
+segment-4612525129938501780_340_000_360_000
+segment-9243656068381062947_1297_428_1317_428
+segment-16767575238225610271_5185_000_5205_000
+segment-17152649515605309595_3440_000_3460_000
+segment-662188686397364823_3248_800_3268_800
+segment-272435602399417322_2884_130_2904_130
+segment-17703234244970638241_220_000_240_000
+segment-15096340672898807711_3765_000_3785_000
+segment-18252111882875503115_378_471_398_471
+segment-9231652062943496183_1740_000_1760_000
+segment-13941626351027979229_3363_930_3383_930
+segment-14811410906788672189_373_113_393_113
+segment-8079607115087394458_1240_000_1260_000
+segment-3915587593663172342_10_000_30_000
+segment-11406166561185637285_1753_750_1773_750
+segment-16751706457322889693_4475_240_4495_240
+segment-15948509588157321530_7187_290_7207_290
+segment-4690718861228194910_1980_000_2000_000
+segment-4013125682946523088_3540_000_3560_000
+segment-5373876050695013404_3817_170_3837_170
+segment-2335854536382166371_2709_426_2729_426
+segment-6183008573786657189_5414_000_5434_000
+segment-12940710315541930162_2660_000_2680_000
+segment-3039251927598134881_1240_610_1260_610
+segment-7988627150403732100_1487_540_1507_540
+segment-6680764940003341232_2260_000_2280_000
+segment-18333922070582247333_320_280_340_280
+segment-8137195482049459160_3100_000_3120_000
+segment-4490196167747784364_616_569_636_569
+segment-7163140554846378423_2717_820_2737_820
+segment-7932945205197754811_780_000_800_000
+segment-1906113358876584689_1359_560_1379_560
+segment-17244566492658384963_2540_000_2560_000
+segment-5574146396199253121_6759_360_6779_360
+segment-271338158136329280_2541_070_2561_070
+segment-18331704533904883545_1560_000_1580_000
+segment-1071392229495085036_1844_790_1864_790
+segment-15959580576639476066_5087_580_5107_580
+segment-10203656353524179475_7625_000_7645_000
+segment-11616035176233595745_3548_820_3568_820
+segment-17626999143001784258_2760_000_2780_000
+segment-3651243243762122041_3920_000_3940_000
+segment-6324079979569135086_2372_300_2392_300
+segment-8888517708810165484_1549_770_1569_770
+segment-6637600600814023975_2235_000_2255_000
+segment-1505698981571943321_1186_773_1206_773
+segment-7650923902987369309_2380_000_2400_000
+segment-5847910688643719375_180_000_200_000
+segment-7799643635310185714_680_000_700_000
+segment-18045724074935084846_6615_900_6635_900
+segment-10247954040621004675_2180_000_2200_000
+segment-6001094526418694294_4609_470_4629_470
+segment-6161542573106757148_585_030_605_030
+segment-3077229433993844199_1080_000_1100_000
+segment-13336883034283882790_7100_000_7120_000
+segment-4764167778917495793_860_000_880_000
+segment-12358364923781697038_2232_990_2252_990
+segment-9265793588137545201_2981_960_3001_960
+segment-12820461091157089924_5202_916_5222_916
+segment-17763730878219536361_3144_635_3164_635
+segment-12657584952502228282_3940_000_3960_000
+segment-967082162553397800_5102_900_5122_900
+segment-9041488218266405018_6454_030_6474_030
+segment-16213317953898915772_1597_170_1617_170
+segment-9579041874842301407_1300_000_1320_000
+segment-15488266120477489949_3162_920_3182_920
+segment-15396462829361334065_4265_000_4285_000
+segment-17694030326265859208_2340_000_2360_000
+segment-14663356589561275673_935_195_955_195
+segment-9114112687541091312_1100_000_1120_000
+segment-1331771191699435763_440_000_460_000
+segment-17136314889476348164_979_560_999_560
+segment-14931160836268555821_5778_870_5798_870
+segment-5772016415301528777_1400_000_1420_000
+segment-4246537812751004276_1560_000_1580_000
+segment-11037651371539287009_77_670_97_670
+segment-14624061243736004421_1840_000_1860_000
+segment-10689101165701914459_2072_300_2092_300
+segment-4409585400955983988_3500_470_3520_470
+segment-8845277173853189216_3828_530_3848_530
+segment-8679184381783013073_7740_000_7760_000
+segment-10335539493577748957_1372_870_1392_870
+segment-5289247502039512990_2640_000_2660_000
+segment-18024188333634186656_1566_600_1586_600
+segment-13982731384839979987_1680_000_1700_000
+segment-18305329035161925340_4466_730_4486_730
+segment-11660186733224028707_420_000_440_000
+segment-14107757919671295130_3546_370_3566_370
+segment-1464917900451858484_1960_000_1980_000
+segment-11387395026864348975_3820_000_3840_000
+segment-11901761444769610243_556_000_576_000
+segment-14300007604205869133_1160_000_1180_000
+segment-9164052963393400298_4692_970_4712_970
+segment-4426410228514970291_1620_000_1640_000
+segment-4816728784073043251_5273_410_5293_410

scripts/translate.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import pathlib
+import torch
+import yaml
+import sys
+import os
+
+from math import pi
+from PIL import Image
+from munch import Munch
+from argparse import ArgumentParser as AP
+from torchvision.transforms import ToPILImage, ToTensor
+
+p_mod = str(pathlib.Path('.').absolute())
+sys.path.append(p_mod.replace("/scripts", ""))
+
+from data.base_dataset import get_transform
+from networks import create_model
+
+device='cuda' if torch.cuda.is_available() else 'cpu'
+def printProgressBar(i, max, postText):
+    n_bar = 20 # size of progress bar
+    j = i / max
+    sys.stdout.write('\r')
+    sys.stdout.write(f"[{'=' * int(n_bar * j):{n_bar}s}] {int(100 * j)}%  {postText}")
+    sys.stdout.flush()
+
+def inference(model, opt, A_path, phi):
+    t_phi = torch.tensor(phi)
+    A_img = Image.open(A_path).convert('RGB')
+    A = get_transform(opt, convert=False)(A_img)
+    img_real = (((ToTensor()(A)) * 2) - 1).unsqueeze(0)
+    img_fake = model.forward(img_real.to(device), t_phi.to(device))
+
+    return ToPILImage()((img_fake[0].cpu() + 1) / 2)
+
+def main(cmdline):
+    if cmdline.checkpoint is None:
+        # Load names of directories inside /logs
+        p = pathlib.Path('./logs')
+        list_run_id = [x.name for x in p.iterdir() if x.is_dir()]
+
+        RUN_ID = list_run_id[0]
+        root_dir = os.path.join('logs', RUN_ID, 'tensorboard', 'default', 'version_0')
+        p = pathlib.Path(root_dir + '/checkpoints')
+        # Load a list of checkpoints, use the last one by default
+        list_checkpoint = [x.name for x in p.iterdir() if 'iter' in x.name]
+        list_checkpoint.sort(reverse=True, key=lambda x: int(x.split('_')[1].split('.pth')[0]))
+
+        CHECKPOINT = list_checkpoint[0]
+    else:
+        RUN_ID = os.path.basename(cmdline.checkpoint.split("/tensorboard")[0])
+        root_dir = os.path.dirname(cmdline.checkpoint.split("/checkpoints")[0])
+        CHECKPOINT = os.path.basename(cmdline.checkpoint.split('checkpoints/')[1])
+
+    print(f"Load checkpoint {CHECKPOINT} from {RUN_ID}")
+
+    # Load parameters
+    with open(os.path.join(root_dir, 'hparams.yaml')) as cfg_file:
+        opt = Munch(yaml.safe_load(cfg_file))
+
+    opt.no_flip = True
+    # Load parameters to the model, load the checkpoint
+    model = create_model(opt)
+    model = model.load_from_checkpoint(os.path.join(root_dir, 'checkpoints', CHECKPOINT))
+    # Transfer the model to the GPU
+    model.to(device)
+
+    # Load paths of all files contained in /Day
+    p = pathlib.Path(cmdline.load_path)
+    dataset_paths = [str(x.relative_to(cmdline.load_path)) for x in p.iterdir()]
+    dataset_paths.sort()
+
+    # Load only files that contained the given string
+    sequence_name = []
+    if cmdline.sequence is not None:
+        for file in dataset_paths:
+            if cmdline.sequence in file:
+                sequence_name.append(file)
+    else:
+        sequence_name = dataset_paths
+
+    # Create directory if it doesn't exist
+    os.makedirs(cmdline.save_path, exist_ok=True)
+
+    i = 0
+    list_phi_modified = [torch.tensor(0.4), torch.tensor(0.8), torch.tensor(1.2), torch.tensor(1.6), torch.tensor(2.0)]
+    for path_img in sequence_name:
+        printProgressBar(i, len(sequence_name), path_img)
+        for phi in list_phi_modified:
+            # Forward our image into the model with the specified ɸ
+            out_img = inference(model, opt, os.path.join(cmdline.load_path, path_img), phi)
+            save_path = os.path.join(cmdline.save_path, f"{os.path.splitext(os.path.basename(path_img))[0]}_phi_{phi:.1f}.png")
+            out_img.save(save_path)
+        i += 1
+
+if __name__ == '__main__':
+    ap = AP()
+    ap.add_argument('--load_path', default='/datasets/waymo_comogan/val/sunny/Day/', type=str, help='Set a path to load the dataset to translate')
+    ap.add_argument('--save_path', default='/CoMoGan/images/', type=str, help='Set a path to save the dataset')
+    ap.add_argument('--sequence', default=None, type=str, help='Set a sequence, will only use the image that contained the string specified')
+    ap.add_argument('--checkpoint', default=None, type=str, help='Set a path to the checkpoint that you want to use')
+    ap.add_argument('--phi', default=0.0, type=float, help='Choose the angle of the sun 𝜙 between [0,2𝜋], which maps to a sun elevation ∈ [+30◦,−40◦]')
+    main(ap.parse_args())
+    print("\n")

train.py

@@ -0,0 +1,59 @@
+import time
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # Disables tensorflow loggings
+
+from options import get_options
+from data import create_dataset
+from networks import create_model, get_model_options
+from argparse import ArgumentParser as AP
+
+import pytorch_lightning as pl
+from pytorch_lightning.loggers import TensorBoardLogger
+
+from util.callbacks import LogAndCheckpointEveryNSteps
+from human_id import generate_id
+
+def start(cmdline):
+
+    pl.trainer.seed_everything(cmdline.seed)
+    opt = get_options(cmdline)
+
+    dataset = create_dataset(opt)  # create a dataset given opt.dataset_mode and other options
+    model = create_model(opt)      # create a model given opt.model and other options
+
+    callbacks = []
+
+    logger = None
+    if not cmdline.debug:
+        root_dir = os.path.join('logs/', generate_id()) if cmdline.id == None else os.path.join('logs/', cmdline.id)
+        logger = TensorBoardLogger(save_dir=os.path.join(root_dir, 'tensorboard'))
+        logger.log_hyperparams(opt)
+        callbacks.append(LogAndCheckpointEveryNSteps(save_step_frequency=opt.save_latest_freq,
+                                                     viz_frequency=opt.display_freq,
+                                                     log_frequency=opt.print_freq))
+    else:
+        root_dir = os.path.join('/tmp', generate_id())
+
+    precision = 16 if cmdline.mixed_precision else 32
+
+    trainer = pl.Trainer(default_root_dir=os.path.join(root_dir, 'checkpoints'), callbacks=callbacks,
+                         gpus=cmdline.gpus, logger=logger, precision=precision, amp_level='01')
+    trainer.fit(model, dataset)
+
+
+if __name__ == '__main__':
+    ap = AP()
+    ap.add_argument('--id', default=None, type=str, help='Set an existing uuid to resume a training')
+    ap.add_argument('--debug', default=False, action='store_true', help='Disables experiment saving')
+    ap.add_argument('--gpus', default=[0], type=int, nargs='+', help='gpus to train on')
+    ap.add_argument('--model', default='comomunit', type=str, help='Choose model for training')
+    ap.add_argument('--data_importer', default='day2timelapse', type=str, help='Module name of the dataset importer')
+    ap.add_argument('--path_data', default='/datasets/waymo_comogan/train/', type=str, help='Path to the dataset')
+    ap.add_argument('--learning_rate', default=0.0001, type=float, help='Learning rate')
+    ap.add_argument('--scheduler_policy', default='step', type=str, help='Scheduler policy')
+    ap.add_argument('--decay_iters_step', default=200000, type=int, help='Decay iterations step')
+    ap.add_argument('--decay_step_gamma', default=0.5, type=float, help='Decay step gamma')
+    ap.add_argument('--seed', default=1, type=int, help='Random seed')
+    ap.add_argument('--mixed_precision', default=False, action='store_true', help='Use mixed precision to reduce memory usage')
+    start(ap.parse_args())
+

util/__init__.py

@@ -0,0 +1,11 @@
+"""This package includes a miscellaneous collection of useful helper functions."""
+from torch.nn import DataParallel
+
+import sys
+
+class DataParallelPassthrough(DataParallel):
+    def __getattr__(self, name):
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            return getattr(self.module, name)

util/callbacks.py

@@ -0,0 +1,41 @@
+import pytorch_lightning as pl
+from hashlib import md5
+import os
+
+class LogAndCheckpointEveryNSteps(pl.Callback):
+    """
+    Save a checkpoint/logs every N steps
+    """
+
+    def __init__(
+        self,
+        save_step_frequency=50,
+        viz_frequency=5,
+        log_frequency=5
+    ):
+        self.save_step_frequency = save_step_frequency
+        self.viz_frequency = viz_frequency
+        self.log_frequency = log_frequency
+
+    def on_batch_end(self, trainer: pl.Trainer, _):
+        global_step = trainer.global_step
+
+        # Saving checkpoint
+        if global_step % self.save_step_frequency == 0 and global_step != 0:
+            filename = "iter_{}.pth".format(global_step)
+            ckpt_path = os.path.join(trainer.checkpoint_callback.dirpath, filename)
+            trainer.save_checkpoint(ckpt_path)
+
+        # Logging losses
+        if global_step % self.log_frequency == 0 and global_step != 0:
+            trainer.model.log_current_losses()
+
+        # Image visualization
+        if global_step % self.viz_frequency == 0 and global_step != 0:
+            trainer.model.log_current_visuals()
+
+class Hash(pl.Callback):
+
+    def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx):
+        if batch_idx == 99:
+            print("Hash " + md5(pl_module.state_dict()["netG_B.dec.model.4.conv.weight"].cpu().detach().numpy()).hexdigest())