Add files using upload-large-folder tool

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+competitors_inference_code/DemoFusion/demo.ipynb filter=lfs diff=lfs merge=lfs -text

competitors_inference_code/DemoFusion/demo.ipynb

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

competitors_inference_code/LSRNA/lsr/swinir-liif-latent-sdxl.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0996bf5ea25178efb48537213a09283a890bb17cf88389106814df3e56480747
+size 19779045

competitors_inference_code/LSRNA/lsr_training/README.md

@@ -0,0 +1,9 @@
+## LSR Training
+This directory includes the training code for LSR.
+To prepare training dataset, please refer to the appendix and the code located at ```datasets/scripts/make_trainset.py```.
+Training process can be executed using the script ```dist.sh```.
+
+> **Note:**  
+> Please be aware that the training code is not fully refined and may encounter issues depending on your environment.
+> For instance, the training code currently is only compatible with PyTorch version 1.x.x.
+> Should you run into any problems during training, please open an issue or send an email.

competitors_inference_code/LSRNA/lsr_training/core.py

@@ -0,0 +1,412 @@
+#https://github.com/sanghyun-son/bicubic_pytorch
+import math
+import typing
+
+import torch
+from torch.nn import functional as F
+
+__all__ = ['imresize'] 
+
+_I = typing.Optional[int]
+_D = typing.Optional[torch.dtype]
+
+def nearest_contribution(x: torch.Tensor) -> torch.Tensor:
+    range_around_0 = torch.logical_and(x.gt(-0.5), x.le(0.5))
+    cont = range_around_0.to(dtype=x.dtype)
+    return cont
+
+def linear_contribution(x: torch.Tensor) -> torch.Tensor:
+    ax = x.abs()
+    range_01 = ax.le(1)
+    cont = (1 - ax) * range_01.to(dtype=x.dtype)
+    return cont
+
+def cubic_contribution(x: torch.Tensor, a: float=-0.5) -> torch.Tensor:
+    ax = x.abs()
+    ax2 = ax * ax
+    ax3 = ax * ax2
+
+    range_01 = ax.le(1)
+    range_12 = torch.logical_and(ax.gt(1), ax.le(2))
+
+    cont_01 = (a + 2) * ax3 - (a + 3) * ax2 + 1
+    cont_01 = cont_01 * range_01.to(dtype=x.dtype)
+
+    cont_12 = (a * ax3) - (5 * a * ax2) + (8 * a * ax) - (4 * a)
+    cont_12 = cont_12 * range_12.to(dtype=x.dtype)
+
+    cont = cont_01 + cont_12
+    return cont
+
+def gaussian_contribution(x: torch.Tensor, sigma: float=2.0) -> torch.Tensor:
+    range_3sigma = (x.abs() <= 3 * sigma + 1)
+    # Normalization will be done after
+    cont = torch.exp(-x.pow(2) / (2 * sigma**2))
+    cont = cont * range_3sigma.to(dtype=x.dtype)
+    return cont
+
+def discrete_kernel(
+        kernel: str, scale: float, antialiasing: bool=True) -> torch.Tensor:
+
+    '''
+    For downsampling with integer scale only.
+    '''
+    downsampling_factor = int(1 / scale)
+    if kernel == 'cubic':
+        kernel_size_orig = 4
+    else:
+        raise ValueError('Pass!')
+
+    if antialiasing:
+        kernel_size = kernel_size_orig * downsampling_factor
+    else:
+        kernel_size = kernel_size_orig
+
+    if downsampling_factor % 2 == 0:
+        a = kernel_size_orig * (0.5 - 1 / (2 * kernel_size))
+    else:
+        kernel_size -= 1
+        a = kernel_size_orig * (0.5 - 1 / (kernel_size + 1))
+
+    with torch.no_grad():
+        r = torch.linspace(-a, a, steps=kernel_size)
+        k = cubic_contribution(r).view(-1, 1)
+        k = torch.matmul(k, k.t())
+        k /= k.sum()
+
+    return k
+
+def reflect_padding(
+        x: torch.Tensor,
+        dim: int,
+        pad_pre: int,
+        pad_post: int) -> torch.Tensor:
+
+    '''
+    Apply reflect padding to the given Tensor.
+    Note that it is slightly different from the PyTorch functional.pad,
+    where boundary elements are used only once.
+    Instead, we follow the MATLAB implementation
+    which uses boundary elements twice.
+
+    For example,
+    [a, b, c, d] would become [b, a, b, c, d, c] with the PyTorch implementation,
+    while our implementation yields [a, a, b, c, d, d].
+    '''
+    b, c, h, w = x.size()
+    if dim == 2 or dim == -2:
+        padding_buffer = x.new_zeros(b, c, h + pad_pre + pad_post, w)
+        padding_buffer[..., pad_pre:(h + pad_pre), :].copy_(x)
+        for p in range(pad_pre):
+            padding_buffer[..., pad_pre - p - 1, :].copy_(x[..., p, :])
+        for p in range(pad_post):
+            padding_buffer[..., h + pad_pre + p, :].copy_(x[..., -(p + 1), :])
+    else:
+        padding_buffer = x.new_zeros(b, c, h, w + pad_pre + pad_post)
+        padding_buffer[..., pad_pre:(w + pad_pre)].copy_(x)
+        for p in range(pad_pre):
+            padding_buffer[..., pad_pre - p - 1].copy_(x[..., p])
+        for p in range(pad_post):
+            padding_buffer[..., w + pad_pre + p].copy_(x[..., -(p + 1)])
+
+    return padding_buffer
+
+def padding(
+        x: torch.Tensor,
+        dim: int,
+        pad_pre: int,
+        pad_post: int,
+        padding_type: typing.Optional[str]='reflect') -> torch.Tensor:
+
+    if padding_type is None:
+        return x
+    elif padding_type == 'reflect':
+        x_pad = reflect_padding(x, dim, pad_pre, pad_post)
+    else:
+        raise ValueError('{} padding is not supported!'.format(padding_type))
+
+    return x_pad
+
+def get_padding(
+        base: torch.Tensor,
+        kernel_size: int,
+        x_size: int) -> typing.Tuple[int, int, torch.Tensor]:
+
+    base = base.long()
+    r_min = base.min()
+    r_max = base.max() + kernel_size - 1
+
+    if r_min <= 0:
+        pad_pre = -r_min
+        pad_pre = pad_pre.item()
+        base += pad_pre
+    else:
+        pad_pre = 0
+
+    if r_max >= x_size:
+        pad_post = r_max - x_size + 1
+        pad_post = pad_post.item()
+    else:
+        pad_post = 0
+
+    return pad_pre, pad_post, base
+
+def get_weight(
+        dist: torch.Tensor,
+        kernel_size: int,
+        kernel: str='cubic',
+        sigma: float=2.0,
+        antialiasing_factor: float=1) -> torch.Tensor:
+
+    buffer_pos = dist.new_zeros(kernel_size, len(dist))
+    for idx, buffer_sub in enumerate(buffer_pos):
+        buffer_sub.copy_(dist - idx)
+
+    # Expand (downsampling) / Shrink (upsampling) the receptive field.
+    buffer_pos *= antialiasing_factor
+    if kernel == 'cubic':
+        weight = cubic_contribution(buffer_pos)
+    elif kernel == 'gaussian':
+        weight = gaussian_contribution(buffer_pos, sigma=sigma)
+    else:
+        raise ValueError('{} kernel is not supported!'.format(kernel))
+
+    weight /= weight.sum(dim=0, keepdim=True)
+    return weight
+
+def reshape_tensor(x: torch.Tensor, dim: int, kernel_size: int) -> torch.Tensor:
+    # Resize height
+    if dim == 2 or dim == -2:
+        k = (kernel_size, 1)
+        h_out = x.size(-2) - kernel_size + 1
+        w_out = x.size(-1)
+    # Resize width
+    else:
+        k = (1, kernel_size)
+        h_out = x.size(-2)
+        w_out = x.size(-1) - kernel_size + 1
+
+    unfold = F.unfold(x, k)
+    unfold = unfold.view(unfold.size(0), -1, h_out, w_out)
+    return unfold
+
+def reshape_input(
+        x: torch.Tensor) -> typing.Tuple[torch.Tensor, _I, _I, _I, _I]:
+
+    if x.dim() == 4:
+        b, c, h, w = x.size()
+    elif x.dim() == 3:
+        c, h, w = x.size()
+        b = None
+    elif x.dim() == 2:
+        h, w = x.size()
+        b = c = None
+    else:
+        raise ValueError('{}-dim Tensor is not supported!'.format(x.dim()))
+
+    x = x.view(-1, 1, h, w)
+    return x, b, c, h, w
+
+def reshape_output(
+        x: torch.Tensor, b: _I, c: _I) -> torch.Tensor:
+
+    rh = x.size(-2)
+    rw = x.size(-1)
+    # Back to the original dimension
+    if b is not None:
+        x = x.view(b, c, rh, rw)        # 4-dim
+    else:
+        if c is not None:
+            x = x.view(c, rh, rw)       # 3-dim
+        else:
+            x = x.view(rh, rw)          # 2-dim
+
+    return x
+
+def cast_input(x: torch.Tensor) -> typing.Tuple[torch.Tensor, _D]:
+    if x.dtype != torch.float32 or x.dtype != torch.float64:
+        dtype = x.dtype
+        x = x.float()
+    else:
+        dtype = None
+
+    return x, dtype
+
+def cast_output(x: torch.Tensor, dtype: _D) -> torch.Tensor:
+    if dtype is not None:
+        if not dtype.is_floating_point:
+            x = x.round()
+        # To prevent over/underflow when converting types
+        if dtype is torch.uint8:
+            x = x.clamp(0, 255)
+
+        x = x.to(dtype=dtype)
+
+    return x
+
+def resize_1d(
+        x: torch.Tensor,
+        dim: int,
+        size: typing.Optional[int],
+        scale: typing.Optional[float],
+        kernel: str='cubic',
+        sigma: float=2.0,
+        padding_type: str='reflect',
+        antialiasing: bool=True) -> torch.Tensor:
+
+    '''
+    Args:
+        x (torch.Tensor): A torch.Tensor of dimension (B x C, 1, H, W).
+        dim (int):
+        scale (float):
+        size (int):
+
+    Return:
+    '''
+    # Identity case
+    if scale == 1:
+        return x
+
+    # Default bicubic kernel with antialiasing (only when downsampling)
+    if kernel == 'cubic':
+        kernel_size = 4
+    else:
+        kernel_size = math.floor(6 * sigma)
+
+    if antialiasing and (scale < 1):
+        antialiasing_factor = scale
+        kernel_size = math.ceil(kernel_size / antialiasing_factor)
+    else:
+        antialiasing_factor = 1
+
+    # We allow margin to both sizes
+    kernel_size += 2
+
+    # Weights only depend on the shape of input and output,
+    # so we do not calculate gradients here.
+    with torch.no_grad():
+        pos = torch.linspace(
+            0, size - 1, steps=size, dtype=x.dtype, device=x.device,
+        )
+        pos = (pos + 0.5) / scale - 0.5
+        base = pos.floor() - (kernel_size // 2) + 1
+        dist = pos - base
+        weight = get_weight(
+            dist,
+            kernel_size,
+            kernel=kernel,
+            sigma=sigma,
+            antialiasing_factor=antialiasing_factor,
+        )
+        pad_pre, pad_post, base = get_padding(base, kernel_size, x.size(dim))
+
+    # To backpropagate through x
+    x_pad = padding(x, dim, pad_pre, pad_post, padding_type=padding_type)
+    unfold = reshape_tensor(x_pad, dim, kernel_size)
+    # Subsampling first
+    if dim == 2 or dim == -2:
+        sample = unfold[..., base, :]
+        weight = weight.view(1, kernel_size, sample.size(2), 1)
+    else:
+        sample = unfold[..., base]
+        weight = weight.view(1, kernel_size, 1, sample.size(3))
+
+    # Apply the kernel
+    x = sample * weight
+    x = x.sum(dim=1, keepdim=True)
+    return x
+
+def downsampling_2d(
+        x: torch.Tensor,
+        k: torch.Tensor,
+        scale: int,
+        padding_type: str='reflect') -> torch.Tensor:
+
+    c = x.size(1)
+    k_h = k.size(-2)
+    k_w = k.size(-1)
+
+    k = k.to(dtype=x.dtype, device=x.device)
+    k = k.view(1, 1, k_h, k_w)
+    k = k.repeat(c, c, 1, 1)
+    e = torch.eye(c, dtype=k.dtype, device=k.device, requires_grad=False)
+    e = e.view(c, c, 1, 1)
+    k = k * e
+
+    pad_h = (k_h - scale) // 2
+    pad_w = (k_w - scale) // 2
+    x = padding(x, -2, pad_h, pad_h, padding_type=padding_type)
+    x = padding(x, -1, pad_w, pad_w, padding_type=padding_type)
+    y = F.conv2d(x, k, padding=0, stride=scale)
+    return y
+
+def imresize(
+        x: torch.Tensor,
+        scale: typing.Optional[float]=None,
+        sizes: typing.Optional[typing.Tuple[int, int]]=None,
+        kernel: typing.Union[str, torch.Tensor]='cubic',
+        sigma: float=2,
+        rotation_degree: float=0,
+        padding_type: str='reflect',
+        antialiasing: bool=True) -> torch.Tensor:
+
+    '''
+    Args:
+        x (torch.Tensor):
+        scale (float):
+        sizes (tuple(int, int)):
+        kernel (str, default='cubic'):
+        sigma (float, default=2):
+        rotation_degree (float, default=0):
+        padding_type (str, default='reflect'):
+        antialiasing (bool, default=True):
+
+    Return:
+        torch.Tensor:
+    '''
+
+    if scale is None and sizes is None:
+        raise ValueError('One of scale or sizes must be specified!')
+    if scale is not None and sizes is not None:
+        raise ValueError('Please specify scale or sizes to avoid conflict!')
+
+    x, b, c, h, w = reshape_input(x)
+
+    if sizes is None:
+        '''
+        # Check if we can apply the convolution algorithm
+        scale_inv = 1 / scale
+        if isinstance(kernel, str) and scale_inv.is_integer():
+            kernel = discrete_kernel(kernel, scale, antialiasing=antialiasing)
+        elif isinstance(kernel, torch.Tensor) and not scale_inv.is_integer():
+            raise ValueError(
+                'An integer downsampling factor '
+                'should be used with a predefined kernel!'
+            )
+        '''
+        # Determine output size
+        sizes = (math.ceil(h * scale), math.ceil(w * scale))
+        scales = (scale, scale)
+
+    if scale is None:
+        scales = (sizes[0] / h, sizes[1] / w)
+
+    x, dtype = cast_input(x)
+
+    if isinstance(kernel, str):
+        # Shared keyword arguments across dimensions
+        kwargs = {
+            'kernel': kernel,
+            'sigma': sigma,
+            'padding_type': padding_type,
+            'antialiasing': antialiasing,
+        }
+        # Core resizing module
+        x = resize_1d(x, -2, size=sizes[0], scale=scales[0], **kwargs)
+        x = resize_1d(x, -1, size=sizes[1], scale=scales[1], **kwargs)
+    elif isinstance(kernel, torch.Tensor):
+        x = downsampling_2d(x, kernel, scale=int(1 / scale))
+
+    x = reshape_output(x, b, c)
+    x = cast_output(x, dtype)
+    return x

competitors_inference_code/LSRNA/lsr_training/datasets/__init__.py

@@ -0,0 +1,3 @@
+from .datasets import register, make
+from . import image_folder
+from . import wrappers

competitors_inference_code/LSRNA/lsr_training/datasets/image_folder.py

@@ -0,0 +1,35 @@
+import os
+from PIL import Image
+
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+from torchvision import transforms
+from datasets import register
+from utils.utils_io import *
+
+
+@register('image-folder')
+class ImageFolder(Dataset):
+
+    def __init__(self, hr_path, lr_path, first_k=None, repeat=1, scales=[2,3,4]):
+        self.repeat = repeat
+        self.files = sorted(os.listdir(hr_path))
+        if first_k is not None:
+            self.files = self.files[:first_k]
+        self.hr_path = hr_path
+        self.lr_path = lr_path
+        self.scales = scales
+
+    def __len__(self):
+        return len(self.files) * self.repeat
+
+    def __getitem__(self, idx):
+        filename = self.files[idx % len(self.files)]
+        hr_path = os.path.join(self.hr_path, filename)
+
+        lr_paths = []
+        for scale in self.scales:
+            lr_path = os.path.join(self.lr_path, f'X{scale}', filename)
+            lr_paths.append(lr_path)
+        return hr_path, lr_paths

competitors_inference_code/LSRNA/lsr_training/train.py

@@ -0,0 +1,238 @@
+import warnings
+warnings.filterwarnings("ignore")
+import os, sys
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+from functools import partial
+import argparse
+import yaml
+import builtins
+
+from utils import *
+import datasets
+import models
+from tqdm import tqdm
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from diffusers import StableDiffusionXLPipeline
+
+
+def prepare_training(config, log):
+    resume_path = config['resume_path']
+    resume = os.path.exists(resume_path)
+
+    if resume:
+        sv_file = torch.load(resume_path, map_location=config['map_loc'])
+        iter_start = sv_file['iter']+1
+        if iter_start <= config['iter_max']//100:
+            resume = False
+        else:
+            log('Model resumed from: {} (prev_iter: {})'.format(resume_path, sv_file['iter']))
+            model = models.make(sv_file['model'], load_sd=True).cuda()
+            optimizer, lr_scheduler = make_optim_sched(model.parameters(),
+                sv_file['optimizer'], sv_file['lr_scheduler'], load_sd=True)
+
+    if not resume:
+        if config.get('init_path'):
+            log('Model init from: {}'.format(config['init_path']))
+            sv_file = torch.load(config['init_path'], map_location=config['map_loc'])    
+            model = models.make(sv_file['model'], load_sd=True).cuda()
+        else:
+            log('Loading new model ...')
+            model = models.make(config['model']).cuda()
+        optimizer, lr_scheduler = make_optim_sched(model.parameters(),
+            config['optimizer'], config['lr_scheduler'])
+        iter_start = 1
+    log('#params={}'.format(compute_num_params(model, text=True)))
+
+    # load vae
+    sd_ckpt = config['sd_ckpt']
+    pipeline = StableDiffusionXLPipeline.from_pretrained(sd_ckpt)
+    pipeline.enable_vae_tiling()
+    vae = pipeline.vae.cuda() # eval mode, float32, i/o range [-1,1]
+    return model, optimizer, lr_scheduler, iter_start, vae
+
+
+def make_train_loader(config):
+    spec = config['train_dataset']
+    seed = 0 if not config['seed'] else config['seed']
+    dataset = datasets.make(spec['dataset'])
+    dataset = datasets.make(spec['wrapper'], args={'dataset': dataset})
+
+    assert spec['batch_size'] % config['world_size'] == 0
+    batch_size = spec['batch_size'] // config['world_size']
+    assert spec['num_workers'] % config['world_size'] == 0
+    num_workers = spec['num_workers'] // config['world_size']
+
+    sampler = DistributedSampler(dataset, shuffle=True, seed=seed)
+    data_loader = DataLoader(dataset, batch_size=batch_size, drop_last=True, 
+        shuffle=False, pin_memory=True, num_workers=num_workers, sampler=sampler)
+    return data_loader, sampler
+
+
+def valid(model, config, vae):
+    valid_path = config['valid_path']
+    valid_data_name = config['valid_path'].split('/')[-2]
+    scale = 2 # fixed
+    model.eval()
+    
+    filenames = sorted(os.listdir(valid_path))
+    for filename in tqdm(filenames, leave=True, desc=f'valid (x{scale})'):
+        hr_file = os.path.join(valid_path, filename)
+        hr = np.array(Image.open(hr_file).convert('RGB')) / 255.
+        hr = torch.from_numpy(hr).permute(2,0,1).float().unsqueeze(0).cuda()
+          
+        with torch.no_grad():
+            # crop to divisible size
+            H,W = hr.shape[-2:]
+            H,W = H//8*8, W//8*8
+            hr = hr[:,:H,:W]
+            hr = (hr - 0.5) * 2 # normalize to [-1,1]
+
+            hr_latent = vae.encode(hr).latent_dist.mode() * vae.config.scaling_factor
+            H,W = hr_latent.shape[-2:]
+            H,W = H*scale, W*scale
+
+            coord = make_coord((H,W), flatten=False, device='cuda').unsqueeze(0)
+            cell = torch.ones_like(coord)
+            cell[:,:,:,0] *= 2/H
+            cell[:,:,:,1] *= 2/W
+
+            pred_latent = model(hr_latent, coord, cell)
+            pred = vae.decode(pred_latent / vae.config.scaling_factor, return_dict=False)[0]
+
+            # denormalize
+            pred = pred / 2 + 0.5 
+            hr = hr / 2 + 0.5
+
+        save_dir = os.path.join(config['save_path'], 'valid', valid_data_name, f'X{scale}')
+        os.makedirs(save_dir, exist_ok=True)
+        filename = filename.split('.')[0] # w/o extension
+        Image.fromarray(tensor2numpy(pred)).save(os.path.join(save_dir, f'{filename}_pred.png'))
+        Image.fromarray(tensor2numpy(hr)).save(os.path.join(save_dir, f'{filename}_hr.png'))
+
+
+def main(): 
+    # get options
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', type=str, required=True)
+    parser.add_argument('--launcher', default='pytorch', help='job launcher')
+    parser.add_argument('--local_rank', type=int, default=0)
+    args = parser.parse_args()
+
+    # distributed setting
+    init_dist('pytorch')
+    rank, world_size = get_dist_info()
+
+    # load logger
+    save_path = os.path.join('save', args.config.split('/')[-1][:-len('.yaml')])
+    logger = Logger()
+    logger.set_save_path(save_path, remove=False)
+    if rank > 0: 
+        builtins.print = lambda *args, **kwargs: None
+        logger.disable()
+    log = logger.log
+
+    # load config
+    config = load_config(args.config)
+    config['world_size'] = world_size
+    if config['seed'] is not None:
+        set_seed(config['seed'])
+    if rank == 0:
+        os.makedirs(save_path, exist_ok=True)
+        with open(os.path.join(save_path, 'config.yaml'), 'w') as f:
+            yaml.dump(config, f, sort_keys=False)
+    log('Config loaded: {}'.format(args.config))
+    config['rank'] = rank
+    config['map_loc'] = f'cuda:{rank}'
+
+    # prepare training
+    model, optimizer, lr_scheduler, iter_start, vae = prepare_training(config, log)
+    model = nn.parallel.DistributedDataParallel(model, find_unused_parameters=True)
+    train_loader, train_sampler = make_train_loader(config)
+
+    if rank == 0:
+        assert os.path.exists(config['valid_path'])
+        timer = Timer()
+        train_loss = Averager()
+        t_iter_start = timer.t()
+
+    iter_cur = iter_start
+    iter_max = config['iter_max']
+    iter_print = config['iter_print']
+    iter_val = config['iter_val']
+    iter_save = config['iter_save']
+
+    loss_fn = nn.L1Loss()
+    while True:
+        train_sampler.set_epoch(iter_cur) # instead of epoch
+        for batch in train_loader: # process single iteration
+            for key, value in batch.items():
+                batch[key] = value.cuda()
+            model.train()
+            optimizer.zero_grad()
+
+            hr, lr = batch['hr'], batch['lr']
+            assert hr.shape[1] == lr.shape[1] and hr.shape[1] == 4
+            coord, cell = batch['coord'], batch['cell']
+            pred = model(lr, coord, cell)
+            loss = loss_fn(pred, hr)
+
+            loss.backward()
+            optimizer.step()
+            lr_scheduler.step()
+
+            if rank == 0:
+                train_loss.add(loss.item())
+                cond1 = (iter_cur % iter_print == 0)
+                cond2 = (iter_cur % iter_save == 0)
+                cond3 = (iter_cur % iter_val == 0)
+
+                if cond1 or cond2 or cond3:
+                    model_ = model.module if hasattr(model, 'module') else model
+                    if cond1 or cond2:
+                        # save current model state
+                        model_spec = config['model']
+                        model_spec['sd'] = model_.state_dict()
+                        optimizer_spec = config['optimizer']
+                        optimizer_spec['sd'] = optimizer.state_dict()
+                        lr_scheduler_spec = config['lr_scheduler']
+                        lr_scheduler_spec['sd'] = lr_scheduler.state_dict()
+                        sv_file = {
+                            'model': model_spec,
+                            'optimizer': optimizer_spec,
+                            'lr_scheduler': lr_scheduler_spec,
+                            'iter': iter_cur
+                        }
+                        if cond1:
+                            log_info = ['iter {}/{}'.format(iter_cur, iter_max)]
+                            log_info.append('train: loss={:.4f}'.format(train_loss.item()))
+                            log_info.append('lr: {:.4e}'.format(lr_scheduler.get_last_lr()[0]))
+
+                            t = timer.t()
+                            prog = (iter_cur - iter_start + 1) / (iter_max - iter_start + 1)
+                            t_iter = time_text(t - t_iter_start)
+                            t_elapsed, t_all = time_text(t), time_text(t / prog)
+                            log_info.append('{} {}/{}'.format(t_iter, t_elapsed, t_all))
+                            log(', '.join(log_info))
+                            train_loss = Averager()
+                            t_iter_start = timer.t()
+                            torch.save(sv_file, os.path.join(config['save_path'], 'iter_last.pth'))
+                        if cond2:
+                            torch.save(sv_file, os.path.join(config['save_path'], 'iter_{}.pth'.format(iter_cur)))
+                    if cond3: # validation
+                        valid(model_, config, vae=vae)
+
+
+            if iter_cur == iter_max:
+                log('Finish training.')
+                return
+            iter_cur += 1
+
+if __name__ == '__main__':
+    main()