id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
1,959 | import torch
from torch.nn import functional as F
from torch import nn
from detectron2.layers import cat
from detectron2.modeling.poolers import ROIPooler
from .utils import aligned_bilinear, compute_loss, compute_loss_softmax
from fvcore.nn import sigmoid_focal_loss_jit
from adet.utils.comm import reduce_sum
from dete... | :param inputs: a list of inputs :param weights: [w0, w1, ...] :param bias: [b0, b1, ...] :return: |
1,960 | import torch.nn as nn
from detectron2.layers.batch_norm import NaiveSyncBatchNorm
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone import Backbone
from .lpf import *
The provided code snippet includes necessary dependencies for implementing the `conv3x3` function. Writ... | 3x3 convolution with padding |
1,961 | import torch.nn as nn
from detectron2.layers.batch_norm import NaiveSyncBatchNorm
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone import Backbone
from .lpf import *
The provided code snippet includes necessary dependencies for implementing the `conv1x1` function. Writ... | 1x1 convolution |
1,962 | import torch
import torch.nn.parallel
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def get_pad_layer(pad_type):
if(pad_type in ['refl','reflect']):
PadLayer = nn.ReflectionPad2d
elif(pad_type in ['repl','replicate']):
PadLayer = nn.ReplicationPad2d
elif(pad_type=... | null |
1,963 | import torch
import torch.nn.parallel
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def get_pad_layer_1d(pad_type):
if(pad_type in ['refl', 'reflect']):
PadLayer = nn.ReflectionPad1d
elif(pad_type in ['repl', 'replicate']):
PadLayer = nn.ReplicationPad1d
elif(pad_... | null |
1,964 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,965 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | 3x3 convolution with padding |
1,966 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,967 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,968 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,969 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,970 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,971 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,972 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,973 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,974 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | null |
1,975 | import math
from os.path import join
import torch
from torch import nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import... | Args: cfg: a detectron2 CfgNode Returns: backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`. |
1,976 | from torch import nn
from torch.nn import BatchNorm2d
from detectron2.layers import Conv2d
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone import Backbone
def conv_bn(inp, oup, stride):
return nn.Sequential(
Conv2d(inp, oup, 3, stride, 1, bias=False),
... | null |
1,977 | from torch import nn
from torch.nn import BatchNorm2d
from detectron2.layers import Conv2d
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone import Backbone
def conv_1x1_bn(inp, oup):
return nn.Sequential(
Conv2d(inp, oup, 1, 1, 0, bias=False),
Batch... | null |
1,978 | from torch import nn
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import FPN, build_resnet_backbone
from detectron2.layers import ShapeSpec
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from .resnet_lpf import build_resnet_lpf_backbone
... | Args: cfg: a detectron2 CfgNode Returns: backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`. |
1,979 | import torch
import torch.nn.functional as F
from torch import nn
from detectron2.layers import Conv2d, ShapeSpec, get_norm
from detectron2.modeling.backbone import Backbone, build_resnet_backbone
from detectron2.modeling import BACKBONE_REGISTRY
from .mobilenet import build_mnv2_backbone
def swish(x):
return x * ... | null |
1,980 | import torch
import torch.nn.functional as F
from torch import nn
from detectron2.layers import Conv2d, ShapeSpec, get_norm
from detectron2.modeling.backbone import Backbone, build_resnet_backbone
from detectron2.modeling import BACKBONE_REGISTRY
from .mobilenet import build_mnv2_backbone
def split_name(name):
for... | null |
1,981 | import torch
import torch.nn.functional as F
from torch import nn
from detectron2.layers import Conv2d, ShapeSpec, get_norm
from detectron2.modeling.backbone import Backbone, build_resnet_backbone
from detectron2.modeling import BACKBONE_REGISTRY
from .mobilenet import build_mnv2_backbone
The provided code snippet inc... | Assert that each stride is 2x times its preceding stride, i.e. "contiguous in log2". |
1,982 | import torch
import torch.nn.functional as F
from torch import nn
from detectron2.layers import Conv2d, ShapeSpec, get_norm
from detectron2.modeling.backbone import Backbone, build_resnet_backbone
from detectron2.modeling import BACKBONE_REGISTRY
from .mobilenet import build_mnv2_backbone
class BiFPN(Backbone):
"""... | Args: cfg: a detectron2 CfgNode Returns: backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`. |
1,983 | from collections import OrderedDict
import torch
import torch.nn as nn
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import Backbone
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone.fpn import FPN
from dete... | 3x3 convolution with padding |
1,984 | from collections import OrderedDict
import torch
import torch.nn as nn
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import Backbone
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone.fpn import FPN
from dete... | 1x1 convolution with padding |
1,985 | from collections import OrderedDict
import torch
import torch.nn as nn
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import Backbone
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone.fpn import FPN
from dete... | Args: cfg: a detectron2 CfgNode Returns: backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`. |
1,986 | from collections import OrderedDict
import torch
import torch.nn as nn
import torch.nn.functional as F
import fvcore.nn.weight_init as weight_init
from detectron2.modeling.backbone import Backbone
from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
from detectron2.modeling.backbone.fpn import FPN
from dete... | Args: cfg: a detectron2 CfgNode Returns: backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`. |
1,987 | import sys
import torch
from torch import nn
from detectron2.layers import cat
from detectron2.modeling.poolers import (
ROIPooler, convert_boxes_to_pooler_format, assign_boxes_to_levels
)
from adet.layers import BezierAlign
from adet.structures import Beziers
def _box_max_size(boxes):
box = boxes.tensor
ma... | null |
1,988 | import sys
import torch
from torch import nn
from detectron2.layers import cat
from detectron2.modeling.poolers import (
ROIPooler, convert_boxes_to_pooler_format, assign_boxes_to_levels
)
from adet.layers import BezierAlign
from adet.structures import Beziers
def _bezier_height(beziers):
beziers = beziers.tens... | null |
1,989 | import logging
import torch
import torch.nn.functional as F
from detectron2.layers import cat
from detectron2.structures import Instances, Boxes
from adet.utils.comm import get_world_size
from fvcore.nn import sigmoid_focal_loss_jit
from adet.utils.comm import reduce_sum, compute_ious
from adet.layers import ml_nms
def... | null |
1,990 | import logging
from typing import List
import torch
import torch.nn as nn
import torch.nn.functional as F
from detectron2.layers import cat
from detectron2.structures import Instances, Boxes, pairwise_iou
from detectron2.utils.comm import get_world_size
from detectron2.modeling.matcher import Matcher
from fvcore.nn imp... | null |
1,991 | import os
import argparse
import numpy as np
from torch.utils.data import DataLoader
from MaskLoader import MaskLoader
from utils import (
IOUMetric,
transform,
inverse_transform,
direct_sigmoid,
inverse_sigmoid
)
def parse_args():
parser = argparse.ArgumentParser(description='Evaluation for PC... | null |
1,992 | import numpy as np
The provided code snippet includes necessary dependencies for implementing the `direct_sigmoid` function. Write a Python function `def direct_sigmoid(x)` to solve the following problem:
Apply the sigmoid operation.
Here is the function:
def direct_sigmoid(x):
"""Apply the sigmoid operation.
... | Apply the sigmoid operation. |
1,993 | import numpy as np
The provided code snippet includes necessary dependencies for implementing the `transform` function. Write a Python function `def transform(X, components_, explained_variance_, mean_=None, whiten=False)` to solve the following problem:
Apply dimensionality reduction to X. X is projected on the first... | Apply dimensionality reduction to X. X is projected on the first principal components previously extracted from a training set. Parameters ---------- X: array-like, shape (n_samples, n_features) New data, where n_samples is the number of samples and n_features is the number of features. components_: array-like, shape (... |
1,994 | import numpy as np
The provided code snippet includes necessary dependencies for implementing the `inverse_transform` function. Write a Python function `def inverse_transform(X, components_, explained_variance_, mean_=None, whiten=False)` to solve the following problem:
Transform data back to its original space. In ot... | Transform data back to its original space. In other words, return an input X_original whose transform would be X. Parameters ---------- X : array-like, shape (n_samples, n_components) New data, where n_samples is the number of samples and n_components is the number of components. components_: array-like, shape (n_compo... |
1,995 | import os
import argparse
import time
import numpy as np
import torch
from torch.utils.data import DataLoader
from sklearn.decomposition import IncrementalPCA
from MaskLoader import MaskLoader
from utils import inverse_sigmoid
VALUE_MAX = 0.05
VALUE_MIN = 0.01
def inverse_sigmoid(x):
"""Apply the inverse sigmoid o... | null |
1,996 | import os
import argparse
import time
import numpy as np
import torch
from torch.utils.data import DataLoader
from sklearn.decomposition import IncrementalPCA
from MaskLoader import MaskLoader
from utils import inverse_sigmoid
def parse_args():
parser = argparse.ArgumentParser(description='PCA Mask Encoding for lo... | null |
1,997 | import math
from typing import Dict, List
import torch
from torch import nn
from torch.nn import functional as F
from detectron2.layers import ShapeSpec, cat
from detectron2.modeling import ROI_HEADS_REGISTRY
from adet.layers import conv_with_kaiming_uniform
from ..poolers import TopPooler
from .attn_predictor import A... | null |
1,998 | import math
from typing import Dict, List
import torch
from torch import nn
from torch.nn import functional as F
from detectron2.layers import ShapeSpec, cat
from detectron2.modeling import ROI_HEADS_REGISTRY
from adet.layers import conv_with_kaiming_uniform
from ..poolers import TopPooler
from .attn_predictor import A... | null |
1,999 | import logging
from torch import nn
from detectron2.modeling.meta_arch.build import META_ARCH_REGISTRY
from detectron2.modeling import ProposalNetwork, GeneralizedRCNN
from detectron2.utils.events import get_event_storage
from detectron2.utils.logger import log_first_n
from detectron2.modeling.postprocessing import det... | In addition to the post processing of detectron2, we add scalign for bezier control points. |
2,000 | import logging
from torch import nn
from detectron2.modeling.meta_arch.build import META_ARCH_REGISTRY
from detectron2.modeling import ProposalNetwork, GeneralizedRCNN
from detectron2.utils.events import get_event_storage
from detectron2.utils.logger import log_first_n
from detectron2.modeling.postprocessing import det... | null |
2,001 | import cv2
import torch
import torch.nn.functional as F
def imresize(img,
size,
return_scale=False,
interpolation='bilinear',
out=None):
"""Resize image to a given size.
Args:
img (ndarray): The input image.
size (tuple[int]): Target size (w, h... | Resize image to the same size of a given image. Args: img (ndarray): The input image. dst_img (ndarray): The target image. return_scale (bool): Whether to return `w_scale` and `h_scale`. interpolation (str): Same as :func:`resize`. Returns: tuple or ndarray: (`resized_img`, `w_scale`, `h_scale`) or `resized_img`. |
2,002 | import cv2
import torch
import torch.nn.functional as F
def imresize(img,
size,
return_scale=False,
interpolation='bilinear',
out=None):
"""Resize image to a given size.
Args:
img (ndarray): The input image.
size (tuple[int]): Target size (w, h... | Resize image while keeping the aspect ratio. Args: img (ndarray): The input image. scale (float | tuple[int]): The scaling factor or maximum size. If it is a float number, then the image will be rescaled by this factor, else if it is a tuple of 2 integers, then the image will be rescaled as large as possible within the... |
2,003 | import cv2
import torch
import torch.nn.functional as F
def center_of_mass(bitmasks):
_, h, w = bitmasks.size()
ys = torch.arange(0, h, dtype=torch.float32, device=bitmasks.device)
xs = torch.arange(0, w, dtype=torch.float32, device=bitmasks.device)
m00 = bitmasks.sum(dim=-1).sum(dim=-1).clamp(min=1e... | null |
2,004 | import cv2
import torch
import torch.nn.functional as F
def point_nms(heat, kernel=2):
# kernel must be 2
hmax = F.max_pool2d(heat, (kernel, kernel), stride=1, padding=1)
keep = (hmax[:, :, :-1, :-1] == heat).float()
return heat * keep | null |
2,005 | import cv2
import torch
import torch.nn.functional as F
def matrix_nms(cate_labels, seg_masks, sum_masks, cate_scores, sigma=2.0, kernel='gaussian'):
n_samples = len(cate_labels)
if n_samples == 0:
return []
seg_masks = seg_masks.reshape(n_samples, -1).float()
# inter.
inter_matrix = torch... | null |
2,006 | import cv2
import torch
import torch.nn.functional as F
def mask_nms(cate_labels, seg_masks, sum_masks, cate_scores, nms_thr=0.5):
n_samples = len(cate_scores)
if n_samples == 0:
return []
keep = seg_masks.new_ones(cate_scores.shape)
seg_masks = seg_masks.float()
for i in range(n_samples ... | null |
2,007 | import torch
from torch import nn
import torch.nn.functional as F
from fvcore.nn import sigmoid_focal_loss_jit
def dice_loss(input, target):
input = input.contiguous().view(input.size()[0], -1)
target = target.contiguous().view(target.size()[0], -1).float()
a = torch.sum(input * target, 1)
b = torch.s... | null |
2,008 | import torch
from torch import nn
import torch.nn.functional as F
from fvcore.nn import sigmoid_focal_loss_jit
def weight_reduce_loss(loss, weight=None, reduction='mean', avg_factor=None):
"""Apply element-wise weight and reduce loss.
Args:
loss (Tensor): Element-wise loss.
weight (Tensor): Elem... | null |
2,009 | import logging
import torch
from torch import nn
import torch.nn.functional as F
from detectron2.layers import cat
from detectron2.structures import Instances, Boxes
from detectron2.utils.comm import get_world_size
from fvcore.nn import sigmoid_focal_loss_jit
from adet.utils.comm import reduce_sum, reduce_mean, compute... | null |
2,010 | from typing import Dict
import math
import torch
from torch import nn
from fvcore.nn import sigmoid_focal_loss_jit
from detectron2.layers import ShapeSpec
from adet.layers import conv_with_kaiming_uniform
from adet.utils.comm import aligned_bilinear
class MaskBranch(nn.Module):
def __init__(self, cfg, input_shape: ... | null |
2,011 | import torch
from torch.nn import functional as F
from torch import nn
from adet.utils.comm import compute_locations, aligned_bilinear
def dice_coefficient(x, target):
eps = 1e-5
n_inst = x.size(0)
x = x.reshape(n_inst, -1)
target = target.reshape(n_inst, -1)
intersection = (x * target).sum(dim=1)
... | null |
2,012 | import torch
from torch.nn import functional as F
from torch import nn
from adet.utils.comm import compute_locations, aligned_bilinear
def unfold_wo_center(x, kernel_size, dilation):
def compute_pairwise_term(mask_logits, pairwise_size, pairwise_dilation):
assert mask_logits.dim() == 4
log_fg_prob = F.logsig... | null |
2,013 | import torch
from torch.nn import functional as F
from torch import nn
from adet.utils.comm import compute_locations, aligned_bilinear
def parse_dynamic_params(params, channels, weight_nums, bias_nums):
assert params.dim() == 2
assert len(weight_nums) == len(bias_nums)
assert params.size(1) == sum(weight_n... | null |
2,014 | import torch
from torch.nn import functional as F
from torch import nn
from adet.utils.comm import compute_locations, aligned_bilinear
class DynamicMaskHead(nn.Module):
def __init__(self, cfg):
def mask_heads_forward(self, features, weights, biases, num_insts):
def mask_heads_forward_with_coords(
... | null |
2,015 | import logging
from skimage import color
import torch
from torch import nn
import torch.nn.functional as F
from detectron2.structures import ImageList
from detectron2.modeling.proposal_generator import build_proposal_generator
from detectron2.modeling.backbone import build_backbone
from detectron2.modeling.meta_arch.bu... | null |
2,016 | from collections import namedtuple
from adet.evaluation import rrc_evaluation_funcs_ic15 as rrc_evaluation_funcs
import importlib
import sys
import math
from rapidfuzz import string_metric
WORD_SPOTTING =True
def default_evaluation_params():
"""
default_evaluation_params: Default parameters to use for the vali... | null |
2,017 | import contextlib
import copy
import io
import itertools
import json
import logging
import numpy as np
import os
import re
import torch
from collections import OrderedDict
from fvcore.common.file_io import PathManager
from pycocotools.coco import COCO
from detectron2.utils import comm
from detectron2.data import Metada... | null |
2,018 | import json
import sy
import zipfile
import re
import sys
import os
import codecs
import importlib
The provided code snippet includes necessary dependencies for implementing the `load_zip_file_keys` function. Write a Python function `def load_zip_file_keys(file,fileNameRegExp='')` to solve the following problem:
Retur... | Returns an array with the entries of the ZIP file that match with the regular expression. The key's are the names or the file or the capturing group definied in the fileNameRegExp |
2,019 | import json
import sysys.path.append('./')
import zipfile
import re
import sys
import os
import codecs
import importlib
The provided code snippet includes necessary dependencies for implementing the `main_validation` function. Write a Python function `def main_validation(default_evaluation_params_fn,validate_data_fn)`... | This process validates a method Params: default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation validate_data_fn: points to a method that validates the corrct format of the submission |
2,020 | from collections import namedtuple
from adet.evaluation import rrc_evaluation_funcs
import importlib
import sys
import math
from rapidfuzz import string_metric
WORD_SPOTTING =True
def default_evaluation_params():
"""
default_evaluation_params: Default parameters to use for the validation and evaluation.
""... | null |
2,021 | import json
import sysys.path.append('./')
import zipfile
import re
import sys
import os
import codecs
import importlib
from io import StringIO
from shapely.geometry import *
def print_help():
sys.stdout.write('Usage: python %s.py -g=<gtFile> -s=<submFile> [-o=<outputFolder> -p=<jsonParams>]' %sys.argv[0])
sys... | null |
2,022 | import json
import sy
import zipfile
import re
import sys
import os
import codecs
import importlib
from io import StringIO
from shapely.geometry import *
The provided code snippet includes necessary dependencies for implementing the `load_zip_file_keys` function. Write a Python function `def load_zip_file_keys(file,fi... | Returns an array with the entries of the ZIP file that match with the regular expression. The key's are the names or the file or the capturing group definied in the fileNameRegExp |
2,023 | import json
import sysys.path.append('./')
import zipfile
import re
import sys
import os
import codecs
import importlib
from io import StringIO
from shapely.geometry import *
The provided code snippet includes necessary dependencies for implementing the `main_validation` function. Write a Python function `def main_val... | This process validates a method Params: default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation validate_data_fn: points to a method that validates the corrct format of the submission |
2,024 | from detectron2.config import CfgNode
_C.MODEL.MOBILENET = False
_C.MODEL.BACKBONE.ANTI_ALIAS = False
_C.MODEL.RESNETS.DEFORM_INTERVAL = 1
_C.INPUT.HFLIP_TRAIN = True
_C.INPUT.CROP.CROP_INSTANCE = True
_C.INPUT.IS_ROTATE = False
_C.MODEL.FCOS = CN()
_C.MODEL.FCOS.NUM_CLASSES = 80
_C.MODEL.FCOS.IN_FEATURES = ["p3", "... | Get a copy of the default config. Returns: a detectron2 CfgNode instance. |
2,025 | import torch
import torch.nn.functional as F
import torch.distributed as dist
from detectron2.utils.comm import get_world_size
def reduce_sum(tensor):
world_size = get_world_size()
if world_size < 2:
return tensor
tensor = tensor.clone()
dist.all_reduce(tensor, op=dist.ReduceOp.SUM)
return t... | null |
2,026 | import torch
import torch.nn.functional as F
import torch.distributed as dist
from detectron2.utils.comm import get_world_size
def aligned_bilinear(tensor, factor):
assert tensor.dim() == 4
assert factor >= 1
assert int(factor) == factor
if factor == 1:
return tensor
h, w = tensor.size()[... | null |
2,027 | import torch
import torch.nn.functional as F
import torch.distributed as dist
from detectron2.utils.comm import get_world_size
def compute_locations(h, w, stride, device):
shifts_x = torch.arange(
0, w * stride, step=stride,
dtype=torch.float32, device=device
)
shifts_y = torch.arange(
... | null |
2,028 | from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
import operator
from functools import reduce
def is_pruned(layer):
try:
layer.mask
return True
except AttributeError:
return False
def is_l... | null |
2,029 | import argparse
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_logger
from predictor import VisualizationDemo
from adet.config import get_cfg
def setup_cfg(args):
# load config fr... | null |
2,030 | import argparse
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_logger
from predictor import VisualizationDemo
from adet.config import get_cfg
def get_parser():
parser = argparse.A... | null |
2,031 | import argparse
import os
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
import types
import torch
from torch import nn
from torch.nn import functional as F
from copy import deepcopy
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_l... | null |
2,032 | import argparse
import os
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
import types
import torch
from torch import nn
from torch.nn import functional as F
from copy import deepcopy
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_l... | null |
2,033 | import argparse
import os
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
import types
import torch
from torch import nn
from torch.nn import functional as F
from copy import deepcopy
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_l... | null |
2,034 | import argparse
import os
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
import types
import torch
from torch import nn
from torch.nn import functional as F
from copy import deepcopy
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_l... | null |
2,035 | import argparse
import os
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
import types
import torch
from torch import nn
from torch.nn import functional as F
from copy import deepcopy
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_l... | null |
2,036 | import argparse
import os
import glob
import multiprocessing as mp
import os
import time
import cv2
import tqdm
import types
import torch
from torch import nn
from torch.nn import functional as F
from copy import deepcopy
from detectron2.data.detection_utils import read_image
from detectron2.utils.logger import setup_l... | null |
2,037 | import time
import functools
import multiprocessing as mp
import numpy as np
import os
from lvis import LVIS
from pycocotools import mask as maskUtils
def _process_instance_to_semantic(anns, output_semantic, img):
img_size = (img["height"], img["width"])
output = np.zeros(img_size, dtype=np.uint8)
for ann i... | Create semantic segmentation annotations from panoptic segmentation annotations, to be used by PanopticFPN. It maps all thing categories to contiguous ids starting from 1, and maps all unlabeled pixels to class 0 Args: instance_json (str): path to the instance json file, in COCO's format. sem_seg_root (str): a director... |
2,038 | import numpy as np
import cv2
import os
import json
error_list = ['23382.png', '23441.png', '20714.png', '20727.png', '23300.png', '21200.png']
def mask2box(mask):
def gen_coco(phase):
result = {
"info": {"description": "PIC2.0 dataset."},
"categories": [
{"supercategory": "none", "id":... | null |
2,039 | import time
import functools
import multiprocessing as mp
import numpy as np
import os
import argparse
from pycocotools.coco import COCO
from pycocotools import mask as maskUtils
from detectron2.data.datasets.builtin_meta import _get_coco_instances_meta
def _process_instance_to_semantic(anns, output_semantic, img, cate... | Create semantic segmentation annotations from panoptic segmentation annotations, to be used by PanopticFPN. It maps all thing categories to contiguous ids starting from 1, and maps all unlabeled pixels to class 0 Args: instance_json (str): path to the instance json file, in COCO's format. sem_seg_root (str): a director... |
2,040 | import time
import functools
import multiprocessing as mp
import numpy as np
import os
import argparse
from pycocotools.coco import COCO
from pycocotools import mask as maskUtils
from detectron2.data.datasets.builtin_meta import _get_coco_instances_meta
def get_parser():
parser = argparse.ArgumentParser(descriptio... | null |
2,041 | import argparse
import torch
def get_parser():
parser = argparse.ArgumentParser(description="Keep only model in ckpt")
parser.add_argument(
"--path",
default="output/person/blendmask/R_50_1x/",
help="path to model weights",
)
parser.add_argument(
"--name",
defaul... | null |
2,042 | import argparse
from collections import OrderedDict
import torch
def get_parser():
parser = argparse.ArgumentParser(description="FCOS Detectron2 Converter")
parser.add_argument(
"--model",
default="weights/blendmask/person/R_50_1x.pth",
metavar="FILE",
help="path to model weight... | null |
2,043 | import argparse
from collections import OrderedDict
import torch
def rename_resnet_param_names(ckpt_state_dict):
converted_state_dict = OrderedDict()
for key in ckpt_state_dict.keys():
value = ckpt_state_dict[key]
key = key.replace("centerness", "ctrness")
converted_state_dict[key] = v... | null |
2,044 | import argparse
import numpy as np
import os
from itertools import chain
import cv2
import tqdm
from PIL import Image
from detectron2.data import DatasetCatalog, MetadataCatalog, build_detection_train_loader
from detectron2.data import detection_utils as utils
from detectron2.data.build import filter_images_with_few_ke... | null |
2,045 | import argparse
import numpy as np
import os
from itertools import chain
import cv2
import tqdm
from PIL import Image
from detectron2.data import DatasetCatalog, MetadataCatalog, build_detection_train_loader
from detectron2.data import detection_utils as utils
from detectron2.data.build import filter_images_with_few_ke... | null |
2,046 | import argparse
import numpy as np
import os
from itertools import chain
import cv2
import tqdm
from PIL import Image
from detectron2.data import DatasetCatalog, MetadataCatalog, build_detection_train_loader
from detectron2.data import detection_utils as utils
from detectron2.data.build import filter_images_with_few_ke... | null |
2,047 | import logging
import os
from collections import OrderedDict
import torch
from torch.nn.parallel import DistributedDataParallel
import detectron2.utils.comm as comm
from detectron2.data import MetadataCatalog, build_detection_train_loader
from detectron2.engine import DefaultTrainer, default_argument_parser, default_se... | Create configs and perform basic setups. |
2,048 | import argparse
from collections import OrderedDict
import torch
def get_parser():
parser = argparse.ArgumentParser(description="FCOS Detectron2 Converter")
parser.add_argument(
"--model",
default="weights/fcos_R_50_1x_official.pth",
metavar="FILE",
help="path to model weights",... | null |
2,049 | import argparse
from collections import OrderedDict
import torch
def rename_resnet_param_names(ckpt_state_dict):
converted_state_dict = OrderedDict()
for key in ckpt_state_dict.keys():
value = ckpt_state_dict[key]
key = key.replace("module.", "")
key = key.replace("body", "bottom_up")
... | null |
2,050 | import collections.abc
import os
import os.path as osp
from torch import nn
import kornia.augmentation as K
import pydiffvg
import save_svg
import cv2
from ttf import font_string_to_svgs, normalize_letter_size
import torch
import numpy as np
def normalize_letter_size(dest_path, font, txt):
fontname = os.path.split... | null |
2,051 | import collections.abc
import os
import os.path as osp
from torch import nn
import kornia.augmentation as K
import pydiffvg
import save_svg
import cv2
from ttf import font_string_to_svgs, normalize_letter_size
import torch
import numpy as np
def get_data_augs(cut_size):
augmentations = []
augmentations.append(... | null |
2,052 | import collections.abc
import os
import os.path as osp
from torch import nn
import kornia.augmentation as K
import pydiffvg
import save_svg
import cv2
from ttf import font_string_to_svgs, normalize_letter_size
import torch
import numpy as np
The provided code snippet includes necessary dependencies for implementing th... | Continuous learning rate decay function. The returned rate is lr_init when step=0 and lr_final when step=max_steps, and is log-linearly interpolated elsewhere (equivalent to exponential decay). If lr_delay_steps>0 then the learning rate will be scaled by some smooth function of lr_delay_mult, such that the initial lear... |
2,053 | import collections.abc
import os
import os.path as osp
from torch import nn
import kornia.augmentation as K
import pydiffvg
import save_svg
import cv2
from ttf import font_string_to_svgs, normalize_letter_size
import torch
import numpy as np
def save_image(img, filename, gamma=1):
check_and_create_dir(filename)
... | null |
2,054 | import collections.abc
import os
import os.path as osp
from torch import nn
import kornia.augmentation as K
import pydiffvg
import save_svg
import cv2
from ttf import font_string_to_svgs, normalize_letter_size
import torch
import numpy as np
def check_and_create_dir(path):
pathdir = osp.split(path)[0]
if osp.is... | null |
2,055 | from typing import Mapping
import os
from tqdm import tqdm
from easydict import EasyDict as edict
import matplotlib.pyplot as plt
import torch
from torch.optim.lr_scheduler import LambdaLR
import pydiffvg
import save_svg
from losses import SDSLoss, ToneLoss, ConformalLoss
from config import set_config
from utils import... | null |
2,056 | import argparse
import os.path as osp
import yaml
import random
from easydict import EasyDict as edict
import numpy.random as npr
import torch
from utils import (
edict_2_dict,
check_and_create_dir,
update)
import wandb
import warnings
def parse_args():
def edict_2_dict(x):
def check_and_create_dir(path)... | null |
2,057 | import numpy as np
import matplotlib.pyplot as plt
from scipy.special import binom
from numpy.linalg import norm
def cubic_bezier(P, t):
return (1.0-t)**3*P[0] + 3*(1.0-t)**2*t*P[1] + 3*(1.0-t)*t**2*P[2] + t**3*P[3] | null |
2,058 | import numpy as np
import matplotlib.pyplot as plt
from scipy.special import binom
from numpy.linalg import norm
def bezier_piecewise(Cp, subd=100, degree=3, d=0):
''' sample a piecewise Bezier curve given a sequence of control points'''
num = num_bezier(Cp.shape[0], degree)
X = []
for i in range(num):
... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.