id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
33,420 | import argparse
import glob
import os
import re
import signal
import subprocess
import tempfile
import time
from dataclasses import dataclass
from datetime import datetime
from typing import Optional
import gradio as gr
import numpy as np
import psutil
import trimesh
from threestudio.utils.config import load_config
fro... | null |
33,421 | import argparse
import glob
import os
import re
import signal
import subprocess
import tempfile
import time
from dataclasses import dataclass
from datetime import datetime
from typing import Optional
import gradio as gr
import numpy as np
import psutil
import trimesh
from threestudio.utils.config import load_config
fro... | null |
33,422 | import glob
import hashlib
import html
import io
import multiprocessing as mp
import os
import re
import urllib
import urllib.request
from typing import Any, Callable, Dict, List, Tuple, Union
import numpy as np
import requests
import scipy.linalg
import torch
from torchvision.io import read_video
from tqdm import tqdm... | null |
33,423 | import argparse
import io
import os
import random
import warnings
import zipfile
from abc import ABC, abstractmethod
from contextlib import contextmanager
from functools import partial
from multiprocessing import cpu_count
from multiprocessing.pool import ThreadPool
from typing import Iterable, Optional, Tuple
import n... | Compute pairwise distances between two batches of feature vectors. |
33,424 | import argparse
import io
import os
import random
import warnings
import zipfile
from abc import ABC, abstractmethod
from contextlib import contextmanager
from functools import partial
from multiprocessing import cpu_count
from multiprocessing.pool import ThreadPool
from typing import Iterable, Optional, Tuple
import n... | null |
33,425 | import argparse
import io
import os
import random
import warnings
import zipfile
from abc import ABC, abstractmethod
from contextlib import contextmanager
from functools import partial
from multiprocessing import cpu_count
from multiprocessing.pool import ThreadPool
from typing import Iterable, Optional, Tuple
import n... | Copied from: https://github.com/numpy/numpy/blob/fb215c76967739268de71aa4bda55dd1b062bc2e/numpy/lib/format.py#L788-L886 Read from file-like object until size bytes are read. Raises ValueError if not EOF is encountered before size bytes are read. Non-blocking objects only supported if they derive from io objects. Requir... |
33,426 | import argparse
import io
import os
import random
import warnings
import zipfile
from abc import ABC, abstractmethod
from contextlib import contextmanager
from functools import partial
from multiprocessing import cpu_count
from multiprocessing.pool import ThreadPool
from typing import Iterable, Optional, Tuple
import n... | null |
33,427 | import argparse
import io
import os
import random
import warnings
import zipfile
from abc import ABC, abstractmethod
from contextlib import contextmanager
from functools import partial
from multiprocessing import cpu_count
from multiprocessing.pool import ThreadPool
from typing import Iterable, Optional, Tuple
import n... | null |
33,428 | import argparse
import io
import os
import random
import warnings
import zipfile
from abc import ABC, abstractmethod
from contextlib import contextmanager
from functools import partial
from multiprocessing import cpu_count
from multiprocessing.pool import ThreadPool
from typing import Iterable, Optional, Tuple
import n... | null |
33,429 | from __future__ import absolute_import, division, print_function
import six
import tensorflow.compat.v1 as tf
import tensorflow_gan as tfgan
import tensorflow_hub as hub
The provided code snippet includes necessary dependencies for implementing the `preprocess` function. Write a Python function `def preprocess(videos,... | Runs some preprocessing on the videos for I3D model. Args: videos: <T>[batch_size, num_frames, height, width, depth] The videos to be preprocessed. We don't care about the specific dtype of the videos, it can be anything that tf.image.resize_bilinear accepts. Values are expected to be in the range 0-255. target_resolut... |
33,430 | from __future__ import absolute_import, division, print_function
import six
import tensorflow.compat.v1 as tf
import tensorflow_gan as tfgan
import tensorflow_hub as hub
def _is_in_graph(tensor_name):
"""Checks whether a given tensor does exists in the graph."""
try:
tf.get_default_graph().get_tensor_by... | Embeds the given videos using the Inflated 3D Convolution ne twork. Downloads the graph of the I3D from tf.hub and adds it to the graph on the first call. Args: videos: <float32>[batch_size, num_frames, height=224, width=224, depth=3]. Expected range is [-1, 1]. Returns: embedding: <float32>[batch_size, embedding_size]... |
33,431 | from __future__ import absolute_import, division, print_function
import six
import tensorflow.compat.v1 as tf
import tensorflow_gan as tfgan
import tensorflow_hub as hub
The provided code snippet includes necessary dependencies for implementing the `calculate_fvd` function. Write a Python function `def calculate_fvd(r... | Returns a list of ops that compute metrics as funcs of activations. Args: real_activations: <float32>[num_samples, embedding_size] generated_activations: <float32>[num_samples, embedding_size] Returns: A scalar that contains the requested FVD. |
33,432 | import argparse
import glob
import os
from collections import namedtuple
import numpy as np
import torch
import torchvision.transforms as transforms
from PIL import Image
from torchvision import models
from tqdm import tqdm
from extern.ldm_zero123.modules.evaluate.ssim import ssim
def normalize_tensor(in_feat, eps=1e-1... | null |
33,433 | import argparse
import glob
import os
from collections import namedtuple
import numpy as np
import torch
import torchvision.transforms as transforms
from PIL import Image
from torchvision import models
from tqdm import tqdm
from extern.ldm_zero123.modules.evaluate.ssim import ssim
class vgg16(torch.nn.Module):
def... | null |
33,434 | import argparse
import glob
import os
from collections import namedtuple
import numpy as np
import torch
import torchvision.transforms as transforms
from PIL import Image
from torchvision import models
from tqdm import tqdm
from extern.ldm_zero123.modules.evaluate.ssim import ssim
class vgg16(torch.nn.Module):
def... | null |
33,435 | import argparse
import glob
import os
from collections import namedtuple
import numpy as np
import torch
import torchvision.transforms as transforms
from PIL import Image
from torchvision import models
from tqdm import tqdm
from extern.ldm_zero123.modules.evaluate.ssim import ssim
class vgg16(torch.nn.Module):
def... | null |
33,436 | import torch
import torch.nn.functional as F
from einops import repeat
from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
from taming.modules.losses.lpips import LPIPS
from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
from torch import nn
def hinge_d_loss_with_ex... | null |
33,437 | import torch
import torch.nn.functional as F
from einops import repeat
from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
from taming.modules.losses.lpips import LPIPS
from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
from torch import nn
def adopt_weight(weight,... | null |
33,438 | import torch
import torch.nn.functional as F
from einops import repeat
from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
from taming.modules.losses.lpips import LPIPS
from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
from torch import nn
def measure_perplexity(p... | null |
33,439 | import torch
import torch.nn.functional as F
from einops import repeat
from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
from taming.modules.losses.lpips import LPIPS
from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
from torch import nn
def l1(x, y):
return... | null |
33,440 | import torch
import torch.nn.functional as F
from einops import repeat
from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
from taming.modules.losses.lpips import LPIPS
from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
from torch import nn
def l2(x, y):
return... | null |
33,441 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
def make_beta_schedule(
schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3
):
if schedule == "linear":
betas = (
... | null |
33,442 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
def make_ddim_timesteps(
ddim_discr_method, num_ddim_timesteps, num_ddpm_timesteps, verbose=True
):
if ddim_discr_method == "uniform":
c = nu... | null |
33,443 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True):
# select alphas for computing the variance schedule
alphas = alphacu... | null |
33,444 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `betas_for_alpha_bar` function. Write a Python function `def betas_for_alpha_b... | Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of (1-beta) over time from t = [0,1]. :param num_diffusion_timesteps: the number of betas to produce. :param alpha_bar: a lambda that takes an argument t from 0 to 1 and produces the cumulative product of (1-bet... |
33,445 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
def extract_into_tensor(a, t, x_shape):
b, *_ = t.shape
out = a.gather(-1, t)
return out.reshape(b, *((1,) * (len(x_shape) - 1))) | null |
33,446 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
class CheckpointFunction(torch.autograd.Function):
def forward(ctx, run_function, length, *args):
ctx.run_function = run_function
ctx.inpu... | Evaluate a function without caching intermediate activations, allowing for reduced memory at the expense of extra compute in the backward pass. :param func: the function to evaluate. :param inputs: the argument sequence to pass to `func`. :param params: a sequence of parameters `func` depends on but does not explicitly... |
33,447 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `timestep_embedding` function. Write a Python function `def timestep_embedding... | Create sinusoidal timestep embeddings. :param timesteps: a 1-D Tensor of N indices, one per batch element. These may be fractional. :param dim: the dimension of the output. :param max_period: controls the minimum frequency of the embeddings. :return: an [N x dim] Tensor of positional embeddings. |
33,448 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `zero_module` function. Write a Python function `def zero_module(module)` to s... | Zero out the parameters of a module and return it. |
33,449 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `scale_module` function. Write a Python function `def scale_module(module, sca... | Scale the parameters of a module and return it. |
33,450 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `mean_flat` function. Write a Python function `def mean_flat(tensor)` to solve... | Take the mean over all non-batch dimensions. |
33,451 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
class GroupNorm32(nn.GroupNorm):
def forward(self, x):
return super().forward(x.float()).type(x.dtype)
The provided code snippet includes necessa... | Make a standard normalization layer. :param channels: number of input channels. :return: an nn.Module for normalization. |
33,452 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `conv_nd` function. Write a Python function `def conv_nd(dims, *args, **kwargs... | Create a 1D, 2D, or 3D convolution module. |
33,453 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `linear` function. Write a Python function `def linear(*args, **kwargs)` to so... | Create a linear module. |
33,454 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `avg_pool_nd` function. Write a Python function `def avg_pool_nd(dims, *args, ... | Create a 1D, 2D, or 3D average pooling module. |
33,455 | import math
import os
import numpy as np
import torch
import torch.nn as nn
from einops import repeat
from extern.ldm_zero123.util import instantiate_from_config
def noise_like(shape, device, repeat=False):
repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(
shape[0], *((1,) * (len(s... | null |
33,456 | import math
import numpy as np
import torch
import torch.nn as nn
from einops import rearrange
from extern.ldm_zero123.modules.attention import LinearAttention
from extern.ldm_zero123.util import instantiate_from_config
The provided code snippet includes necessary dependencies for implementing the `get_timestep_embedd... | This matches the implementation in Denoising Diffusion Probabilistic Models: From Fairseq. Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the description in Section 3.5 of "Attention Is All You Need". |
33,457 | import math
import numpy as np
import torch
import torch.nn as nn
from einops import rearrange
from extern.ldm_zero123.modules.attention import LinearAttention
from extern.ldm_zero123.util import instantiate_from_config
def nonlinearity(x):
# swish
return x * torch.sigmoid(x) | null |
33,458 | import math
import numpy as np
import torch
import torch.nn as nn
from einops import rearrange
from extern.ldm_zero123.modules.attention import LinearAttention
from extern.ldm_zero123.util import instantiate_from_config
def Normalize(in_channels, num_groups=32):
return torch.nn.GroupNorm(
num_groups=num_gr... | null |
33,459 | import math
import numpy as np
import torch
import torch.nn as nn
from einops import rearrange
from extern.ldm_zero123.modules.attention import LinearAttention
from extern.ldm_zero123.util import instantiate_from_config
class LinAttnBlock(LinearAttention):
def __init__(self, in_channels):
class AttnBlock(nn.Module... | null |
33,460 | import math
from abc import abstractmethod
from functools import partial
from typing import Iterable
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
from extern.ldm_zero123.modules.attention import SpatialTransformer
from extern.ldm_zero123.modules.diffusionmodules.util impor... | null |
33,461 | import math
from abc import abstractmethod
from functools import partial
from typing import Iterable
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
from extern.ldm_zero123.modules.attention import SpatialTransformer
from extern.ldm_zero123.modules.diffusionmodules.util impor... | null |
33,462 | import math
from abc import abstractmethod
from functools import partial
from typing import Iterable
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
from extern.ldm_zero123.modules.attention import SpatialTransformer
from extern.ldm_zero123.modules.diffusionmodules.util impor... | A counter for the `thop` package to count the operations in an attention operation. Meant to be used like: macs, params = thop.profile( model, inputs=(inputs, timestamps), custom_ops={QKVAttention: QKVAttention.count_flops}, ) |
33,463 | import math
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from extern.ldm_zero123.modules.diffusionmodules.util import checkpoint
def uniq(arr):
return {el: True for el in arr}.keys() | null |
33,464 | import math
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from extern.ldm_zero123.modules.diffusionmodules.util import checkpoint
def exists(val):
def default(val, d):
if exists(val):
return val
return d() i... | null |
33,465 | import math
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from extern.ldm_zero123.modules.diffusionmodules.util import checkpoint
def max_neg_value(t):
return -torch.finfo(t.dtype).max | null |
33,466 | import math
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from extern.ldm_zero123.modules.diffusionmodules.util import checkpoint
def init_(tensor):
dim = tensor.shape[-1]
std = 1 / math.sqrt(dim)
tensor.uniform... | null |
33,467 | import math
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from extern.ldm_zero123.modules.diffusionmodules.util import checkpoint
The provided code snippet includes necessary dependencies for implementing the `zero_module` ... | Zero out the parameters of a module and return it. |
33,468 | import math
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from extern.ldm_zero123.modules.diffusionmodules.util import checkpoint
def Normalize(in_channels):
return torch.nn.GroupNorm(
num_groups=32, num_channel... | null |
33,469 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
The p... | Args: img: numpy image, WxH or WxHxC sf: scale factor Return: cropped image |
33,470 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
The p... | Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper) |
33,471 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
The p... | " # modified version of https://github.com/assafshocher/BlindSR_dataset_generator # Kai Zhang # min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var # max_var = 2.5 * sf |
33,472 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def bi... | blur + bicubic downsampling Args: x: HxWxC image, [0, 1] k: hxw, double sf: down-scale factor Return: downsampled LR image Reference: @inproceedings{zhang2018learning, title={Learning a single convolutional super-resolution network for multiple degradations}, author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, bookti... |
33,473 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def bi... | bicubic downsampling + blur Args: x: HxWxC image, [0, 1] k: hxw, double sf: down-scale factor Return: downsampled LR image Reference: @inproceedings{zhang2019deep, title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels}, author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, booktitle={IEEE Conference on ... |
33,474 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
The p... | blur + downsampling Args: x: HxWxC image, [0, 1]/[0, 255] k: hxw, double sf: down-scale factor Return: downsampled LR image |
33,475 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def bl... | USM sharpening. borrowed from real-ESRGAN Input image: I; Blurry image: B. 1. K = I + weight * (I - B) 2. Mask = 1 if abs(I - B) > threshold, else: 0 3. Blur mask: 4. Out = Mask * K + (1 - Mask) * I Args: img (Numpy array): Input image, HWC, BGR; float32, [0, 1]. weight (float): Sharp weight. Default: 1. radius (float)... |
33,476 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def a... | null |
33,477 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def a... | null |
33,478 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def a... | null |
33,479 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def sh... | This is the degradation model of BSRGAN from the paper "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" ---------- img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) sf: scale factor isp_model: camera ISP model Returns ------- img: low-quality patch, siz... |
33,480 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def sh... | This is the degradation model of BSRGAN from the paper "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" ---------- sf: scale factor isp_model: camera ISP model Returns ------- img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] hq: corresponding high-quality patch, si... |
33,481 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def imshow(x, title=None, cbar=False, figsize=None):
plt.figure(figsize=figsize)
plt.imshow(np.squeeze(x), interpolation="nearest", cmap="gray")
if title:
... | null |
33,482 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def surf(Z, cmap="rainbow", figsize=None):
plt.figure(figsize=figsize)
ax3 = plt.axes(projection="3d")
w, h = Z.shape[:2]
xx = np.arange(0, w, 1)
yy ... | null |
33,483 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
def get_image_paths(dataroot):
paths = None # return None if dataroot is None
if dataroot is not None:
paths =... | split the large images from original_dataroot into small overlapped images with size (p_size)x(p_size), and save them into taget_dataroot; only the images with larger size than (p_max)x(p_max) will be splitted. Args: original_dataroot: taget_dataroot: p_size: size of small images p_overlap: patch size in training is a ... |
33,484 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def mkdir(path):
if not os.path.exists(path):
os.makedirs(path)
def mkdirs(paths):
if isinstance(paths, str):
mkdir(paths)
else:
for p... | null |
33,485 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
def get_timestamp():
def mkdir_and_rename(path):
if os.path.exists(path):
new_name = path + "_archived_" + get_tim... | null |
33,486 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def imwrite(img, img_path):
img = np.squeeze(img)
if img.ndim == 3:
img = img[:, :, [2, 1, 0]]
cv2.imwrite(img_path, img)
def imsave(img, img_path):
... | null |
33,487 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def read_img(path):
# read image by cv2
# return: Numpy float32, HWC, BGR, [0,1]
img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # cv2.IMREAD_GRAYSCALE
img ... | null |
33,488 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def uint162single(img):
return np.float32(img / 65535.0) | null |
33,489 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def single2uint16(img):
return np.uint16((img.clip(0, 1) * 65535.0).round()) | null |
33,490 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def uint2tensor4(img):
if img.ndim == 2:
img = np.expand_dims(img, axis=2)
return (
torch.from_numpy(np.ascontiguousarray(img))
.permute(2... | null |
33,491 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def uint2tensor3(img):
if img.ndim == 2:
img = np.expand_dims(img, axis=2)
return (
torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).f... | null |
33,492 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def tensor2uint(img):
img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy()
if img.ndim == 3:
img = np.transpose(img, (1, 2, 0))
return np.uint8... | null |
33,493 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def single2tensor3(img):
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float() | null |
33,494 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def single2tensor4(img):
return (
torch.from_numpy(np.ascontiguousarray(img))
.permute(2, 0, 1)
.float()
.unsqueeze(0)
) | null |
33,495 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def tensor2single(img):
img = img.data.squeeze().float().cpu().numpy()
if img.ndim == 3:
img = np.transpose(img, (1, 2, 0))
return img | null |
33,496 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def tensor2single3(img):
img = img.data.squeeze().float().cpu().numpy()
if img.ndim == 3:
img = np.transpose(img, (1, 2, 0))
elif img.ndim == 2:
... | null |
33,497 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def single2tensor5(img):
return (
torch.from_numpy(np.ascontiguousarray(img))
.permute(2, 0, 1, 3)
.float()
.unsqueeze(0)
) | null |
33,498 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def single32tensor5(img):
return torch.from_numpy(np.ascontiguousarray(img)).float().unsqueeze(0).unsqueeze(0) | null |
33,499 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def single42tensor4(img):
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float() | null |
33,500 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
The provided code snippet includes necessary dependencies for implementing the `tensor2img` function. Write a Python function `def tensor2img(tensor, out_type=np.uint8, m... | Converts a torch Tensor into an image Numpy array of BGR channel order Input: 4D(B,(3/1),H,W), 3D(C,H,W), or 2D(H,W), any range, RGB channel order Output: 3D(H,W,C) or 2D(H,W), [0,255], np.uint8 (default) |
33,501 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
The provided code snippet includes necessary dependencies for implementing the `augment_img_tensor4` function. Write a Python function `def augment_img_tensor4(img, mode=... | Kai Zhang (github: https://github.com/cszn) |
33,502 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def augment_img(img, mode=0):
"""Kai Zhang (github: https://github.com/cszn)"""
if mode == 0:
return img
elif mode == 1:
return np.flipud(np.ro... | Kai Zhang (github: https://github.com/cszn) |
33,503 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def augment_img_np3(img, mode=0):
if mode == 0:
return img
elif mode == 1:
return img.transpose(1, 0, 2)
elif mode == 2:
return img[::... | null |
33,504 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def augment_imgs(img_list, hflip=True, rot=True):
# horizontal flip OR rotate
hflip = hflip and random.random() < 0.5
vflip = rot and random.random() < 0.5
... | null |
33,505 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def modcrop(img_in, scale):
# img_in: Numpy, HWC or HW
img = np.copy(img_in)
if img.ndim == 2:
H, W = img.shape
H_r, W_r = H % scale, W % scal... | null |
33,506 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def shave(img_in, border=0):
# img_in: Numpy, HWC or HW
img = np.copy(img_in)
h, w = img.shape[:2]
img = img[border : h - border, border : w - border]
... | null |
33,507 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
The provided code snippet includes necessary dependencies for implementing the `rgb2ycbcr` function. Write a Python function `def rgb2ycbcr(img, only_y=True)` to solve th... | same as matlab rgb2ycbcr only_y: only return Y channel Input: uint8, [0, 255] float, [0, 1] |
33,508 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
The provided code snippet includes necessary dependencies for implementing the `ycbcr2rgb` function. Write a Python function `def ycbcr2rgb(img)` to solve the following p... | same as matlab ycbcr2rgb Input: uint8, [0, 255] float, [0, 1] |
33,509 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def bgr2ycbcr(img, only_y=True):
"""bgr version of rgb2ycbcr
only_y: only return Y channel
Input:
uint8, [0, 255]
float, [0, 1]
"""
in_... | null |
33,510 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def calculate_psnr(img1, img2, border=0):
# img1 and img2 have range [0, 255]
# img1 = img1.squeeze()
# img2 = img2.squeeze()
if not img1.shape == img2.sh... | null |
33,511 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def ssim(img1, img2):
C1 = (0.01 * 255) ** 2
C2 = (0.03 * 255) ** 2
img1 = img1.astype(np.float64)
img2 = img2.astype(np.float64)
kernel = cv2.getGauss... | calculate SSIM the same outputs as MATLAB's img1, img2: [0, 255] |
33,512 | import math
import os
import random
from datetime import datetime
import cv2
import numpy as np
import torch
from torchvision.utils import make_grid
def calculate_weights_indices(
in_length, out_length, scale, kernel, kernel_width, antialiasing
):
def imresize(img, scale, antialiasing=True):
# Now the scale sh... | null |
33,516 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def bi... | blur + bicubic downsampling Args: x: HxWxC image, [0, 1] k: hxw, double sf: down-scale factor Return: downsampled LR image Reference: @inproceedings{zhang2018learning, title={Learning a single convolutional super-resolution network for multiple degradations}, author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, bookti... |
33,517 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def bi... | bicubic downsampling + blur Args: x: HxWxC image, [0, 1] k: hxw, double sf: down-scale factor Return: downsampled LR image Reference: @inproceedings{zhang2019deep, title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels}, author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, booktitle={IEEE Conference on ... |
33,518 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
The p... | blur + downsampling Args: x: HxWxC image, [0, 1]/[0, 255] k: hxw, double sf: down-scale factor Return: downsampled LR image |
33,519 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def sh... | This is the degradation model of BSRGAN from the paper "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" ---------- img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) sf: scale factor isp_model: camera ISP model Returns ------- img: low-quality patch, siz... |
33,520 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def sh... | This is the degradation model of BSRGAN from the paper "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" ---------- sf: scale factor isp_model: camera ISP model Returns ------- img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] hq: corresponding high-quality patch, si... |
33,521 | import random
from functools import partial
import albumentations
import cv2
import numpy as np
import scipy
import scipy.stats as ss
import torch
from scipy import ndimage
from scipy.interpolate import interp2d
from scipy.linalg import orth
import extern.ldm_zero123.modules.image_degradation.utils_image as util
def ad... | This is an extended degradation model by combining the degradation models of BSRGAN and Real-ESRGAN ---------- img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) sf: scale factor use_shuffle: the degradation shuffle use_sharp: sharpening the img Returns ------- img: low-quality patch,... |
33,522 | from collections import namedtuple
from functools import partial
from inspect import isfunction
import torch
import torch.nn.functional as F
from einops import rearrange, reduce, repeat
from torch import einsum, nn
def exists(val):
return val is not None
def default(val, d):
if exists(val):
return val
... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.