id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
15,549 | import torch.cuda as cuda
import torch.nn as nn
import torch
import collections
from torch.nn.parallel._functions import Gather
def user_scattered_collate(batch):
return batch | null |
15,550 | import torch.cuda as cuda
import torch.nn as nn
import torch
import collections
from torch.nn.parallel._functions import Gather
def async_copy_to(obj, dev, main_stream=None):
if torch.is_tensor(obj):
v = obj.cuda(dev, non_blocking=True)
if main_stream is not None:
v.data.record_stream(ma... | null |
15,551 | import torch.cuda as cuda
import torch.nn as nn
import torch
import collections
from torch.nn.parallel._functions import Gather
def async_copy_to(obj, dev, main_stream=None):
if torch.is_tensor(obj):
v = obj.cuda(dev, non_blocking=True)
if main_stream is not None:
v.data.record_stream(ma... | null |
15,552 | import torch
import torch.multiprocessing as multiprocessing
from torch._C import _set_worker_signal_handlers, \
_remove_worker_pids, _error_if_any_worker_fails
try:
from torch._C import _set_worker_pids
except:
from torch._C import _update_worker_pids as _set_worker_pids
from .sampler import SequentialSamp... | null |
15,553 | import torch
import torch.multiprocessing as multiprocessing
from torch._C import _set_worker_signal_handlers, \
_remove_worker_pids, _error_if_any_worker_fails
try:
from torch._C import _set_worker_pids
except:
from torch._C import _update_worker_pids as _set_worker_pids
from .sampler import SequentialSamp... | null |
15,554 | import torch
import torch.multiprocessing as multiprocessing
from torch._C import _set_worker_signal_handlers, \
_remove_worker_pids, _error_if_any_worker_fails
try:
from torch._C import _set_worker_pids
except:
from torch._C import _update_worker_pids as _set_worker_pids
from .sampler import SequentialSamp... | Puts each data field into a tensor with outer dimension batch size |
15,555 | import torch
import torch.multiprocessing as multiprocessing
from torch._C import _set_worker_signal_handlers, \
_remove_worker_pids, _error_if_any_worker_fails
from .sampler import SequentialSampler, RandomSampler, BatchSampler
import signal
import collections
import re
import sys
import threading
import traceback... | null |
15,556 | import bisect
import warnings
from torch._utils import _accumulate
from torch import randperm
class Subset(Dataset):
def __init__(self, dataset, indices):
self.dataset = dataset
self.indices = indices
def __getitem__(self, idx):
return self.dataset[self.indices[idx]]
def __len__(self... | Randomly split a dataset into non-overlapping new datasets of given lengths ds Arguments: dataset (Dataset): Dataset to be split lengths (iterable): lengths of splits to be produced |
15,557 | import torch
from torch.autograd import Variable
import numpy as np
import collections
def as_variable(obj):
if isinstance(obj, Variable):
return obj
if isinstance(obj, collections.Sequence):
return [as_variable(v) for v in obj]
elif isinstance(obj, collections.Mapping):
return {k: ... | null |
15,558 | import torch
from torch.autograd import Variable
import numpy as np
import collections
def as_numpy(obj):
if isinstance(obj, collections.Sequence):
return [as_numpy(v) for v in obj]
elif isinstance(obj, collections.Mapping):
return {k: as_numpy(v) for k, v in obj.items()}
elif isinstance(ob... | null |
15,559 | import torch
from torch.autograd import Variable
import numpy as np
import collections
def mark_volatile(obj):
if torch.is_tensor(obj):
obj = Variable(obj)
if isinstance(obj, Variable):
obj.no_grad = True
return obj
elif isinstance(obj, collections.Mapping):
return {k: mark_... | null |
15,560 | import os
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
from scipy.io import loadmat
from torch.nn.modules import BatchNorm2d
from . import resnet
from . import mobilenet
def conv3x3_bn_relu(in_planes, out_planes, stride=1):
return nn.Sequential(
nn.Conv2d(in_planes... | null |
15,561 | import math
import torch.nn as nn
from torch.nn import BatchNorm2d
from .utils import load_url
The provided code snippet includes necessary dependencies for implementing the `conv3x3` function. Write a Python function `def conv3x3(in_planes, out_planes, stride=1)` to solve the following problem:
3x3 convolution with p... | 3x3 convolution with padding |
15,562 | import math
import torch.nn as nn
from torch.nn import BatchNorm2d
from .utils import load_url
model_urls = {
'resnet50': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnet50-imagenet.pth',
}
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=... | Constructs a ResNet-50 model. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet |
15,563 | import math
import torch.nn as nn
from torch.nn import BatchNorm2d
from .utils import load_url
model_urls = {
'resnet50': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnet50-imagenet.pth',
}
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=... | Constructs a ResNet-18 model. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet |
15,564 | import glob
import os
import PIL.Image as Image
import cv2
import numpy as np
import tqdm
import shutil
from saicinpainting.evaluation.utils import load_yaml
def generate_masks_for_img(infile, outmask_pattern, mask_size=200, step=0.5):
inimg = Image.open(infile)
width, height = inimg.size
step_abs = int(ma... | null |
15,576 | import torch
import torch.multiprocessing as multiprocessing
from torch._C import _set_worker_signal_handlers, \
_remove_worker_pids, _error_if_any_worker_fails
try:
from torch._C import _set_worker_pids
except:
from torch._C import _update_worker_pids as _set_worker_pids
from .sampler import SequentialSamp... | null |
15,588 | import os
import numpy as np
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.themes.utils import colors, fonts, sizes
from openai.error import APIConnectionErro... | null |
15,589 | import os
import numpy as np
os.environ['CURL_CA_BUNDLE'] = ''
os.environ['MKL_SERVICE_FORCE_INTEL'] = '1'
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.theme... | null |
15,590 | import os
import numpy as np
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.themes.utils import colors, fonts, sizes
from openai.error import APIConnectionErro... | null |
15,591 | import os
import numpy as np
os.environ['CURL_CA_BUNDLE'] = ''
os.environ['MKL_SERVICE_FORCE_INTEL'] = '1'
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.theme... | null |
15,592 | import os
import numpy as np
os.environ['CURL_CA_BUNDLE'] = ''
os.environ['MKL_SERVICE_FORCE_INTEL'] = '1'
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.theme... | null |
15,593 | import os
import numpy as np
os.environ['CURL_CA_BUNDLE'] = ''
os.environ['MKL_SERVICE_FORCE_INTEL'] = '1'
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.theme... | null |
15,594 | import os
import numpy as np
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.themes.utils import colors, fonts, sizes
from openai.error import APIConnectionErro... | null |
15,595 | import os
import numpy as np
from pathlib import Path
import sys
import random
from PIL import Image
import numpy as np
import argparse
from functools import partial
import gradio as gr
import gradio.themes.base as ThemeBase
from gradio.themes.utils import colors, fonts, sizes
from openai.error import APIConnectionErro... | null |
15,596 | import inspect
import re
import os
import numpy as np
import uuid
import shutil
import whisper
import torch
import gradio as gr
import imageio
from io import BytesIO
import requests as req
from PIL import Image
from langchain.agents.initialize import initialize_agent
from langchain.agents.tools import Tool
from langcha... | null |
15,597 | from .intern_action import intern_action_b16
from huggingface_hub import hf_hub_download
import torch
import torch.nn as nn
import torchvision.transforms as T
import torch.nn.functional as F
import numpy as np
from .processing import (
GroupNormalize, GroupScale, GroupCenterCrop,
Stack, ToTorchFormatTensor
)
... | null |
15,598 | from .intern_action import intern_action_b16
from huggingface_hub import hf_hub_download
import torch
import torch.nn as nn
import torchvision.transforms as T
import torch.nn.functional as F
import numpy as np
from .processing import (
GroupNormalize, GroupScale, GroupCenterCrop,
Stack, ToTorchFormatTensor
)
... | null |
15,599 | from .intern_action import intern_action_b16
from huggingface_hub import hf_hub_download
import torch
import torch.nn as nn
import torchvision.transforms as T
import torch.nn.functional as F
import numpy as np
from .processing import (
GroupNormalize, GroupScale, GroupCenterCrop,
Stack, ToTorchFormatTensor
)
c... | null |
15,600 | from .intern_action import intern_action_b16
from huggingface_hub import hf_hub_download
import torch
import torch.nn as nn
import torchvision.transforms as T
import torch.nn.functional as F
import numpy as np
from .processing import (
GroupNormalize, GroupScale, GroupCenterCrop,
Stack, ToTorchFormatTensor
)
... | null |
15,601 | import warnings
from .vit import VisionTransformer, interpolate_pos_embed
from .swin_transformer import SwinTransformer, interpolate_relative_pos_embed
from .med import BertConfig, BertModel, BertLMHeadModel
from .utils import tra_array
from transformers import BertTokenizer
import torch
from torch import nn
import tor... | null |
15,602 | import warnings
from .vit import VisionTransformer, interpolate_pos_embed
from .swin_transformer import SwinTransformer, interpolate_relative_pos_embed
from .med import BertConfig, BertModel, BertLMHeadModel
from .utils import tra_array
from transformers import BertTokenizer
import torch
from torch import nn
import tor... | null |
15,603 | import warnings
from .vit import VisionTransformer, interpolate_pos_embed
from .swin_transformer import SwinTransformer, interpolate_relative_pos_embed
from .med import BertConfig, BertModel, BertLMHeadModel
from .utils import tra_array
from transformers import BertTokenizer
import torch
from torch import nn
import tor... | null |
15,604 | import warnings
from .vit import VisionTransformer, interpolate_pos_embed
from .swin_transformer import SwinTransformer, interpolate_relative_pos_embed
from .med import BertConfig, BertModel, BertLMHeadModel
from .utils import tra_array
from transformers import BertTokenizer
import torch
from torch import nn
import tor... | null |
15,605 | import dataclasses
from enum import auto, Enum
from typing import List, Tuple, Any
conv_one_shot = Conversation(
system="A chat between a curious human and an artificial intelligence assistant. "
"The assistant gives helpful, detailed, and polite answers to the human's questions.",
roles=("Human", "A... | null |
15,606 | import dataclasses
from enum import auto, Enum
from typing import List, Tuple, Any
def compute_skip_echo_len(model_name, conv, prompt):
model_name = model_name.lower()
if "husky" in model_name:
skip_echo_len = len(prompt) - prompt.count("</s>") * 3
else:
skip_echo_len = len(prompt) + 1 - pr... | null |
15,607 | import dataclasses
import torch
from torch import Tensor
import torch.nn as nn
from torch.nn import functional as F
class CLinear(nn.Module):
"""Compressed Linear Layer."""
def __init__(self, weight, bias, device):
super().__init__()
self.weight = compress(weight.data.to(device), default_compres... | null |
15,608 | import dataclasses
import torch
from torch import Tensor
import torch.nn as nn
from torch.nn import functional as F
class CLinear_V2(nn.Module):
"""Compressed Linear Layer."""
def __init__(self, weight, bias, device):
super().__init__()
self.weight = weight.data.to("cpu")
self.weight_int... | null |
15,609 | import dataclasses
import torch
from torch import Tensor
import torch.nn as nn
from torch.nn import functional as F
class CLinear_V2(nn.Module):
"""Compressed Linear Layer."""
def __init__(self, weight, bias, device):
super().__init__()
self.weight = weight.data.to("cpu")
self.weight_int... | null |
15,610 | import dataclasses
import torch
from torch import Tensor
import torch.nn as nn
from torch.nn import functional as F
class CLinear_V2(nn.Module):
"""Compressed Linear Layer."""
def __init__(self, weight, bias, device):
super().__init__()
self.weight = weight.data.to("cpu")
self.weight_int... | null |
15,611 | import dataclasses
import torch
from torch import Tensor
import torch.nn as nn
from torch.nn import functional as F
The provided code snippet includes necessary dependencies for implementing the `compress` function. Write a Python function `def compress(tensor, config)` to solve the following problem:
Simulate group-w... | Simulate group-wise quantization. |
15,612 | import dataclasses
import torch
from torch import Tensor
import torch.nn as nn
from torch.nn import functional as F
The provided code snippet includes necessary dependencies for implementing the `decompress` function. Write a Python function `def decompress(packed_data, config)` to solve the following problem:
Simulat... | Simulate group-wise dequantization. |
15,613 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def add_points_to_image(image, points, size=5):
# h, w, = image.shape[:2]
# print(image.shape)
# print(ima... | null |
15,614 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def to_image(tensor):
tensor = tensor.squeeze(0).permute(1, 2, 0).contiguous()
arr = tensor.detach().cpu().num... | null |
15,615 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def gen_new_seed():
return random.randint(0, 65535)
def seed_everything(seed):
if seed == -1:
seed = g... | null |
15,616 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def resize_800(image):
w, h = image.size
if w > h:
ratio = w * 1.0 / 800
new_w, new_h = 800, i... | null |
15,617 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def prompts(name, description):
def decorator(func):
func.name = name
func.description = descripti... | null |
15,618 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def gen_new_name(orginal_name, suffix="update", ext="png"):
root_path, filename = os.path.split(orginal_name)
... | null |
15,619 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def dilate_mask(mask, dilate_factor=9):
# dilate mask
mask = mask.astype(np.uint8)
dilated_mask = cv2.dila... | null |
15,620 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def cal_dilate_factor(mask):
area = mask[mask != 0].sum()
edge = cv2.Canny(mask, 30, 226)
perimeter = edge... | null |
15,621 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def blend_gt2pt(old_image, new_image, sigma=0.15, steps=100):
new_size = new_image.size
old_size = old_image.s... | null |
15,622 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def loadvideo_decord(sample, sample_rate_scale=1,new_width=384, new_height=384, clip_len=8, frame_sample_rate=2,num_se... | null |
15,623 | import torch
import numpy as np
from decord import VideoReader
from decord import cpu
import uuid
import os
import torchvision.transforms as transforms
import math
import time
import cv2
import random
def loadvideo_decord_origin(self, sample, sample_rate_scale=1,new_width=384, new_height=384, clip_len=8, frame_sample_... | null |
15,624 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | null |
15,625 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | null |
15,626 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | null |
15,627 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | null |
15,628 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | null |
15,629 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | Perform uniform spatial sampling on the images and corresponding boxes. Args: images (tensor): images to perform uniform crop. The dimension is `num frames` x `channel` x `height` x `width`. size (int): size of height and weight to crop the images. spatial_idx (int): 0, 1, or 2 for left, center, and right crop if width... |
15,630 | import logging
import math
import os
import torch
import torch.nn as nn
import torchaudio
from PIL import Image
from pytorchvideo import transforms as pv_transforms
from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
from pytorchvideo.data.encoded_video import EncodedVideo
from torchvision import t... | null |
15,631 | import os
import urllib
from functools import partial
from types import SimpleNamespace
import torch
import torch.nn as nn
from .helpers import (
EinOpsRearrange,
LearnableLogitScaling,
Normalize,
SelectElement,
SelectEOSAndProject,
)
from .multimodal_preprocessors import (
AudioPreprocessor,
... | null |
15,632 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | Sinusoid position encoding table |
15,633 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | null |
15,634 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | null |
15,635 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | Returns list of utf-8 byte and a corresponding list of unicode strings. The reversible bpe codes work on unicode strings. This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. This ... |
15,636 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | Return set of symbol pairs in a word. Word is represented as tuple of symbols (symbols being variable-length strings). |
15,637 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | null |
15,638 | import gzip
import html
import io
import math
from functools import lru_cache
from typing import Callable, List, Optional
import ftfy
import numpy as np
import regex as re
import torch
import torch.nn as nn
from iopath.common.file_io import g_pathmgr
from timm.models.layers import trunc_normal_
from .helpers import cas... | null |
15,639 | import os
import sys
import torch
from omegaconf import OmegaConf
import numpy as np
from .ldm.models.diffusion.ddim import DDIMSampler
from .ldm.util import instantiate_from_config
def make_batch(image, mask, device):
image = image.astype(np.float32) / 255.0
image = image[None].transpose(0, 3, 1, 2)
image... | null |
15,640 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 = (
torch.linspac... | null |
15,641 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 = num_ddpm_timesteps // nu... | null |
15,642 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...util import instantiate_from_config
def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True):
# select alphas for computing the variance schedule
alphas = alphacums[ddim_timestep... | null |
15,643 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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_bar(num_diffusion... | 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... |
15,644 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 |
15,645 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...util import instantiate_from_config
class CheckpointFunction(torch.autograd.Function):
def forward(ctx, run_function, length, *args):
ctx.run_function = run_function
ctx.input_tensors = list... | 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... |
15,646 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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(timesteps, dim,... | 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. |
15,647 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 solve the followi... | Zero out the parameters of a module and return it. |
15,648 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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, scale)` to solve th... | Scale the parameters of a module and return it. |
15,649 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 the following p... | Take the mean over all non-batch dimensions. |
15,650 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 necessary dependencies ... | Make a standard normalization layer. :param channels: number of input channels. :return: an nn.Module for normalization. |
15,651 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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)` to solve the ... | Create a 1D, 2D, or 3D convolution module. |
15,652 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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 solve the followin... | Create a linear module. |
15,653 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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, **kwargs)` to so... | Create a 1D, 2D, or 3D average pooling module. |
15,654 | import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ...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(shape) - 1)))
noise = ... | null |
15,663 | from inspect import isfunction
import math
import torch
import torch.nn.functional as F
from torch import nn, einsum
from einops import rearrange, repeat
from ldm.modules.diffusionmodules.util import checkpoint
def exists(val):
def default(val, d):
if exists(val):
return val
return d() if isfunction(d)... | null |
15,685 | import os
import math
import random
import numpy as np
import torch
import cv2
from torchvision.utils import make_grid
from datetime import datetime
def imwrite(img, img_path):
def imsave(img, img_path):
img = np.squeeze(img)
if img.ndim == 3:
img = img[:, :, [2, 1, 0]]
cv2.imwrite(img_path, img) | null |
15,733 | import importlib
import torch
import numpy as np
from collections import abc
from einops import rearrange
from functools import partial
import multiprocessing as mp
from threading import Thread
from queue import Queue
from inspect import isfunction
from PIL import Image, ImageDraw, ImageFont
def exists(x):
def default... | null |
15,736 | import importlib
import torch
import numpy as np
from collections import abc
from einops import rearrange
from functools import partial
import multiprocessing as mp
from threading import Thread
from queue import Queue
from inspect import isfunction
from PIL import Image, ImageDraw, ImageFont
def get_obj_from_str(string... | null |
15,739 | import torch
import torch.nn as nn
import numpy as np
import pytorch_lightning as pl
from torch.optim.lr_scheduler import LambdaLR
from einops import rearrange, repeat
from contextlib import contextmanager
from functools import partial
from tqdm import tqdm
from torchvision.utils import make_grid
from pytorch_lightning... | Overwrite model.train with this function to make sure train/eval mode does not change anymore. |
15,740 | import torch
import torch.nn as nn
import numpy as np
import pytorch_lightning as pl
from torch.optim.lr_scheduler import LambdaLR
from einops import rearrange, repeat
from contextlib import contextmanager
from functools import partial
from tqdm import tqdm
from torchvision.utils import make_grid
from pytorch_lightning... | null |
15,741 | import os
import torch
from PIL import Image
import random
import time
import numpy as np
import uuid
import cv2
import wget
from transformers import pipeline
from .utils import (cal_dilate_factor, dilate_mask, gen_new_name,
seed_everything, prompts, resize_800,
gen_new_seed, GLO... | null |
15,742 | import torch
import torch.nn as nn
import torch.nn.functional as F
from functools import partial
from timm.models.vision_transformer import _cfg, PatchEmbed
from timm.models.registry import register_model
from timm.models.layers import trunc_normal_, DropPath
from timm.models.helpers import named_apply, adapt_input_con... | Load weights from .npz checkpoints for official Google Brain Flax implementation |
15,743 | from collections import abc
import os
import torch
from torch.nn import functional as F
from torch.autograd import Function
from torch.utils.cpp_extension import load
class UpFirDn2d(Function):
def forward(ctx, input, kernel, up, down, pad):
up_x, up_y = up
down_x, down_y = down
pad_x0, pad_... | null |
15,744 | import contextlib
import warnings
import torch
from torch import autograd
from torch.nn import functional as F
weight_gradients_disabled = False
def no_weight_gradients():
global weight_gradients_disabled
old = weight_gradients_disabled
weight_gradients_disabled = True
yield
weight_gradients_disab... | null |
15,745 | import os
import torch
from torch import nn
from torch.nn import functional as F
from torch.autograd import Function
from torch.utils.cpp_extension import load
class FusedLeakyReLUFunction(Function):
def forward(ctx, input, bias, negative_slope, scale):
empty = input.new_empty(0)
ctx.bias = bias is ... | null |
15,746 | import math
import random
import torch
from torch import nn
from torch.nn import functional as F
from .op import FusedLeakyReLU, fused_leaky_relu, upfirdn2d, conv2d_gradfix
def make_kernel(k):
k = torch.tensor(k, dtype=torch.float32)
if k.ndim == 1:
k = k[None, :] * k[:, None]
k /= k.sum()
r... | null |
15,747 | import copy
import os
import random
import urllib.request
import torch
import torch.nn.functional as FF
import torch.optim
from torchvision import utils
from tqdm import tqdm
from .stylegan2.model import Generator
def get_path(base_path):
BASE_DIR = os.path.join('model_zoo')
save_path = os.path.join(BASE_DIR, b... | null |
15,748 | import copy
import os
import random
import urllib.request
import torch
import torch.nn.functional as FF
import torch.optim
from torchvision import utils
from tqdm import tqdm
from .stylegan2.model import Generator
def bilinear_interpolate_torch(im, y, x):
def drag_gan(g_ema, latent: torch.Tensor, noise, F, handle_poin... | null |
15,749 | import os
import sys
import cv2
import numpy as np
import torch
import ipdb
from PIL import Image
from .utils import gen_new_name, prompts
import torch
from omegaconf import OmegaConf
import numpy as np
import wget
from .inpainting_src.ldm_inpainting.ldm.models.diffusion.ddim import DDIMSampler
from .inpainting_src.ldm... | null |
15,750 | import numpy as np
from scipy import interpolate
import torch
import torch.nn as nn
import torch.utils.checkpoint as checkpoint
from timm.models.layers import DropPath, to_2tuple, trunc_normal_
The provided code snippet includes necessary dependencies for implementing the `window_partition` function. Write a Python fu... | Args: x: (B, H, W, C) window_size (int): window size Returns: windows: (num_windows*B, window_size, window_size, C) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.