id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
15,379 | import bisect
import functools
import logging
import numbers
import os
import signal
import sys
import traceback
import warnings
import torch
from pytorch_lightning import seed_everything
import platform
def get_has_ddp_rank():
master_port = os.environ.get('MASTER_PORT', None)
node_rank = os.environ.get('NODE_R... | null |
15,380 | import bisect
import functools
import logging
import numbers
import os
import signal
import sys
import traceback
import warnings
import torch
from pytorch_lightning import seed_everything
import platform
def get_has_ddp_rank():
def handle_ddp_parent_process():
parent_cwd = os.environ.get('TRAINING_PARENT_WORK_DIR'... | null |
15,381 | import collections
from functools import partial
import functools
import logging
from collections import defaultdict
import numpy as np
import torch.nn as nn
from saicinpainting.training.modules.base import BaseDiscriminator, deconv_factory, get_conv_block_ctor, get_norm_layer, get_activation
from saicinpainting.traini... | null |
15,382 | import abc
from typing import Tuple, List
import torch
import torch.nn as nn
from saicinpainting.training.modules.depthwise_sep_conv import DepthWiseSeperableConv
from saicinpainting.training.modules.multidilated_conv import MultidilatedConv
class DepthWiseSeperableConv(nn.Module):
def __init__(self, in_dim, out_d... | null |
15,383 | import abc
from typing import Tuple, List
import torch
import torch.nn as nn
from saicinpainting.training.modules.depthwise_sep_conv import DepthWiseSeperableConv
from saicinpainting.training.modules.multidilated_conv import MultidilatedConv
def get_norm_layer(kind='bn'):
if not isinstance(kind, str):
retu... | null |
15,384 | import abc
from typing import Tuple, List
import torch
import torch.nn as nn
from saicinpainting.training.modules.depthwise_sep_conv import DepthWiseSeperableConv
from saicinpainting.training.modules.multidilated_conv import MultidilatedConv
def get_activation(kind='tanh'):
if kind == 'tanh':
return nn.Tan... | null |
15,385 | import abc
from typing import Tuple, List
import torch
import torch.nn as nn
from saicinpainting.training.modules.depthwise_sep_conv import DepthWiseSeperableConv
from saicinpainting.training.modules.multidilated_conv import MultidilatedConv
class DepthWiseSeperableConv(nn.Module):
def __init__(self, in_dim, out_d... | null |
15,386 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from saicinpainting.training.losses.perceptual import IMAGENET_STD, IMAGENET_MEAN
def get_gauss_kernel(kernel_size, width_factor=1):
coords = torch.stack(torch.meshgrid(torch.arange(kernel_size),
... | null |
15,387 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from saicinpainting.training.losses.perceptual import IMAGENET_STD, IMAGENET_MEAN
def dummy_distance_weighter(real_img, pred_img, mask):
return mask
class BlurMask(nn.Module):
def __init__(self, kernel_size=5, width_factor=1):... | null |
15,388 | from typing import List
import torch
import torch.nn.functional as F
def masked_l2_loss(pred, target, mask, weight_known, weight_missing):
per_pixel_l2 = F.mse_loss(pred, target, reduction='none')
pixel_weights = mask * weight_missing + (1 - mask) * weight_known
return (pixel_weights * per_pixel_l2).mean() | null |
15,389 | from typing import List
import torch
import torch.nn.functional as F
def masked_l1_loss(pred, target, mask, weight_known, weight_missing):
per_pixel_l1 = F.l1_loss(pred, target, reduction='none')
pixel_weights = mask * weight_missing + (1 - mask) * weight_known
return (pixel_weights * per_pixel_l1).mean() | null |
15,390 | from typing import List
import torch
import torch.nn.functional as F
def feature_matching_loss(fake_features: List[torch.Tensor], target_features: List[torch.Tensor], mask=None):
if mask is None:
res = torch.stack([F.mse_loss(fake_feat, target_feat)
for fake_feat, target_feat in ... | null |
15,391 | from typing import Tuple, Dict, Optional
import torch
import torch.nn as nn
import torch.nn.functional as F
def make_r1_gp(discr_real_pred, real_batch):
if torch.is_grad_enabled():
grad_real = torch.autograd.grad(outputs=discr_real_pred.sum(), inputs=real_batch, create_graph=True)[0]
grad_penalty =... | null |
15,392 | from typing import Tuple, Dict, Optional
import torch
import torch.nn as nn
import torch.nn.functional as F
class NonSaturatingWithR1(BaseAdversarialLoss):
def __init__(self, gp_coef=5, weight=1, mask_as_fake_target=False, allow_scale_mask=False,
mask_scale_mode='nearest', extra_mask_weight_for_gen... | null |
15,393 | import math
import random
import hashlib
import logging
from enum import Enum
import cv2
import numpy as np
from saicinpainting.evaluation.masks.mask import SegmentationMask
from saicinpainting.utils import LinearRamp
class DrawMethod(Enum):
LINE = 'line'
CIRCLE = 'circle'
SQUARE = 'square'
def make_random... | null |
15,394 | import math
import random
import hashlib
import logging
from enum import Enum
import cv2
import numpy as np
from saicinpainting.evaluation.masks.mask import SegmentationMask
from saicinpainting.utils import LinearRamp
def make_random_rectangle_mask(shape, margin=10, bbox_min_size=30, bbox_max_size=100, min_times=0, ma... | null |
15,395 | import math
import random
import hashlib
import logging
from enum import Enum
import cv2
import numpy as np
from saicinpainting.evaluation.masks.mask import SegmentationMask
from saicinpainting.utils import LinearRamp
def make_random_superres_mask(shape, min_step=2, max_step=4, min_width=1, max_width=3):
height, w... | null |
15,396 | import glob
import logging
import os
import random
import albumentations as A
import cv2
import numpy as np
import torch
import torch.nn.functional as F
import webdataset
from omegaconf import open_dict, OmegaConf
from skimage.feature import canny
from skimage.transform import rescale, resize
from torch.utils.data impo... | null |
15,397 | import glob
import logging
import os
import random
import albumentations as A
import cv2
import numpy as np
import torch
import torch.nn.functional as F
import webdataset
from omegaconf import open_dict, OmegaConf
from skimage.feature import canny
from skimage.transform import rescale, resize
from torch.utils.data impo... | null |
15,398 | import abc
from typing import Dict, List
import numpy as np
import torch
from skimage import color
from skimage.segmentation import mark_boundaries
from . import colors
def visualize_mask_and_images(images_dict: Dict[str, np.ndarray], keys: List[str],
last_without_mask=True, rescale_keys=N... | null |
15,399 | import random
import colorsys
import numpy as np
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
The provided code snippet includes necessary dependencies for implementing the `generate_colors` function. Write a Python function `def generat... | Creates a random colormap to be used together with matplotlib. Useful for segmentation tasks :param nlabels: Number of labels (size of colormap) :param type: 'bright' for strong colors, 'soft' for pastel colors :param first_color_black: Option to use first color as black, True or False :param last_color_black: Option t... |
15,400 | import logging
import torch
import torch.nn.functional as F
from omegaconf import OmegaConf
from saicinpainting.training.data.datasets import make_constant_area_crop_params
from saicinpainting.training.losses.distance_weighting import make_mask_distance_weighter
from saicinpainting.training.losses.feature_matching impo... | null |
15,401 | import copy
import logging
from typing import Dict, Tuple
import pandas as pd
import pytorch_lightning as ptl
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DistributedSampler
from saicinpainting.evaluation import make_evaluator
from saicinpainting.training.data.datasets... | null |
15,402 | import copy
import logging
from typing import Dict, Tuple
import pandas as pd
import pytorch_lightning as ptl
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DistributedSampler
from saicinpainting.evaluation import make_evaluator
from saicinpainting.training.data.datasets... | null |
15,403 | import copy
import logging
from typing import Dict, Tuple
import pandas as pd
import pytorch_lightning as ptl
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DistributedSampler
from saicinpainting.evaluation import make_evaluator
from saicinpainting.training.data.datasets... | null |
15,404 | import logging
from abc import abstractmethod, ABC
import numpy as np
import sklearn
import sklearn.svm
import torch
import torch.nn as nn
import torch.nn.functional as F
from joblib import Parallel, delayed
from scipy import linalg
from models.ade20k import SegmentationModule, NUM_CLASS, segm_options
from .fid.incepti... | :param groups: group numbers for respective elements :return: dict of kind {group_idx: indices of the corresponding group elements} |
15,405 | import logging
from abc import abstractmethod, ABC
import numpy as np
import sklearn
import sklearn.svm
import torch
import torch.nn as nn
import torch.nn.functional as F
from joblib import Parallel, delayed
from scipy import linalg
from models.ade20k import SegmentationModule, NUM_CLASS, segm_options
from .fid.incepti... | null |
15,406 | import logging
from abc import abstractmethod, ABC
import numpy as np
import sklearn
import sklearn.svm
import torch
import torch.nn as nn
import torch.nn.functional as F
from joblib import Parallel, delayed
from scipy import linalg
from models.ade20k import SegmentationModule, NUM_CLASS, segm_options
from .fid.incepti... | null |
15,407 | import logging
from abc import abstractmethod, ABC
import numpy as np
import sklearn
import sklearn.svm
import torch
import torch.nn as nn
import torch.nn.functional as F
from joblib import Parallel, delayed
from scipy import linalg
from models.ade20k import SegmentationModule, NUM_CLASS, segm_options
from .fid.incepti... | null |
15,408 | import logging
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import models
FID_WEIGHTS_URL = 'https://github.com/mseitzer/pytorch-fid/releases/download/fid_weights/pt_inception-2015-12-05-6726825d.pth'
LOGGER = logging.getLogger(__name__)
class FIDInceptionA(models.inception.Incept... | Build pretrained Inception model for FID computation The Inception model for FID computation uses a different set of weights and has a slightly different structure than torchvision's Inception. This method first constructs torchvision's Inception and then patches the necessary parts that are different in the FID Incept... |
15,409 | import os
import pathlib
from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
import numpy as np
import torch
from imageio import imread
from PIL import Image, JpegImagePlugin
from scipy import linalg
from torch.nn.functional import adaptive_avg_pool2d
from torchvision.transforms import CenterCrop, Compos... | Calculates the FID of two paths |
15,410 | import os
import pathlib
from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
import numpy as np
import torch
from imageio import imread
from PIL import Image, JpegImagePlugin
from scipy import linalg
from torch.nn.functional import adaptive_avg_pool2d
from torchvision.transforms import CenterCrop, Compos... | null |
15,411 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,412 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,413 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,414 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,415 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
def rgb2lab(in_img, mean_cent=False):
from skimage import color
img_lab = color.rgb2lab(in_img)
if (mean_cent):
img_lab[:, :, 0] = img_lab[:, :, 0] - 50
return img_lab
def... | null |
15,416 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
def rgb2lab(in_img, mean_cent=False):
def tensor2np(tensor_obj):
def np2tensor(np_obj):
def rgb2lab(input):
def im2tensor(image, imtype=np.uint8, cent=1., factor=255. / 2.):
def im2tensor(image, ... | null |
15,417 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,418 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | Function computes Two Alternative Forced Choice (2AFC) score using distance function 'func' in dataset 'data_loader' INPUTS data_loader - CustomDatasetDataLoader object - contains a TwoAFCDataset inside func - callable distance function - calling d=func(in0,in1) should take 2 pytorch tensors with shape Nx3xXxY, and ret... |
15,419 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
def voc_ap(rec, prec, use_07_metric=False):
""" ap = voc_ap(rec, prec, [use_07_metric])
Compute VOC AP given precision and recall.
If use_07_metric is true, uses the
VOC 07 11 poi... | Function computes JND score using distance function 'func' in dataset 'data_loader' INPUTS data_loader - CustomDatasetDataLoader object - contains a JNDDataset inside func - callable distance function - calling d=func(in0,in1) should take 2 pytorch tensors with shape Nx3xXxY, and return pytorch array of length N OUTPUT... |
15,420 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,421 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,422 | import numpy as np
from skimage.metrics import structural_similarity
import torch
from saicinpainting.utils import get_shape
import os
from collections import OrderedDict
from scipy.ndimage import zoom
from tqdm import tqdm
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
from collections im... | null |
15,423 | import logging
import math
from typing import Dict
import numpy as np
import torch
import torch.nn as nn
import tqdm
from torch.utils.data import DataLoader
from saicinpainting.evaluation.utils import move_to_device
def ssim_fid100_f1(metrics, fid_scale=100):
ssim = metrics[('ssim', 'total')]['mean']
fid = met... | null |
15,424 | import logging
import math
from typing import Dict
import numpy as np
import torch
import torch.nn as nn
import tqdm
from torch.utils.data import DataLoader
from saicinpainting.evaluation.utils import move_to_device
def lpips_fid100_f1(metrics, fid_scale=100):
neg_lpips = 1 - metrics[('lpips', 'total')]['mean'] #... | null |
15,425 | from enum import Enum
import yaml
from easydict import EasyDict as edict
import torch.nn as nn
import torch
def load_yaml(path):
with open(path, 'r') as f:
return edict(yaml.safe_load(f)) | null |
15,426 | import glob
import os
import cv2
import PIL.Image as Image
import numpy as np
from torch.utils.data import Dataset
import torch.nn.functional as F
def ceil_modulo(x, mod):
def pad_img_to_modulo(img, mod):
channels, height, width = img.shape
out_height = ceil_modulo(height, mod)
out_width = ceil_modulo(widt... | null |
15,427 | import glob
import os
import cv2
import PIL.Image as Image
import numpy as np
from torch.utils.data import Dataset
import torch.nn.functional as F
def scale_image(img, factor, interpolation=cv2.INTER_AREA):
if img.shape[0] == 1:
img = img[0]
else:
img = np.transpose(img, (1, 2, 0))
img = c... | null |
15,428 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
The pro... | First stage of generalizing from countless2d. You have five slots: A, B, C, D, E You can decide if something is the winner by first checking for matches of three, then matches of two, then picking just one if the other two tries fail. In countless2d, you just check for matches of two and then pick one of them otherwise... |
15,429 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
The pro... | Extend countless5 to countless8. Same deal, except we also need to check for matches of length 4. |
15,430 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
The pro... | countless8 + dynamic programming. ~2x faster |
15,431 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
The pro... | Now write countless8 in such a way that it could be used to process an image. |
15,432 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
The pro... | Downsample x by factor using averaging. @return: The downsampled array, of the same type as x. |
15,433 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
def dow... | null |
15,434 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
The pro... | Downsample x by factor using striding. @return: The downsampled array, of the same type as x. |
15,435 | from six.moves import range
from PIL import Image
import numpy as np
import io
import time
import math
import random
import sys
from collections import defaultdict
from copy import deepcopy
from itertools import combinations
from functools import reduce
from tqdm import tqdm
from memory_profiler import profile
def coun... | null |
15,436 | from __future__ import print_function, division
import six
from six.moves import range
from collections import defaultdict
from functools import reduce
import operator
import io
import os
from PIL import Image
import math
import numpy as np
import random
import sys
import time
from tqdm import tqdm
from scipy import n... | null |
15,437 | from __future__ import print_function, division
import six
from six.moves import range
from collections import defaultdict
from functools import reduce
import operator
import io
import os
from PIL import Image
import math
import numpy as np
import random
import sys
import time
from tqdm import tqdm
from scipy import n... | To facilitate 2x2 downsampling segmentation, change an odd sized image into an even sized one. Works by mirroring the starting 1 pixel edge of the image on odd shaped sides. e.g. turn a 3x3x5 image into a 4x4x5 (the x and y are what are getting downsampled) For example: [ 3, 2, 4 ] => [ 3, 3, 2, 4 ] which is now easy t... |
15,438 | from __future__ import print_function, division
import six
from six.moves import range
from collections import defaultdict
from functools import reduce
import operator
import io
import os
from PIL import Image
import math
import numpy as np
import random
import sys
import time
from tqdm import tqdm
from scipy import n... | null |
15,439 | from __future__ import print_function, division
import six
from six.moves import range
from collections import defaultdict
from functools import reduce
import operator
import io
import os
from PIL import Image
import math
import numpy as np
import random
import sys
import time
from tqdm import tqdm
from scipy import n... | null |
15,440 | from __future__ import print_function, division
import six
from six.moves import range
from collections import defaultdict
from functools import reduce
import operator
import io
import os
from PIL import Image
import math
import numpy as np
import random
import sys
import time
from tqdm import tqdm
from scipy import n... | null |
15,441 | import torch
import torch.nn as nn
from torch.optim import Adam, SGD
from kornia.filters import gaussian_blur2d
from kornia.geometry.transform import resize
from kornia.morphology import erosion
from torch.nn import functional as F
import numpy as np
import cv2
from saicinpainting.evaluation.data import pad_tensor_to_... | Refines the inpainting of the network Parameters ---------- batch : dict image-mask batch, currently we assume the batchsize to be 1 inpainter : nn.Module the inpainting neural network gpu_ids : str the GPU ids of the machine to use. If only single GPU, use: "0," modulo : int pad the image to ensure dimension % modulo ... |
15,442 | import numpy as np
from skimage import io
from skimage.segmentation import mark_boundaries
def save_item_for_vis(item, out_file):
mask = item['mask'] > 0.5
if mask.ndim == 3:
mask = mask[0]
img = mark_boundaries(np.transpose(item['image'], (1, 2, 0)),
mask,
... | null |
15,443 | import numpy as np
from skimage import io
from skimage.segmentation import mark_boundaries
def save_mask_for_sidebyside(item, out_file):
mask = item['mask']# > 0.5
if mask.ndim == 3:
mask = mask[0]
mask = np.clip(mask * 255, 0, 255).astype('uint8')
io.imsave(out_file, mask) | null |
15,444 | import numpy as np
from skimage import io
from skimage.segmentation import mark_boundaries
def save_img_for_sidebyside(item, out_file):
img = np.transpose(item['image'], (1, 2, 0))
img = np.clip(img * 255, 0, 255).astype('uint8')
io.imsave(out_file, img) | null |
15,445 | import glob
import os
import shutil
import traceback
import hydra
from omegaconf import OmegaConf
import PIL.Image as Image
import numpy as np
from joblib import Parallel, delayed
from saicinpainting.evaluation.masks.mask import SegmentationMask, propose_random_square_crop
from saicinpainting.evaluation.utils import lo... | null |
15,446 | import os
import shutil
import torch
def get_checkpoint_files(s):
s = s.strip()
if ',' in s:
return [get_checkpoint_files(chunk) for chunk in s.split(',')]
return 'last.ckpt' if s == 'last' else f'{s}.ckpt' | null |
15,447 | import math
import os
import random
import braceexpand
import webdataset as wds
def is_good_key(key, cats):
return any(c in key for c in cats) | null |
15,454 | import bisect
import functools
import logging
import numbers
import os
import signal
import sys
import traceback
import warnings
import torch
from pytorch_lightning import seed_everything
LOGGER = logging.getLogger(__name__)
import platform
def print_traceback_handler(sig, frame):
def register_debug_signal_handlers(si... | null |
15,457 | import bisect
import functools
import logging
import numbers
import os
import signal
import sys
import traceback
import warnings
import torch
from pytorch_lightning import seed_everything
import platform
def get_has_ddp_rank():
def handle_ddp_subprocess():
def main_decorator(main_func):
@functools.wraps(ma... | null |
15,458 | import bisect
import functools
import logging
import numbers
import os
import signal
import sys
import traceback
import warnings
import torch
from pytorch_lightning import seed_everything
import platform
def get_has_ddp_rank():
master_port = os.environ.get('MASTER_PORT', None)
node_rank = os.environ.get('NODE_R... | null |
15,471 | import math
import random
import hashlib
import logging
from enum import Enum
import cv2
import numpy as np
from saicinpainting.evaluation.masks.mask import SegmentationMask
from saicinpainting.utils import LinearRamp
class DrawMethod(Enum):
def make_random_irregular_mask(shape, max_angle=4, max_len=60, max_width=20, ... | null |
15,474 | import math
import random
import hashlib
import logging
from enum import Enum
import cv2
import numpy as np
from saicinpainting.evaluation.masks.mask import SegmentationMask
from saicinpainting.utils import LinearRamp
class DumbAreaMaskGenerator:
min_ratio = 0.1
max_ratio = 0.35
default_ratio = 0.225
de... | null |
15,477 | import glob
import logging
import os
import random
import albumentations as A
import cv2
import numpy as np
import torch
import torch.nn.functional as F
import webdataset
from omegaconf import open_dict, OmegaConf
from skimage.feature import canny
from skimage.transform import rescale, resize
from torch.utils.data impo... | null |
15,489 | import os
import pathlib
from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
import numpy as np
import torch
from imageio import imread
from PIL import Image, JpegImagePlugin
from scipy import linalg
from torch.nn.functional import adaptive_avg_pool2d
from torchvision.transforms import CenterCrop, Compos... | Calculates the FID of two paths |
15,490 | import os
import pathlib
from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
import numpy as np
import torch
from imageio import imread
from PIL import Image, JpegImagePlugin
from scipy import linalg
from torch.nn.functional import adaptive_avg_pool2d
from torchvision.transforms import CenterCrop, Compos... | null |
15,506 | from enum import Enum
import yaml
from easydict import EasyDict as edict
import torch.nn as nn
import torch
def move_to_device(obj, device):
if isinstance(obj, nn.Module):
return obj.to(device)
if torch.is_tensor(obj):
return obj.to(device)
if isinstance(obj, (tuple, list)):
return ... | null |
15,507 | import glob
import os
import cv2
import PIL.Image as Image
import numpy as np
from torch.utils.data import Dataset
import torch.nn.functional as F
def load_image(fname, mode='RGB', return_orig=False):
img = np.array(Image.open(fname).convert(mode))
if img.ndim == 3:
img = np.transpose(img, (2, 0, 1))
... | null |
15,508 | import glob
import os
import cv2
import PIL.Image as Image
import numpy as np
from torch.utils.data import Dataset
import torch.nn.functional as F
def ceil_modulo(x, mod):
if x % mod == 0:
return x
return (x // mod + 1) * mod
def pad_img_to_modulo(img, mod):
channels, height, width = img.shape
... | null |
15,509 | import glob
import os
import cv2
import PIL.Image as Image
import numpy as np
from torch.utils.data import Dataset
import torch.nn.functional as F
def ceil_modulo(x, mod):
if x % mod == 0:
return x
return (x // mod + 1) * mod
def pad_tensor_to_modulo(img, mod):
batch_size, channels, height, width =... | null |
15,511 | import enum
from copy import deepcopy
import numpy as np
from skimage import img_as_ubyte
from skimage.transform import rescale, resize
from .countless.countless2d import zero_corrected_countless
def propose_random_square_crop(mask, min_overlap=0.5):
height, width = mask.shape
mask_ys, mask_xs = np.where(mask ... | null |
15,520 | from __future__ import print_function, division
import six
from six.moves import range
from collections import defaultdict
from functools import reduce
import operator
import io
import os
from PIL import Image
import math
import numpy as np
import random
import sys
import time
from tqdm import tqdm
from scipy import n... | null |
15,529 | import os
import numpy as np
import tqdm
from skimage import io
from skimage.segmentation import mark_boundaries
from saicinpainting.evaluation.data import InpaintingDataset
from saicinpainting.evaluation.vis import save_item_for_vis
def save_mask_for_sidebyside(item, out_file):
mask = item['mask']# > 0.5
if m... | null |
15,530 | import os
import numpy as np
import tqdm
from skimage import io
from skimage.segmentation import mark_boundaries
from saicinpainting.evaluation.data import InpaintingDataset
from saicinpainting.evaluation.vis import save_item_for_vis
def save_img_for_sidebyside(item, out_file):
img = np.transpose(item['image'], (1... | null |
15,531 | import os
import numpy as np
import tqdm
from skimage import io
from skimage.segmentation import mark_boundaries
from saicinpainting.evaluation.data import InpaintingDataset
from saicinpainting.evaluation.vis import save_item_for_vis
def save_masked_img_for_sidebyside(item, out_file):
mask = item['mask']
img ... | null |
15,532 | import cv2
import numpy as np
import sklearn
import torch
import os
import pickle
import pandas as pd
import matplotlib.pyplot as plt
from joblib import Parallel, delayed
from saicinpainting.evaluation.data import PrecomputedInpaintingResultsDataset, load_image
from saicinpainting.evaluation.losses.fid.inception import... | null |
15,533 | import cv2
import numpy as np
import sklearn
import torch
import os
import pickle
import pandas as pd
import matplotlib.pyplot as plt
from joblib import Parallel, delayed
from saicinpainting.evaluation.data import PrecomputedInpaintingResultsDataset, load_image
from saicinpainting.evaluation.losses.fid.inception import... | null |
15,534 | import cv2
import numpy as np
import sklearn
import torch
import os
import pickle
import pandas as pd
import matplotlib.pyplot as plt
from joblib import Parallel, delayed
from saicinpainting.evaluation.data import PrecomputedInpaintingResultsDataset, load_image
from saicinpainting.evaluation.losses.fid.inception import... | null |
15,535 | import glob
import os
import shutil
import traceback
import PIL.Image as Image
import numpy as np
from joblib import Parallel, delayed
from saicinpainting.evaluation.masks.mask import SegmentationMask, propose_random_square_crop
from saicinpainting.evaluation.utils import load_yaml, SmallMode
from saicinpainting.traini... | null |
15,536 | import os
from argparse import ArgumentParser
def ssim_fid100_f1(metrics, fid_scale=100):
ssim = metrics.loc['total', 'ssim']['mean']
fid = metrics.loc['total', 'fid']['mean']
fid_rel = max(0, fid_scale - fid) / fid_scale
f1 = 2 * ssim * fid_rel / (ssim + fid_rel + 1e-3)
return f1 | null |
15,537 | import os
from argparse import ArgumentParser
def find_best_checkpoint(model_list, models_dir):
with open(model_list) as f:
models = [m.strip() for m in f.readlines()]
with open(f'{model_list}_best', 'w') as f:
for model in models:
print(model)
best_f1 = 0
be... | null |
15,538 | import glob
import os
import re
import tensorflow as tf
from torch.utils.tensorboard import SummaryWriter
DROP_RULES = [
re.compile(r'_std$', re.I)
]
def need_drop(tag):
for rule in DROP_RULES:
if rule.search(tag):
return True
return False | null |
15,539 | import glob
import os
import re
import tensorflow as tf
from torch.utils.tensorboard import SummaryWriter
GROUPING_RULES = [
re.compile(r'^(?P<group>train|test|val|extra_val_.*?(256|512))_(?P<title>.*)', re.I)
]
def get_group_and_title(tag):
for rule in GROUPING_RULES:
match = rule.search(tag)
... | null |
15,540 | import os
import cv2
import numpy as np
import torch
from skimage import io
from skimage.transform import resize
from torch.utils.data import Dataset
from saicinpainting.evaluation.evaluator import InpaintingEvaluator
from saicinpainting.evaluation.losses.base_loss import SSIMScore, LPIPSScore, FIDScore
def create_rec... | null |
15,541 | import os
import sys
import numpy as np
import torch
def color_encode(labelmap, colors, mode='RGB'):
labelmap = labelmap.astype('int')
labelmap_rgb = np.zeros((labelmap.shape[0], labelmap.shape[1], 3),
dtype=np.uint8)
for label in np.unique(labelmap):
if label < 0:
... | null |
15,542 | import torch.nn as nn
import math
from .utils import load_url
from .segm_lib.nn import SynchronizedBatchNorm2d
BatchNorm2d = SynchronizedBatchNorm2d
def conv_bn(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
BatchNorm2d(oup),
nn.ReLU6(inplace=True)
... | null |
15,543 | import torch.nn as nn
import math
from .utils import load_url
from .segm_lib.nn import SynchronizedBatchNorm2d
BatchNorm2d = SynchronizedBatchNorm2d
def conv_1x1_bn(inp, oup):
return nn.Sequential(
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
BatchNorm2d(oup),
nn.ReLU6(inplace=True)
) | null |
15,544 | import torch.nn as nn
import math
from .utils import load_url
from .segm_lib.nn import SynchronizedBatchNorm2d
model_urls = {
'mobilenetv2': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/mobilenet_v2.pth.tar',
}
class MobileNetV2(nn.Module):
def __init__(self, n_class=1000, input_size=224, width_mu... | Constructs a MobileNet_V2 model. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet |
15,548 | import torch.cuda as cuda
import torch.nn as nn
import torch
import collections
from torch.nn.parallel._functions import Gather
The provided code snippet includes necessary dependencies for implementing the `dict_gather` function. Write a Python function `def dict_gather(outputs, target_device, dim=0)` to solve the fo... | Gathers variables from different GPUs on a specified device (-1 means the CPU), with dictionary support. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.