Add application file

app.py

@@ -0,0 +1,82 @@
+import numpy as np
+import torch
+import gradio as gr
+from PIL import Image
+from net.CIDNet import CIDNet
+import torchvision.transforms as transforms
+import torch.nn.functional as F
+import os
+import imquality.brisque as brisque
+from loss.niqe_utils import *
+
+eval_net = CIDNet()
+eval_net.trans.gated = True
+eval_net.trans.gated2 = True
+
+def process_image(input_img,score,model_path,gamma,alpha_s=1.0,alpha_i=1.0):
+    torch.set_grad_enabled(False)
+    eval_net.load_state_dict(torch.load(os.path.join(directory,model_path), map_location=lambda storage, loc: storage))
+    eval_net.eval()
+    
+    pil2tensor = transforms.Compose([transforms.ToTensor()])
+    input = pil2tensor(input_img)
+    factor = 8
+    h, w = input.shape[1], input.shape[2]
+    H, W = ((h + factor) // factor) * factor, ((w + factor) // factor) * factor
+    padh = H - h if h % factor != 0 else 0
+    padw = W - w if w % factor != 0 else 0
+    input = F.pad(input.unsqueeze(0), (0,padw,0,padh), 'reflect')
+    with torch.no_grad():
+        eval_net.trans.alpha_s = alpha_s
+        eval_net.trans.alpha = alpha_i
+        output = eval_net(input**gamma)
+    output = torch.clamp(output,0,1)
+    output = output[:, :, :h, :w]
+    enhanced_img = transforms.ToPILImage()(output.squeeze(0))
+    if score == 'Yes':
+        im1 = enhanced_img.convert('RGB')
+        score_brisque = brisque.score(im1) 
+        im1 = np.array(im1)
+        score_niqe = calculate_niqe(im1)
+        return enhanced_img,score_niqe,score_brisque
+    else:
+        return enhanced_img,0,0
+
+def find_pth_files(directory):
+    pth_files = []
+    for root, dirs, files in os.walk(directory):
+        if 'train' in root.split(os.sep):
+            continue
+        for file in files:
+            if file.endswith('.pth'):
+                pth_files.append(os.path.join(root, file))
+    return pth_files
+
+def remove_weights_prefix(paths):
+    cleaned_paths = [path.replace('.\\weights\\', '') for path in paths]
+    return cleaned_paths
+
+directory = ".\weights"
+pth_files = find_pth_files(directory)
+pth_files2 = remove_weights_prefix(pth_files)
+
+interface = gr.Interface(
+    fn=process_image,
+    inputs=[
+        gr.Image(label="Low-light Image", type="pil"),
+        gr.Radio(choices=['Yes','No'],label="Image Score"),
+        gr.Radio(choices=pth_files2,label="Model Path"),
+        gr.Slider(0.1,10,label="gamma curve",step=0.01,value=1.0),
+        gr.Slider(0,2,label="Alpha-s",step=0.01,value=1.0),
+        gr.Slider(0.1,2,label="Alpha-i",step=0.01,value=1.0)
+    ],
+    outputs=[
+        gr.Image(label="Result", type="pil"),
+        gr.Textbox(label="NIQE"),
+        gr.Textbox(label="BRISQUE")
+    ],
+    title="HVI-CIDNet (Low-Light Image Enhancement)",
+    allow_flagging="never"
+)
+
+interface.launch(server_port=7862)

loss/niqe_pris_params.npz

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

loss/niqe_utils.py

@@ -0,0 +1,559 @@
+
+import cv2
+import math
+import numpy as np
+from scipy.ndimage import convolve
+from scipy.special import gamma
+import torch
+
+def cubic(x):
+    """cubic function used for calculate_weights_indices."""
+    absx = torch.abs(x)
+    absx2 = absx**2
+    absx3 = absx**3
+    return (1.5 * absx3 - 2.5 * absx2 + 1) * (
+        (absx <= 1).type_as(absx)) + (-0.5 * absx3 + 2.5 * absx2 - 4 * absx + 2) * (((absx > 1) *
+                                                                                     (absx <= 2)).type_as(absx))
+
+
+
+def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing):
+    """Calculate weights and indices, used for imresize function.
+    Args:
+        in_length (int): Input length.
+        out_length (int): Output length.
+        scale (float): Scale factor.
+        kernel_width (int): Kernel width.
+        antialisaing (bool): Whether to apply anti-aliasing when downsampling.
+    """
+
+    if (scale < 1) and antialiasing:
+        # Use a modified kernel (larger kernel width) to simultaneously
+        # interpolate and antialias
+        kernel_width = kernel_width / scale
+
+    # Output-space coordinates
+    x = torch.linspace(1, out_length, out_length)
+
+    # Input-space coordinates. Calculate the inverse mapping such that 0.5
+    # in output space maps to 0.5 in input space, and 0.5 + scale in output
+    # space maps to 1.5 in input space.
+    u = x / scale + 0.5 * (1 - 1 / scale)
+
+    # What is the left-most pixel that can be involved in the computation?
+    left = torch.floor(u - kernel_width / 2)
+
+    # What is the maximum number of pixels that can be involved in the
+    # computation?  Note: it's OK to use an extra pixel here; if the
+    # corresponding weights are all zero, it will be eliminated at the end
+    # of this function.
+    p = math.ceil(kernel_width) + 2
+
+    # The indices of the input pixels involved in computing the k-th output
+    # pixel are in row k of the indices matrix.
+    indices = left.view(out_length, 1).expand(out_length, p) + torch.linspace(0, p - 1, p).view(1, p).expand(
+        out_length, p)
+
+    # The weights used to compute the k-th output pixel are in row k of the
+    # weights matrix.
+    distance_to_center = u.view(out_length, 1).expand(out_length, p) - indices
+
+    # apply cubic kernel
+    if (scale < 1) and antialiasing:
+        weights = scale * cubic(distance_to_center * scale)
+    else:
+        weights = cubic(distance_to_center)
+
+    # Normalize the weights matrix so that each row sums to 1.
+    weights_sum = torch.sum(weights, 1).view(out_length, 1)
+    weights = weights / weights_sum.expand(out_length, p)
+
+    # If a column in weights is all zero, get rid of it. only consider the
+    # first and last column.
+    weights_zero_tmp = torch.sum((weights == 0), 0)
+    if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6):
+        indices = indices.narrow(1, 1, p - 2)
+        weights = weights.narrow(1, 1, p - 2)
+    if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6):
+        indices = indices.narrow(1, 0, p - 2)
+        weights = weights.narrow(1, 0, p - 2)
+    weights = weights.contiguous()
+    indices = indices.contiguous()
+    sym_len_s = -indices.min() + 1
+    sym_len_e = indices.max() - in_length
+    indices = indices + sym_len_s - 1
+    return weights, indices, int(sym_len_s), int(sym_len_e)
+
+def imresize(img, scale, antialiasing=True):
+    """imresize function same as MATLAB.
+    It now only supports bicubic.
+    The same scale applies for both height and width.
+    Args:
+        img (Tensor | Numpy array):
+            Tensor: Input image with shape (c, h, w), [0, 1] range.
+            Numpy: Input image with shape (h, w, c), [0, 1] range.
+        scale (float): Scale factor. The same scale applies for both height
+            and width.
+        antialisaing (bool): Whether to apply anti-aliasing when downsampling.
+            Default: True.
+    Returns:
+        Tensor: Output image with shape (c, h, w), [0, 1] range, w/o round.
+    """
+    squeeze_flag = False
+    if type(img).__module__ == np.__name__:  # numpy type
+        numpy_type = True
+        if img.ndim == 2:
+            img = img[:, :, None]
+            squeeze_flag = True
+        img = torch.from_numpy(img.transpose(2, 0, 1)).float()
+    else:
+        numpy_type = False
+        if img.ndim == 2:
+            img = img.unsqueeze(0)
+            squeeze_flag = True
+
+    in_c, in_h, in_w = img.size()
+    out_h, out_w = math.ceil(in_h * scale), math.ceil(in_w * scale)
+    kernel_width = 4
+    kernel = 'cubic'
+
+    # get weights and indices
+    weights_h, indices_h, sym_len_hs, sym_len_he = calculate_weights_indices(in_h, out_h, scale, kernel, kernel_width,
+                                                                             antialiasing)
+    weights_w, indices_w, sym_len_ws, sym_len_we = calculate_weights_indices(in_w, out_w, scale, kernel, kernel_width,
+                                                                             antialiasing)
+    # process H dimension
+    # symmetric copying
+    img_aug = torch.FloatTensor(in_c, in_h + sym_len_hs + sym_len_he, in_w)
+    img_aug.narrow(1, sym_len_hs, in_h).copy_(img)
+
+    sym_patch = img[:, :sym_len_hs, :]
+    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(1, inv_idx)
+    img_aug.narrow(1, 0, sym_len_hs).copy_(sym_patch_inv)
+
+    sym_patch = img[:, -sym_len_he:, :]
+    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(1, inv_idx)
+    img_aug.narrow(1, sym_len_hs + in_h, sym_len_he).copy_(sym_patch_inv)
+
+    out_1 = torch.FloatTensor(in_c, out_h, in_w)
+    kernel_width = weights_h.size(1)
+    for i in range(out_h):
+        idx = int(indices_h[i][0])
+        for j in range(in_c):
+            out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_h[i])
+
+    # process W dimension
+    # symmetric copying
+    out_1_aug = torch.FloatTensor(in_c, out_h, in_w + sym_len_ws + sym_len_we)
+    out_1_aug.narrow(2, sym_len_ws, in_w).copy_(out_1)
+
+    sym_patch = out_1[:, :, :sym_len_ws]
+    inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(2, inv_idx)
+    out_1_aug.narrow(2, 0, sym_len_ws).copy_(sym_patch_inv)
+
+    sym_patch = out_1[:, :, -sym_len_we:]
+    inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
+    sym_patch_inv = sym_patch.index_select(2, inv_idx)
+    out_1_aug.narrow(2, sym_len_ws + in_w, sym_len_we).copy_(sym_patch_inv)
+
+    out_2 = torch.FloatTensor(in_c, out_h, out_w)
+    kernel_width = weights_w.size(1)
+    for i in range(out_w):
+        idx = int(indices_w[i][0])
+        for j in range(in_c):
+            out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_w[i])
+
+    if squeeze_flag:
+        out_2 = out_2.squeeze(0)
+    if numpy_type:
+        out_2 = out_2.numpy()
+        if not squeeze_flag:
+            out_2 = out_2.transpose(1, 2, 0)
+
+    return out_2
+
+
+def _convert_input_type_range(img):
+    """Convert the type and range of the input image.
+    It converts the input image to np.float32 type and range of [0, 1].
+    It is mainly used for pre-processing the input image in colorspace
+    conversion functions such as rgb2ycbcr and ycbcr2rgb.
+    Args:
+        img (ndarray): The input image. It accepts:
+            1. np.uint8 type with range [0, 255];
+            2. np.float32 type with range [0, 1].
+    Returns:
+        (ndarray): The converted image with type of np.float32 and range of
+            [0, 1].
+    """
+    img_type = img.dtype
+    img = img.astype(np.float32)
+    if img_type == np.float32:
+        pass
+    elif img_type == np.uint8:
+        img /= 255.
+    else:
+        raise TypeError(f'The img type should be np.float32 or np.uint8, but got {img_type}')
+    return img
+
+
+def _convert_output_type_range(img, dst_type):
+    """Convert the type and range of the image according to dst_type.
+    It converts the image to desired type and range. If `dst_type` is np.uint8,
+    images will be converted to np.uint8 type with range [0, 255]. If
+    `dst_type` is np.float32, it converts the image to np.float32 type with
+    range [0, 1].
+    It is mainly used for post-processing images in colorspace conversion
+    functions such as rgb2ycbcr and ycbcr2rgb.
+    Args:
+        img (ndarray): The image to be converted with np.float32 type and
+            range [0, 255].
+        dst_type (np.uint8 | np.float32): If dst_type is np.uint8, it
+            converts the image to np.uint8 type with range [0, 255]. If
+            dst_type is np.float32, it converts the image to np.float32 type
+            with range [0, 1].
+    Returns:
+        (ndarray): The converted image with desired type and range.
+    """
+    if dst_type not in (np.uint8, np.float32):
+        raise TypeError(f'The dst_type should be np.float32 or np.uint8, but got {dst_type}')
+    if dst_type == np.uint8:
+        img = img.round()
+    else:
+        img /= 255.
+    return img.astype(dst_type)
+
+
+
+def rgb2ycbcr(img, y_only=False):
+    """Convert a RGB image to YCbCr image.
+    This function produces the same results as Matlab's `rgb2ycbcr` function.
+    It implements the ITU-R BT.601 conversion for standard-definition
+    television. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
+    It differs from a similar function in cv2.cvtColor: `RGB <-> YCrCb`.
+    In OpenCV, it implements a JPEG conversion. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
+    Args:
+        img (ndarray): The input image. It accepts:
+            1. np.uint8 type with range [0, 255];
+            2. np.float32 type with range [0, 1].
+        y_only (bool): Whether to only return Y channel. Default: False.
+    Returns:
+        ndarray: The converted YCbCr image. The output image has the same type
+            and range as input image.
+    """
+    img_type = img.dtype
+    img = _convert_input_type_range(img)
+    if y_only:
+        out_img = np.dot(img, [65.481, 128.553, 24.966]) + 16.0
+    else:
+        out_img = np.matmul(
+            img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786], [24.966, 112.0, -18.214]]) + [16, 128, 128]
+    out_img = _convert_output_type_range(out_img, img_type)
+    return out_img
+
+
+def bgr2ycbcr(img, y_only=False):
+    """Convert a BGR image to YCbCr image.
+    The bgr version of rgb2ycbcr.
+    It implements the ITU-R BT.601 conversion for standard-definition
+    television. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
+    It differs from a similar function in cv2.cvtColor: `BGR <-> YCrCb`.
+    In OpenCV, it implements a JPEG conversion. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
+    Args:
+        img (ndarray): The input image. It accepts:
+            1. np.uint8 type with range [0, 255];
+            2. np.float32 type with range [0, 1].
+        y_only (bool): Whether to only return Y channel. Default: False.
+    Returns:
+        ndarray: The converted YCbCr image. The output image has the same type
+            and range as input image.
+    """
+    img_type = img.dtype
+    img = _convert_input_type_range(img)
+    if y_only:
+        out_img = np.dot(img, [24.966, 128.553, 65.481]) + 16.0
+    else:
+        out_img = np.matmul(
+            img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786], [65.481, -37.797, 112.0]]) + [16, 128, 128]
+    out_img = _convert_output_type_range(out_img, img_type)
+    return out_img
+
+def ycbcr2rgb(img):
+    """Convert a YCbCr image to RGB image.
+    This function produces the same results as Matlab's ycbcr2rgb function.
+    It implements the ITU-R BT.601 conversion for standard-definition
+    television. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
+    It differs from a similar function in cv2.cvtColor: `YCrCb <-> RGB`.
+    In OpenCV, it implements a JPEG conversion. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
+    Args:
+        img (ndarray): The input image. It accepts:
+            1. np.uint8 type with range [0, 255];
+            2. np.float32 type with range [0, 1].
+    Returns:
+        ndarray: The converted RGB image. The output image has the same type
+            and range as input image.
+    """
+    img_type = img.dtype
+    img = _convert_input_type_range(img) * 255
+    out_img = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071],
+                              [0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836]  # noqa: E126
+    out_img = _convert_output_type_range(out_img, img_type)
+    return out_img
+
+
+def to_y_channel(img):
+    """Change to Y channel of YCbCr.
+    Args:
+        img (ndarray): Images with range [0, 255].
+    Returns:
+        (ndarray): Images with range [0, 255] (float type) without round.
+    """
+    img = img.astype(np.float32) / 255.
+    if img.ndim == 3 and img.shape[2] == 3:
+        img = bgr2ycbcr(img, y_only=True)
+        img = img[..., None]
+    return img * 255.
+
+
+def reorder_image(img, input_order='HWC'):
+    """Reorder images to 'HWC' order.
+    If the input_order is (h, w), return (h, w, 1);
+    If the input_order is (c, h, w), return (h, w, c);
+    If the input_order is (h, w, c), return as it is.
+    Args:
+        img (ndarray): Input image.
+        input_order (str): Whether the input order is 'HWC' or 'CHW'.
+            If the input image shape is (h, w), input_order will not have
+            effects. Default: 'HWC'.
+    Returns:
+        ndarray: reordered image.
+    """
+
+    if input_order not in ['HWC', 'CHW']:
+        raise ValueError(f"Wrong input_order {input_order}. Supported input_orders are 'HWC' and 'CHW'")
+    if len(img.shape) == 2:
+        img = img[..., None]
+    if input_order == 'CHW':
+        img = img.transpose(1, 2, 0)
+    return img
+
+def rgb2ycbcr_pt(img, y_only=False):
+    """Convert RGB images to YCbCr images (PyTorch version).
+    It implements the ITU-R BT.601 conversion for standard-definition television. See more details in
+    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
+    Args:
+        img (Tensor): Images with shape (n, 3, h, w), the range [0, 1], float, RGB format.
+         y_only (bool): Whether to only return Y channel. Default: False.
+    Returns:
+        (Tensor): converted images with the shape (n, 3/1, h, w), the range [0, 1], float.
+    """
+    if y_only:
+        weight = torch.tensor([[65.481], [128.553], [24.966]]).to(img)
+        out_img = torch.matmul(img.permute(0, 2, 3, 1), weight).permute(0, 3, 1, 2) + 16.0
+    else:
+        weight = torch.tensor([[65.481, -37.797, 112.0], [128.553, -74.203, -93.786], [24.966, 112.0, -18.214]]).to(img)
+        bias = torch.tensor([16, 128, 128]).view(1, 3, 1, 1).to(img)
+        out_img = torch.matmul(img.permute(0, 2, 3, 1), weight).permute(0, 3, 1, 2) + bias
+
+    out_img = out_img / 255.
+    return
+
+def tensor2img(tensor):
+    im = (255. * tensor).data.cpu().numpy()
+    # clamp
+    im[im > 255] = 255
+    im[im < 0] = 0
+    im = im.astype(np.uint8)
+    return im
+
+def img2tensor(img):
+    img = (img / 255.).astype('float32')
+    if img.ndim ==2:
+        img = np.expand_dims(np.expand_dims(img, axis = 0),axis=0)
+    else:
+        img = np.transpose(img, (2, 0, 1))  # C, H, W
+        img = np.expand_dims(img, axis=0)
+    img = np.ascontiguousarray(img, dtype=np.float32)
+    tensor = torch.from_numpy(img)
+    return tensor
+
+def estimate_aggd_param(block):
+    """Estimate AGGD (Asymmetric Generalized Gaussian Distribution) parameters.
+    Args:
+        block (ndarray): 2D Image block.
+    Returns:
+        tuple: alpha (float), beta_l (float) and beta_r (float) for the AGGD
+            distribution (Estimating the parames in Equation 7 in the paper).
+    """
+    block = block.flatten()
+    gam = np.arange(0.2, 10.001, 0.001)  # len = 9801
+    gam_reciprocal = np.reciprocal(gam)
+    r_gam = np.square(gamma(gam_reciprocal * 2)) / (gamma(gam_reciprocal) * gamma(gam_reciprocal * 3))
+
+    left_std = np.sqrt(np.mean(block[block < 0]**2))
+    right_std = np.sqrt(np.mean(block[block > 0]**2))
+    gammahat = left_std / right_std
+    rhat = (np.mean(np.abs(block)))**2 / np.mean(block**2)
+    rhatnorm = (rhat * (gammahat**3 + 1) * (gammahat + 1)) / ((gammahat**2 + 1)**2)
+    array_position = np.argmin((r_gam - rhatnorm)**2)
+
+    alpha = gam[array_position]
+    beta_l = left_std * np.sqrt(gamma(1 / alpha) / gamma(3 / alpha))
+    beta_r = right_std * np.sqrt(gamma(1 / alpha) / gamma(3 / alpha))
+    return (alpha, beta_l, beta_r)
+
+
+def compute_feature(block):
+    """Compute features.
+    Args:
+        block (ndarray): 2D Image block.
+    Returns:
+        list: Features with length of 18.
+    """
+    feat = []
+    alpha, beta_l, beta_r = estimate_aggd_param(block)
+    feat.extend([alpha, (beta_l + beta_r) / 2])
+
+    # distortions disturb the fairly regular structure of natural images.
+    # This deviation can be captured by analyzing the sample distribution of
+    # the products of pairs of adjacent coefficients computed along
+    # horizontal, vertical and diagonal orientations.
+    shifts = [[0, 1], [1, 0], [1, 1], [1, -1]]
+    for i in range(len(shifts)):
+        shifted_block = np.roll(block, shifts[i], axis=(0, 1))
+        alpha, beta_l, beta_r = estimate_aggd_param(block * shifted_block)
+        # Eq. 8
+        mean = (beta_r - beta_l) * (gamma(2 / alpha) / gamma(1 / alpha))
+        feat.extend([alpha, mean, beta_l, beta_r])
+    return feat
+
+
+def niqe(img, mu_pris_param, cov_pris_param, gaussian_window, block_size_h=96, block_size_w=96):
+    """Calculate NIQE (Natural Image Quality Evaluator) metric.
+    ``Paper: Making a "Completely Blind" Image Quality Analyzer``
+    This implementation could produce almost the same results as the official
+    MATLAB codes: http://live.ece.utexas.edu/research/quality/niqe_release.zip
+    Note that we do not include block overlap height and width, since they are
+    always 0 in the official implementation.
+    For good performance, it is advisable by the official implementation to
+    divide the distorted image in to the same size patched as used for the
+    construction of multivariate Gaussian model.
+    Args:
+        img (ndarray): Input image whose quality needs to be computed. The
+            image must be a gray or Y (of YCbCr) image with shape (h, w).
+            Range [0, 255] with float type.
+        mu_pris_param (ndarray): Mean of a pre-defined multivariate Gaussian
+            model calculated on the pristine dataset.
+        cov_pris_param (ndarray): Covariance of a pre-defined multivariate
+            Gaussian model calculated on the pristine dataset.
+        gaussian_window (ndarray): A 7x7 Gaussian window used for smoothing the
+            image.
+        block_size_h (int): Height of the blocks in to which image is divided.
+            Default: 96 (the official recommended value).
+        block_size_w (int): Width of the blocks in to which image is divided.
+            Default: 96 (the official recommended value).
+    """
+    assert img.ndim == 2, ('Input image must be a gray or Y (of YCbCr) image with shape (h, w).')
+    # crop image
+    h, w = img.shape
+    num_block_h = math.floor(h / block_size_h)
+    num_block_w = math.floor(w / block_size_w)
+    img = img[0:num_block_h * block_size_h, 0:num_block_w * block_size_w]
+
+    distparam = []  # dist param is actually the multiscale features
+    for scale in (1, 2):  # perform on two scales (1, 2)
+        mu = convolve(img, gaussian_window, mode='nearest')
+        sigma = np.sqrt(np.abs(convolve(np.square(img), gaussian_window, mode='nearest') - np.square(mu)))
+        # normalize, as in Eq. 1 in the paper
+        img_nomalized = (img - mu) / (sigma + 1)
+
+        feat = []
+        for idx_w in range(num_block_w):
+            for idx_h in range(num_block_h):
+                # process ecah block
+                block = img_nomalized[idx_h * block_size_h // scale:(idx_h + 1) * block_size_h // scale,
+                                      idx_w * block_size_w // scale:(idx_w + 1) * block_size_w // scale]
+                feat.append(compute_feature(block))
+
+        distparam.append(np.array(feat))
+
+        if scale == 1:
+            img = imresize(img / 255., scale=0.5, antialiasing=True)
+            img = img * 255.
+
+    distparam = np.concatenate(distparam, axis=1)
+
+    # fit a MVG (multivariate Gaussian) model to distorted patch features
+    mu_distparam = np.nanmean(distparam, axis=0)
+    # use nancov. ref: https://ww2.mathworks.cn/help/stats/nancov.html
+    distparam_no_nan = distparam[~np.isnan(distparam).any(axis=1)]
+    cov_distparam = np.cov(distparam_no_nan, rowvar=False)
+
+    # compute niqe quality, Eq. 10 in the paper
+    invcov_param = np.linalg.pinv((cov_pris_param + cov_distparam) / 2)
+    quality = np.matmul(
+        np.matmul((mu_pris_param - mu_distparam), invcov_param), np.transpose((mu_pris_param - mu_distparam)))
+
+    quality = np.sqrt(quality)
+    quality = float(np.squeeze(quality))
+    return quality
+
+
+def calculate_niqe(img, crop_border=0,input_order='HWC', convert_to='y', **kwargs):
+    """Calculate NIQE (Natural Image Quality Evaluator) metric.
+    ``Paper: Making a "Completely Blind" Image Quality Analyzer``
+    This implementation could produce almost the same results as the official
+    MATLAB codes: http://live.ece.utexas.edu/research/quality/niqe_release.zip
+    > MATLAB R2021a result for tests/data/baboon.png: 5.72957338 (5.7296)
+    > Our re-implementation result for tests/data/baboon.png: 5.7295763 (5.7296)
+    We use the official params estimated from the pristine dataset.
+    We use the recommended block size (96, 96) without overlaps.
+    Args:
+        img (ndarray): Input image whose quality needs to be computed.
+            The input image must be in range [0, 255] with float/int type.
+            The input_order of image can be 'HW' or 'HWC' or 'CHW'. (BGR order)
+            If the input order is 'HWC' or 'CHW', it will be converted to gray
+            or Y (of YCbCr) image according to the ``convert_to`` argument.
+        crop_border (int): Cropped pixels in each edge of an image. These
+            pixels are not involved in the metric calculation.
+        input_order (str): Whether the input order is 'HW', 'HWC' or 'CHW'.
+            Default: 'HWC'.
+        convert_to (str): Whether converted to 'y' (of MATLAB YCbCr) or 'gray'.
+            Default: 'y'.
+    Returns:
+        float: NIQE result.
+    """
+    # ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
+    # we use the official params estimated from the pristine dataset.
+    niqe_pris_params = np.load('./loss/niqe_pris_params.npz')
+    mu_pris_param = niqe_pris_params['mu_pris_param']
+    cov_pris_param = niqe_pris_params['cov_pris_param']
+    gaussian_window = niqe_pris_params['gaussian_window']
+
+    img = img.astype(np.float32)
+    if input_order != 'HW':
+        img = reorder_image(img, input_order=input_order)
+        if convert_to == 'y':
+            img = to_y_channel(img)
+        elif convert_to == 'gray':
+            img = cv2.cvtColor(img / 255., cv2.COLOR_BGR2GRAY) * 255.
+        img = np.squeeze(img)
+
+    if crop_border != 0:
+        img = img[crop_border:-crop_border, crop_border:-crop_border]
+
+    # round is necessary for being consistent with MATLAB's result
+    img = img.round()
+
+    niqe_result = niqe(img, mu_pris_param, cov_pris_param, gaussian_window)
+
+    return niqe_result

net/CIDNet.py

@@ -0,0 +1,130 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops import rearrange
+from net.HVI_transform import RGB_HVI
+from net.transformer_utils import *
+from net.LCA import *
+
+class CIDNet(nn.Module):
+    def __init__(self, 
+                 channels=[36, 36, 72, 144],
+                 heads=[1, 2, 4, 8],
+                 norm=False
+        ):
+        super(CIDNet, self).__init__()
+        
+        
+        [ch1, ch2, ch3, ch4] = channels
+        [head1, head2, head3, head4] = heads
+        
+        # HV_ways
+        self.HVE_block0 = nn.Sequential(
+            nn.ReplicationPad2d(1),
+            nn.Conv2d(3, ch1, 3, stride=1, padding=0,bias=False)
+            )
+        self.HVE_block1 = NormDownsample(ch1, ch2, use_norm = norm)
+        self.HVE_block2 = NormDownsample(ch2, ch3, use_norm = norm)
+        self.HVE_block3 = NormDownsample(ch3, ch4, use_norm = norm)
+        
+        self.HVD_block3 = NormUpsample(ch4, ch3, use_norm = norm)
+        self.HVD_block2 = NormUpsample(ch3, ch2, use_norm = norm)
+        self.HVD_block1 = NormUpsample(ch2, ch1, use_norm = norm)
+        self.HVD_block0 = nn.Sequential(
+            nn.ReplicationPad2d(1),
+            nn.Conv2d(ch1, 2, 3, stride=1, padding=0,bias=False)
+        )
+        
+        
+        # I_ways
+        self.IE_block0 = nn.Sequential(
+            nn.ReplicationPad2d(1),
+            nn.Conv2d(1, ch1, 3, stride=1, padding=0,bias=False),
+            )
+        self.IE_block1 = NormDownsample(ch1, ch2, use_norm = norm)
+        self.IE_block2 = NormDownsample(ch2, ch3, use_norm = norm)
+        self.IE_block3 = NormDownsample(ch3, ch4, use_norm = norm)
+        
+        self.ID_block3 = NormUpsample(ch4, ch3, use_norm=norm)
+        self.ID_block2 = NormUpsample(ch3, ch2, use_norm=norm)
+        self.ID_block1 = NormUpsample(ch2, ch1, use_norm=norm)
+        self.ID_block0 =  nn.Sequential(
+            nn.ReplicationPad2d(1),
+            nn.Conv2d(ch1, 1, 3, stride=1, padding=0,bias=False),
+            )
+        
+        self.HV_LCA1 = HV_LCA(ch2, head2)
+        self.HV_LCA2 = HV_LCA(ch3, head3)
+        self.HV_LCA3 = HV_LCA(ch4, head4)
+        self.HV_LCA4 = HV_LCA(ch4, head4)
+        self.HV_LCA5 = HV_LCA(ch3, head3)
+        self.HV_LCA6 = HV_LCA(ch2, head2)
+        
+        self.I_LCA1 = I_LCA(ch2, head2)
+        self.I_LCA2 = I_LCA(ch3, head3)
+        self.I_LCA3 = I_LCA(ch4, head4)
+        self.I_LCA4 = I_LCA(ch4, head4)
+        self.I_LCA5 = I_LCA(ch3, head3)
+        self.I_LCA6 = I_LCA(ch2, head2)
+        
+        self.trans = RGB_HVI().cuda()
+        
+    def forward(self, x):
+        dtypes = x.dtype
+        hvi = self.trans.HVIT(x)
+        i = hvi[:,2,:,:].unsqueeze(1).to(dtypes)
+        # low
+        i_enc0 = self.IE_block0(i)
+        i_enc1 = self.IE_block1(i_enc0)
+        hv_0 = self.HVE_block0(hvi)
+        hv_1 = self.HVE_block1(hv_0)
+        i_jump0 = i_enc0
+        hv_jump0 = hv_0
+        
+        i_enc2 = self.I_LCA1(i_enc1, hv_1)
+        hv_2 = self.HV_LCA1(hv_1, i_enc1)
+        v_jump1 = i_enc2
+        hv_jump1 = hv_2
+        i_enc2 = self.IE_block2(i_enc2)
+        hv_2 = self.HVE_block2(hv_2)
+        
+        i_enc3 = self.I_LCA2(i_enc2, hv_2)
+        hv_3 = self.HV_LCA2(hv_2, i_enc2)
+        v_jump2 = i_enc3
+        hv_jump2 = hv_3
+        i_enc3 = self.IE_block3(i_enc2)
+        hv_3 = self.HVE_block3(hv_2)
+        
+        i_enc4 = self.I_LCA3(i_enc3, hv_3)
+        hv_4 = self.HV_LCA3(hv_3, i_enc3)
+        
+        i_dec4 = self.I_LCA4(i_enc4,hv_4)
+        hv_4 = self.HV_LCA4(hv_4, i_enc4)
+        
+        hv_3 = self.HVD_block3(hv_4, hv_jump2)
+        i_dec3 = self.ID_block3(i_dec4, v_jump2)
+        i_dec2 = self.I_LCA5(i_dec3, hv_3)
+        hv_2 = self.HV_LCA5(hv_3, i_dec3)
+        
+        hv_2 = self.HVD_block2(hv_2, hv_jump1)
+        i_dec2 = self.ID_block2(i_dec3, v_jump1)
+        
+        i_dec1 = self.I_LCA6(i_dec2, hv_2)
+        hv_1 = self.HV_LCA6(hv_2, i_dec2)
+        
+        i_dec1 = self.ID_block1(i_dec1, i_jump0)
+        i_dec0 = self.ID_block0(i_dec1)
+        hv_1 = self.HVD_block1(hv_1, hv_jump0)
+        hv_0 = self.HVD_block0(hv_1)
+        
+        output_hvi = torch.cat([hv_0, i_dec0], dim=1) + hvi
+        output_rgb = self.trans.PHVIT(output_hvi)
+
+        return output_rgb
+    
+    def HVIT(self,x):
+        hvi = self.trans.HVIT(x)
+        return hvi
+    
+    
+

net/HVI_transform.py

@@ -0,0 +1,122 @@
+import torch
+import torch.nn as nn
+
+pi = 3.141592653589793
+
+class RGB_HVI(nn.Module):
+    def __init__(self):
+        super(RGB_HVI, self).__init__()
+        self.density_k = torch.nn.Parameter(torch.full([1],0.2)) # k is reciprocal to the paper mentioned
+        self.gated = False
+        self.gated2= False
+        self.alpha = 1.0
+        self.alpha_s = 1.3
+        self.this_k = 0
+        
+    def HVIT(self, img):
+        eps = 1e-8
+        device = img.device
+        dtypes = img.dtype
+        hue = torch.Tensor(img.shape[0], img.shape[2], img.shape[3]).to(device).to(dtypes)
+        value = img.max(1)[0].to(dtypes)
+        img_min = img.min(1)[0].to(dtypes)
+        hue[img[:,2]==value] = 4.0 + ( (img[:,0]-img[:,1]) / (value - img_min + eps)) [img[:,2]==value]
+        hue[img[:,1]==value] = 2.0 + ( (img[:,2]-img[:,0]) / (value - img_min + eps)) [img[:,1]==value]
+        hue[img[:,0]==value] = (0.0 + ((img[:,1]-img[:,2]) / (value - img_min + eps)) [img[:,0]==value]) % 6
+
+        hue[img.min(1)[0]==value] = 0.0
+        hue = hue/6.0
+
+        saturation = (value - img_min ) / (value + eps )
+        saturation[value==0] = 0
+
+        hue = hue.unsqueeze(1)
+        saturation = saturation.unsqueeze(1)
+        value = value.unsqueeze(1)
+        
+        k = self.density_k
+        self.this_k = k.item()
+        
+        color_sensitive = ((value * 0.5 * pi).sin() + eps).pow(k)
+        ch = (2.0 * pi * hue).cos()
+        cv = (2.0 * pi * hue).sin()
+        H = color_sensitive * saturation * ch
+        V = color_sensitive * saturation * cv
+        I = value
+        xyz = torch.cat([H, V, I],dim=1)
+        return xyz
+    
+    def PHVIT(self, img):
+        eps = 1e-8
+        H,V,I = img[:,0,:,:],img[:,1,:,:],img[:,2,:,:]
+        
+        # clip
+        H = torch.clamp(H,-1,1)
+        V = torch.clamp(V,-1,1)
+        I = torch.clamp(I,0,1)
+        
+        v = I
+        k = self.this_k
+        color_sensitive = ((v * 0.5 * pi).sin() + eps).pow(k)
+        H = (H) / (color_sensitive + eps)
+        V = (V) / (color_sensitive + eps)
+        H = torch.clamp(H,-1,1)
+        V = torch.clamp(V,-1,1)
+        h = torch.atan2(V + eps,H + eps) / (2*pi)
+        h = h%1
+        s = torch.sqrt(H**2 + V**2 + eps)
+        
+        if self.gated:
+            s = s * self.alpha_s
+        
+        s = torch.clamp(s,0,1)
+        v = torch.clamp(v,0,1)
+        
+        r = torch.zeros_like(h)
+        g = torch.zeros_like(h)
+        b = torch.zeros_like(h)
+        
+        hi = torch.floor(h * 6.0)
+        f = h * 6.0 - hi
+        p = v * (1. - s)
+        q = v * (1. - (f * s))
+        t = v * (1. - ((1. - f) * s))
+        
+        hi0 = hi==0
+        hi1 = hi==1
+        hi2 = hi==2
+        hi3 = hi==3
+        hi4 = hi==4
+        hi5 = hi==5
+        
+        r[hi0] = v[hi0]
+        g[hi0] = t[hi0]
+        b[hi0] = p[hi0]
+        
+        r[hi1] = q[hi1]
+        g[hi1] = v[hi1]
+        b[hi1] = p[hi1]
+        
+        r[hi2] = p[hi2]
+        g[hi2] = v[hi2]
+        b[hi2] = t[hi2]
+        
+        r[hi3] = p[hi3]
+        g[hi3] = q[hi3]
+        b[hi3] = v[hi3]
+        
+        r[hi4] = t[hi4]
+        g[hi4] = p[hi4]
+        b[hi4] = v[hi4]
+        
+        r[hi5] = v[hi5]
+        g[hi5] = p[hi5]
+        b[hi5] = q[hi5]
+                
+        r = r.unsqueeze(1)
+        g = g.unsqueeze(1)
+        b = b.unsqueeze(1)
+        rgb = torch.cat([r, g, b], dim=1)
+        if self.gated2:
+            rgb = rgb * self.alpha
+        return rgb

net/LCA.py

@@ -0,0 +1,93 @@
+import torch
+import torch.nn as nn
+from einops import rearrange
+from net.transformer_utils import *
+
+# Cross Attention Block
+class CAB(nn.Module):
+    def __init__(self, dim, num_heads, bias):
+        super(CAB, self).__init__()
+        self.num_heads = num_heads
+        self.temperature = nn.Parameter(torch.ones(num_heads, 1, 1))
+
+        self.q = nn.Conv2d(dim, dim, kernel_size=1, bias=bias)
+        self.q_dwconv = nn.Conv2d(dim, dim, kernel_size=3, stride=1, padding=1, groups=dim, bias=bias)
+        self.kv = nn.Conv2d(dim, dim*2, kernel_size=1, bias=bias)
+        self.kv_dwconv = nn.Conv2d(dim*2, dim*2, kernel_size=3, stride=1, padding=1, groups=dim*2, bias=bias)
+        self.project_out = nn.Conv2d(dim, dim, kernel_size=1, bias=bias)
+
+    def forward(self, x, y):
+        b, c, h, w = x.shape
+
+        q = self.q_dwconv(self.q(x))
+        kv = self.kv_dwconv(self.kv(y))
+        k, v = kv.chunk(2, dim=1)
+
+        q = rearrange(q, 'b (head c) h w -> b head c (h w)', head=self.num_heads)
+        k = rearrange(k, 'b (head c) h w -> b head c (h w)', head=self.num_heads)
+        v = rearrange(v, 'b (head c) h w -> b head c (h w)', head=self.num_heads)
+
+        q = torch.nn.functional.normalize(q, dim=-1)
+        k = torch.nn.functional.normalize(k, dim=-1)
+
+        attn = (q @ k.transpose(-2, -1)) * self.temperature
+        attn = nn.functional.softmax(attn,dim=-1)
+
+        out = (attn @ v)
+
+        out = rearrange(out, 'b head c (h w) -> b (head c) h w', head=self.num_heads, h=h, w=w)
+
+        out = self.project_out(out)
+        return out
+    
+
+# Intensity Enhancement Layer
+class IEL(nn.Module):
+    def __init__(self, dim, ffn_expansion_factor=2.66, bias=False):
+        super(IEL, self).__init__()
+
+        hidden_features = int(dim*ffn_expansion_factor)
+
+        self.project_in = nn.Conv2d(dim, hidden_features*2, kernel_size=1, bias=bias)
+        
+        self.dwconv = nn.Conv2d(hidden_features*2, hidden_features*2, kernel_size=3, stride=1, padding=1, groups=hidden_features*2, bias=bias)
+        self.dwconv1 = nn.Conv2d(hidden_features, hidden_features, kernel_size=3, stride=1, padding=1, groups=hidden_features, bias=bias)
+        self.dwconv2 = nn.Conv2d(hidden_features, hidden_features, kernel_size=3, stride=1, padding=1, groups=hidden_features, bias=bias)
+       
+        self.project_out = nn.Conv2d(hidden_features, dim, kernel_size=1, bias=bias)
+
+        self.Tanh = nn.Tanh()
+    def forward(self, x):
+        x = self.project_in(x)
+        x1, x2 = self.dwconv(x).chunk(2, dim=1)
+        x1 = self.Tanh(self.dwconv1(x1)) + x1
+        x2 = self.Tanh(self.dwconv2(x2)) + x2
+        x = x1 * x2
+        x = self.project_out(x)
+        return x
+  
+  
+# Lightweight Cross Attention
+class HV_LCA(nn.Module):
+    def __init__(self, dim,num_heads, bias=False):
+        super(HV_LCA, self).__init__()
+        self.gdfn = IEL(dim) # IEL and CDL have same structure
+        self.norm = LayerNorm(dim)
+        self.ffn = CAB(dim, num_heads, bias)
+        
+    def forward(self, x, y):
+        x = x + self.ffn(self.norm(x),self.norm(y))
+        x = self.gdfn(self.norm(x))
+        return x
+    
+class I_LCA(nn.Module):
+    def __init__(self, dim,num_heads, bias=False):
+        super(I_LCA, self).__init__()
+        self.norm = LayerNorm(dim)
+        self.gdfn = IEL(dim)
+        self.ffn = CAB(dim, num_heads, bias=bias)
+        
+    def forward(self, x, y):
+        x = x + self.ffn(self.norm(x),self.norm(y))
+        x = x + self.gdfn(self.norm(x)) 
+        return x

net/transformer_utils.py

@@ -0,0 +1,72 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops import rearrange
+
+class LayerNorm(nn.Module):
+    r""" LayerNorm that supports two data formats: channels_last (default) or channels_first. 
+    The ordering of the dimensions in the inputs. channels_last corresponds to inputs with 
+    shape (batch_size, height, width, channels) while channels_first corresponds to inputs 
+    with shape (batch_size, channels, height, width).
+    """
+    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_first"):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(normalized_shape))
+        self.bias = nn.Parameter(torch.zeros(normalized_shape))
+        self.eps = eps
+        self.data_format = data_format
+        if self.data_format not in ["channels_last", "channels_first"]:
+            raise NotImplementedError 
+        self.normalized_shape = (normalized_shape, )
+    
+    def forward(self, x):
+        if self.data_format == "channels_last":
+            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
+        elif self.data_format == "channels_first":
+            u = x.mean(1, keepdim=True)
+            s = (x - u).pow(2).mean(1, keepdim=True)
+            x = (x - u) / torch.sqrt(s + self.eps)
+            x = self.weight[:, None, None] * x + self.bias[:, None, None]
+            return x
+
+class NormDownsample(nn.Module):
+    def __init__(self,in_ch,out_ch,scale=0.5,use_norm=False):
+        super(NormDownsample, self).__init__()
+        self.use_norm=use_norm
+        if self.use_norm:
+            self.norm=LayerNorm(out_ch)
+        self.prelu = nn.PReLU()
+        self.down = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch,kernel_size=3,stride=1, padding=1, bias=False),
+            nn.UpsamplingBilinear2d(scale_factor=scale))
+    def forward(self, x):
+        x = self.down(x)
+        x = self.prelu(x)
+        if self.use_norm:
+            x = self.norm(x)
+            return x
+        else:
+            return x
+
+class NormUpsample(nn.Module):
+    def __init__(self, in_ch,out_ch,scale=2,use_norm=False):
+        super(NormUpsample, self).__init__()
+        self.use_norm=use_norm
+        if self.use_norm:
+            self.norm=LayerNorm(out_ch)
+        self.prelu = nn.PReLU()
+        self.up_scale = nn.Sequential(
+            nn.Conv2d(in_ch,out_ch,kernel_size=3,stride=1, padding=1, bias=False),
+            nn.UpsamplingBilinear2d(scale_factor=scale))
+        self.up = nn.Conv2d(out_ch*2,out_ch,kernel_size=1,stride=1, padding=0, bias=False)
+            
+    def forward(self, x,y):
+        x = self.up_scale(x)
+        x = torch.cat([x, y],dim=1)
+        x = self.up(x)
+        x = self.prelu(x)
+        if self.use_norm:
+            return self.norm(x)
+        else:
+            return x
+ 

weights/LOL-Blur.pth

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

weights/LOLv1/BestLPIPS_0.0868.pth

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

weights/LOLv1/BestSSIM_0.8631.pth

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

weights/LOLv1/PSNR_24.74.pth

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

weights/LOLv1/w_perc.pth

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

weights/LOLv1/wo_perc.pth

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

weights/LOLv2_real/best_PSNR.pth

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

weights/LOLv2_real/best_SSIM.pth

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

weights/LOLv2_real/w_perc.pth

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

weights/LOLv2_syn/w_perc.pth

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

weights/LOLv2_syn/wo_perc.pth

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

weights/SICE.pth

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

weights/SID.pth

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

weights/generalization.pth

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