entry_point stringlengths 1 65 | original_triton_code stringlengths 4.5k 619k | python_code stringlengths 208 60.9k | triton_code stringlengths 1.15k 275k | repo_name stringlengths 7 115 | module_name stringlengths 1 65 | synthetic bool 1
class | uuid int64 0 18.5k | licenses listlengths 1 6 | stars int64 0 19.8k | sha stringlengths 40 40 | repo_link stringlengths 72 180 | pytorch_code stringlengths 200 4.05k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
UpSampleConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class MyConvo2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, he_init=True,
stride=1, bias=True):
super(MyConvo2d, self).__init__()
self.he_init = he_init
self.padding = int((kernel_size - 1) / 2)
self.conv = nn.Conv2d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | justaboutlola/improved-wgan-pytorch | UpSampleConv | false | 15,756 | [
"MIT"
] | 412 | 5bb0b729809152d9129ef72a9dd28b3ff83021a2 | https://github.com/justaboutlola/improved-wgan-pytorch/tree/5bb0b729809152d9129ef72a9dd28b3ff83021a2 | import torch
from torch import nn
class MyConvo2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, he_init=True,
stride=1, bias=True):
super().__init__()
self.he_init = he_init
self.padding = int((kernel_size - 1) / 2)
self.conv = nn.Conv2d(input_dim, out... |
ExtractTensorPatches | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import Optional
from typing import Tuple
import torch.nn as nn
import torch.nn.functional as F
from typing import Union
from torch.nn.modules.utils import _pair
def _extract_tensor_patchesnd(input: 'torch.Tensor', window_sizes:
'Tuple[int, ...]', strides: 'Tuple[int, ...]') ->torch.Tensor... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from typing import Optional
from typing import Tuple
import torch.nn as nn
import torch.nn.functional as F
from typing import Union
from tor... | justanhduc/kornia | ExtractTensorPatches | false | 15,757 | [
"ECL-2.0",
"Apache-2.0"
] | 51 | c14081292dfb2491fad50ba10e27491cad8cb3e3 | https://github.com/justanhduc/kornia/tree/c14081292dfb2491fad50ba10e27491cad8cb3e3 | import torch
from typing import Optional
from typing import Tuple
import torch.nn as nn
import torch.nn.functional as F
from typing import Union
from torch.nn.modules.utils import _pair
def _extract_tensor_patchesnd(input: 'torch.Tensor', window_sizes:
'Tuple[int, ...]', strides: 'Tuple[int, ...]') ->torch.Tensor... |
Grad_hyper | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional
class Grad_hyper(torch.nn.Module):
"""
N-D gradient loss.
"""
def __init__(self, penalty='l1'):
super(Grad_hyper, self).__init__()
self.penalty = penalty
def forward(self, y_pred, wts):
dy = torch.abs(y_pred[:, :, 1:, :] - y_pred[:,... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn.functi... | junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration | Grad_hyper | false | 15,758 | [
"MIT"
] | 82 | dfa24a47a564a000aa9b4eea95a6e83a24568359 | https://github.com/junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration/tree/dfa24a47a564a000aa9b4eea95a6e83a24568359 | import torch
import torch.nn.functional
class Model(torch.nn.Module):
"""
N-D gradient loss.
"""
def __init__(self, penalty='l1'):
super().__init__()
self.penalty = penalty
def forward(self, y_pred, wts):
dy = torch.abs(y_pred[:, :, 1:, :] - y_pred[:, :, :-1, :])
... |
PCC | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional
class PCC(torch.nn.Module):
def __init__(self):
super(PCC, self).__init__()
def pcc(self, y_true, y_pred):
A_bar = torch.mean(y_pred, dim=[1, 2, 3, 4], keepdim=True)
B_bar = torch.mean(y_true, dim=[1, 2, 3, 4], keepdim=True)
top = torch... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn.functional
a... | junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration | PCC | false | 15,760 | [
"MIT"
] | 82 | dfa24a47a564a000aa9b4eea95a6e83a24568359 | https://github.com/junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration/tree/dfa24a47a564a000aa9b4eea95a6e83a24568359 | import torch
import torch.nn.functional
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def pcc(self, y_true, y_pred):
A_bar = torch.mean(y_pred, dim=[1, 2, 3, 4], keepdim=True)
B_bar = torch.mean(y_true, dim=[1, 2, 3, 4], keepdim=True)
top = torch.mean((... |
outblock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.distributions.normal import Normal
import torch.nn.functional
class outblock(nn.Module):
def __init__(self, in_ch, out_ch, stride=2, output_padding=1):
super(outblock, self).__init__()
self.upconv = nn.Conv3d(in_ch, out_ch, 3, padding=1, stride=stride... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.distributions.normal import Normal
import torch... | junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration | outblock | false | 15,761 | [
"MIT"
] | 82 | dfa24a47a564a000aa9b4eea95a6e83a24568359 | https://github.com/junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration/tree/dfa24a47a564a000aa9b4eea95a6e83a24568359 | import torch
import torch.nn as nn
from torch.distributions.normal import Normal
import torch.nn.functional
class Model(nn.Module):
def __init__(self, in_ch, out_ch, stride=2, output_padding=1):
super().__init__()
self.upconv = nn.Conv3d(in_ch, out_ch, 3, padding=1, stride=stride)
self.up... |
DeiTEmbeddings | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import collections
import torch
from torch import nn
import torch.utils.checkpoint
import collections.abc
def to_2tuple(x):
if isinstance(x, collections.abc.Iterable):
return x
return x, x
class PatchEmbeddings(nn.Module):
"""
Image to Patch Embe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import collections
from torch import nn
import torch.utils.checkpoint
import col... | jxhe/unify-parameter-efficient-tuning | DeiTEmbeddings | false | 15,762 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import collections
import torch
from torch import nn
import torch.utils.checkpoint
import collections.abc
def to_2tuple(x):
if isinstance(x, collections.abc.Iterable):
return x
return x, x
class PatchEmbeddings(nn.Module):
"""
Image to Patch Embe... |
GroupedLinearLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.checkpoint
class GroupedLinearLayer(nn.Module):
def __init__(self, input_size, output_size, num_groups):
super().__init__()
self.input_size = input_size
self.output_size = output_size
self.num_groups = num_groups
self.gr... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.utils.checkpoint
assert_size_stride = torch._C... | jxhe/unify-parameter-efficient-tuning | GroupedLinearLayer | false | 15,763 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | import torch
from torch import nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, input_size, output_size, num_groups):
super().__init__()
self.input_size = input_size
self.output_size = output_size
self.num_groups = num_groups
self.group_in_dim = ... |
ConvBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1):
super(ConvBlock, self).__init__()
self.Mconv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | kacel33/ActionAI_PC | ConvBlock | false | 15,764 | [
"MIT"
] | 1,311 | a0528f49ea61cc07d7c1e9a3cd6846e5f50cfae7 | https://github.com/kacel33/ActionAI_PC/tree/a0528f49ea61cc07d7c1e9a3cd6846e5f50cfae7 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1):
super().__init__()
self.Mconv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channels, kernel_size=kern... |
HubertFeatureProjection | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.utils.checkpoint
class HubertFeatureProjection(nn.Module):
def __init__(self, config):
super().__init__()
self.layer_norm = nn.LayerNorm(config.conv_dim[-1], eps=config.
layer_norm_eps)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | jxhe/unify-parameter-efficient-tuning | HubertFeatureProjection | false | 15,765 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.layer_norm = nn.LayerNorm(config.conv_dim[-1], eps=config.
layer_norm_eps)
self.projection ... |
MegatronBertOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.utils.checkpoint
class MegatronBertOutput(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
self.dropout = nn.Dropout(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.utils.checkpoint
assert_size_stride = torch._C... | jxhe/unify-parameter-efficient-tuning | MegatronBertOutput | false | 15,766 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
self.dropout = nn.Dropout(config.hidden... |
IBertLMHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
import torch.utils.checkpoint
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class IBertLMHead(nn.Module):
"""I-BERT Head for masked language modelin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | jxhe/unify-parameter-efficient-tuning | IBertLMHead | false | 15,767 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
import torch.utils.checkpoint
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class Model(nn.Module):
"""I-BERT Head for masked language modeling."""
... |
Conv3d_wd | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.functional
class Conv3d_wd(nn.Conv3d):
def __init__(self, in_channels, out_channels, kernel_size, stride=(1, 1,
1), padding=(0, 0, 0), dilation=(1, 1, 1), groups=1, bias=False):
super(Conv3d_wd, self).__init__(in_c... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration | Conv3d_wd | false | 15,768 | [
"MIT"
] | 82 | dfa24a47a564a000aa9b4eea95a6e83a24568359 | https://github.com/junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration/tree/dfa24a47a564a000aa9b4eea95a6e83a24568359 | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.functional
class Model(nn.Conv3d):
def __init__(self, in_channels, out_channels, kernel_size, stride=(1, 1,
1), padding=(0, 0, 0), dilation=(1, 1, 1), groups=1, bias=False):
super().__init__(in_channels, out_channe... |
MPNetSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
import torch.utils.checkpoint
class MPNetSelfAttention(nn.Module):
def __init__(self, config):
super().__init__()
if (config.hidden_size % config.num_attention_heads != 0 and not
hasattr(config... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jxhe/unify-parameter-efficient-tuning | MPNetSelfAttention | false | 15,769 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, config):
super().__init__()
if (config.hidden_size % config.num_attention_heads != 0 and not
hasattr(config, 'embedding_... |
NoNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.checkpoint
class NoNorm(nn.Module):
def __init__(self, feat_size, eps=None):
super().__init__()
self.bias = nn.Parameter(torch.zeros(feat_size))
self.weight = nn.Parameter(torch.ones(feat_size))
def forward(self, input_tensor):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.utils.checkpoint
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | jxhe/unify-parameter-efficient-tuning | NoNorm | false | 15,770 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | import torch
from torch import nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, feat_size, eps=None):
super().__init__()
self.bias = nn.Parameter(torch.zeros(feat_size))
self.weight = nn.Parameter(torch.ones(feat_size))
def forward(self, input_tensor):
... |
ConvDropoutLayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.checkpoint
class SqueezeBertLayerNorm(nn.LayerNorm):
"""
This is a nn.LayerNorm subclass that accepts NCW data layout and performs normalization in the C dimension.
N = batch C = channels W = sequence length
"""
def __init__(self, hidden_size,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | jxhe/unify-parameter-efficient-tuning | ConvDropoutLayerNorm | false | 15,771 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | import torch
from torch import nn
import torch.utils.checkpoint
class SqueezeBertLayerNorm(nn.LayerNorm):
"""
This is a nn.LayerNorm subclass that accepts NCW data layout and performs normalization in the C dimension.
N = batch C = channels W = sequence length
"""
def __init__(self, hidden_size,... |
DeiTAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from typing import List
from typing import Tuple
from torch import nn
from typing import Set
import torch.utils.checkpoint
def find_pruneable_heads_and_indices(heads: 'List[int]', n_heads: 'int',
head_size: 'int', already_pruned_heads: 'Set[in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jxhe/unify-parameter-efficient-tuning | DeiTAttention | false | 15,772 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import math
import torch
from typing import List
from typing import Tuple
from torch import nn
from typing import Set
import torch.utils.checkpoint
def find_pruneable_heads_and_indices(heads: 'List[int]', n_heads: 'int',
head_size: 'int', already_pruned_heads: 'Set[in... |
MobileBertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
import torch.utils.checkpoint
class MobileBertSelfAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.num_attention_heads = config.num_attention_heads
self.attention_head_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jxhe/unify-parameter-efficient-tuning | MobileBertSelfAttention | false | 15,773 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.num_attention_heads = config.num_attention_heads
self.attention_head_size = int(config.true... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Critic(nn.Module):
def __init__(self, state_size, action_size, action_parameter_size,
hidden_layers=None, action_input_layer=0, init_type='normal',
activation='leaky_relu', init_std=0.01):
super(Critic, self).__init_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | jordiriu/MP-DQN | Critic | false | 15,774 | [
"MIT"
] | 75 | eec13eb9b4e2c0099649e0639f2a8b93d7d0d5be | https://github.com/jordiriu/MP-DQN/tree/eec13eb9b4e2c0099649e0639f2a8b93d7d0d5be | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_size, action_size, action_parameter_size,
hidden_layers=None, action_input_layer=0, init_type='normal',
activation='leaky_relu', init_std=0.01):
super().__init__()
s... |
DistillationOrthogonalProjectionLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class DistillationOrthogonalProjectionLoss(nn.Module):
def __init__(self):
super(DistillationOrthogonalProjectionLoss, self).__init__(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kahnchana/opl | DistillationOrthogonalProjectionLoss | false | 15,775 | [
"MIT"
] | 64 | 1db31de3f95ced16c769f5b18325bdef46f317f4 | https://github.com/kahnchana/opl/tree/1db31de3f95ced16c769f5b18325bdef46f317f4 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
@staticmethod
def forward(features, features_teacher):
... |
MSE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.optim import *
class MSE(nn.Module):
def __init__(self):
super().__init__()
def forward(self, outputs, target, *args):
val_pixels = (target > 0.001).float()
loss = target * val_pixels - outputs * val_pixels
return loss ** 2
def ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.optim import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._... | kakaxi314/GuideNet | MSE | false | 15,776 | [
"MIT"
] | 142 | 9f53b4086d707e94d48a47bbac7dd87aaba9fdea | https://github.com/kakaxi314/GuideNet/tree/9f53b4086d707e94d48a47bbac7dd87aaba9fdea | import torch
import torch.nn as nn
from torch.optim import *
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, outputs, target, *args):
val_pixels = (target > 0.001).float()
loss = target * val_pixels - outputs * val_pixels
return loss ** 2
de... |
ResBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.functional
def Activation_layer(activation_cfg, inplace=True):
out = None
if activation_cfg == 'ReLU':
out = nn.ReLU(inplace=inplace)
else:
out = nn.LeakyReLU(ne... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn.fun... | junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration | ResBlock | false | 15,777 | [
"MIT"
] | 82 | dfa24a47a564a000aa9b4eea95a6e83a24568359 | https://github.com/junyuchen245/TransMorph_Transformer_for_Medical_Image_Registration/tree/dfa24a47a564a000aa9b4eea95a6e83a24568359 | from _paritybench_helpers import _mock_config
import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.functional
def Activation_layer(activation_cfg, inplace=True):
out = None
if activation_cfg == 'ReLU':
out = nn.ReLU(inplace=inplace)
else:
out = nn.LeakyReLU(ne... |
RMSE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.optim import *
class RMSE(nn.Module):
def __init__(self):
super().__init__()
def forward(self, outputs, target, *args):
val_pixels = (target > 0.001).float()
err = (target * val_pixels - outputs * val_pixels) ** 2
loss = torch.sum... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
from torch.optim import *
assert_size_stride = torch._C._... | kakaxi314/GuideNet | RMSE | false | 15,778 | [
"MIT"
] | 142 | 9f53b4086d707e94d48a47bbac7dd87aaba9fdea | https://github.com/kakaxi314/GuideNet/tree/9f53b4086d707e94d48a47bbac7dd87aaba9fdea | import torch
import torch.nn as nn
from torch.optim import *
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, outputs, target, *args):
val_pixels = (target > 0.001).float()
err = (target * val_pixels - outputs * val_pixels) ** 2
loss = torch.su... |
mySConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn import Conv2d
from torch.nn import ReLU
from torch.nn import InstanceNorm2d
class mySConv(nn.Module):
def __init__(self, num_filter=128, stride=1, in_channels=128):
super(mySConv, self).__init__()
self.conv = Conv2d(out_channels=num_filter, kernel_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | junhocho/ShapeMatchingGAN | mySConv | false | 15,779 | [
"MIT"
] | 117 | b90e9c2490bfdf62c5da9b1eb6b0cdf0618cf570 | https://github.com/junhocho/ShapeMatchingGAN/tree/b90e9c2490bfdf62c5da9b1eb6b0cdf0618cf570 | import torch
import torch.nn as nn
from torch.nn import Conv2d
from torch.nn import ReLU
from torch.nn import InstanceNorm2d
class Model(nn.Module):
def __init__(self, num_filter=128, stride=1, in_channels=128):
super().__init__()
self.conv = Conv2d(out_channels=num_filter, kernel_size=3, stride=... |
Scale | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn import *
class Scale(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x):
return x * self.scale
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
from torch.nn import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._d... | kcorder/autonomous-learning-library | Scale | false | 15,780 | [
"MIT"
] | 584 | 0266195fa47564e51a32087bc007bff6dda5e263 | https://github.com/kcorder/autonomous-learning-library/tree/0266195fa47564e51a32087bc007bff6dda5e263 | import torch
from torch import nn
from torch.nn import *
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x):
return x * self.scale
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return ... |
MultiLayeredConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class MultiLayeredConv1d(torch.nn.Module):
"""Multi-layered conv1d for Transformer block.
This is a module of multi-leyered conv1d designed to replace positionwise feed-forward network
in Transforner block, which is introduced in `FastSpeech: Fast, Robust and Controllable Text to Speech`_.
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C... | karan-deepsync/FastSpeech2 | MultiLayeredConv1d | false | 15,781 | [
"Apache-2.0"
] | 148 | 84ad261db4a865536b2e15dfb8346644c3192704 | https://github.com/karan-deepsync/FastSpeech2/tree/84ad261db4a865536b2e15dfb8346644c3192704 | import torch
class Model(torch.nn.Module):
"""Multi-layered conv1d for Transformer block.
This is a module of multi-leyered conv1d designed to replace positionwise feed-forward network
in Transforner block, which is introduced in `FastSpeech: Fast, Robust and Controllable Text to Speech`_.
Args:
... |
mySBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn import Conv2d
from torch.nn import ReLU
from torch.nn import InstanceNorm2d
class mySConv(nn.Module):
def __init__(self, num_filter=128, stride=1, in_channels=128):
super(mySConv, self).__init__()
self.conv = Conv2d(out_channels=num_filter, kernel_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | junhocho/ShapeMatchingGAN | mySBlock | false | 15,782 | [
"MIT"
] | 117 | b90e9c2490bfdf62c5da9b1eb6b0cdf0618cf570 | https://github.com/junhocho/ShapeMatchingGAN/tree/b90e9c2490bfdf62c5da9b1eb6b0cdf0618cf570 | import torch
import torch.nn as nn
from torch.nn import Conv2d
from torch.nn import ReLU
from torch.nn import InstanceNorm2d
class mySConv(nn.Module):
def __init__(self, num_filter=128, stride=1, in_channels=128):
super().__init__()
self.conv = Conv2d(out_channels=num_filter, kernel_size=3, strid... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class LayerNorm(torch.nn.Module):
def __init__(self, nout: 'int'):
super(LayerNorm, self).__init__()
self.layer_norm = torch.nn.LayerNorm(nout, eps=1e-12)
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
x = self.layer_norm(x.transpose(1, -1))
x = x.transpose... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | karan-deepsync/FastSpeech2 | LayerNorm | false | 15,783 | [
"Apache-2.0"
] | 148 | 84ad261db4a865536b2e15dfb8346644c3192704 | https://github.com/karan-deepsync/FastSpeech2/tree/84ad261db4a865536b2e15dfb8346644c3192704 | import torch
class Model(torch.nn.Module):
def __init__(self, nout: 'int'):
super().__init__()
self.layer_norm = torch.nn.LayerNorm(nout, eps=1e-12)
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
x = self.layer_norm(x.transpose(1, -1))
x = x.transpose(1, -1)
ret... |
AlbertAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from typing import List
from typing import Tuple
from torch import nn
from typing import Set
import torch.utils.checkpoint
def find_pruneable_heads_and_indices(heads: 'List[int]', n_heads: 'int',
head_size: 'int', already_pruned_heads: 'Set[in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jxhe/unify-parameter-efficient-tuning | AlbertAttention | false | 15,784 | [
"Apache-2.0"
] | 101 | 3222ce2c0079566a28043e22380eb4ab6ad14389 | https://github.com/jxhe/unify-parameter-efficient-tuning/tree/3222ce2c0079566a28043e22380eb4ab6ad14389 | from _paritybench_helpers import _mock_config
import math
import torch
from typing import List
from typing import Tuple
from torch import nn
from typing import Set
import torch.utils.checkpoint
def find_pruneable_heads_and_indices(heads: 'List[int]', n_heads: 'int',
head_size: 'int', already_pruned_heads: 'Set[in... |
L2Norm | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.init
class L2Norm(nn.Module):
def __init__(self):
super(L2Norm, self).__init__()
self.eps = 1e-10
def forward(self, x):
norm = torch.sqrt(torch.sum(x * x, dim=1) + self.eps)
x = x / norm.unsqueeze(-1).expand_as(x)
ret... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn.init
assert_size_stride = torch._C._dynam... | keeeeenw/image-matching-benchmark-baselines | L2Norm | false | 15,785 | [
"Apache-2.0"
] | 103 | 1a11bedbe3c57f477ab9de302591811115ada37a | https://github.com/keeeeenw/image-matching-benchmark-baselines/tree/1a11bedbe3c57f477ab9de302591811115ada37a | import torch
import torch.nn as nn
import torch.nn.init
class Model(nn.Module):
def __init__(self):
super().__init__()
self.eps = 1e-10
def forward(self, x):
norm = torch.sqrt(torch.sum(x * x, dim=1) + self.eps)
x = x / norm.unsqueeze(-1).expand_as(x)
return x
def g... |
BCELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
class BCELoss(nn.Module):
def __init__(self):
super(self.__class__, self).__init__()
def forward(self, input, target):
return -torch.mean(torch.sum(target * torch.log(torch.clamp(input,
min=1e-10)) + (1 - target) * torch.l... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.dat... | kejiejiang/UnsupervisedDeepLearning-Pytorch | BCELoss | false | 15,786 | [
"MIT"
] | 87 | 6ea7b7151ae62bf0130b56cc023f2be068aa87f0 | https://github.com/kejiejiang/UnsupervisedDeepLearning-Pytorch/tree/6ea7b7151ae62bf0130b56cc023f2be068aa87f0 | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
def __init__(self):
super(self.__class__, self).__init__()
def forward(self, input, target):
return -torch.mean(torch.sum(target * torch.log(torch.clamp(input,
min=1e-10)) + (1 - target) * torch.log... |
stage_block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class dilation_layer(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, padding=
'same_padding', dilation=1):
super(dilation_layer, self).__init__()
if padding == 'same_padding':
padding = int((ke... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | kacel33/ActionAI_PC | stage_block | false | 15,787 | [
"MIT"
] | 1,311 | a0528f49ea61cc07d7c1e9a3cd6846e5f50cfae7 | https://github.com/kacel33/ActionAI_PC/tree/a0528f49ea61cc07d7c1e9a3cd6846e5f50cfae7 | import torch
import torch.nn as nn
import torch.utils.data
class dilation_layer(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, padding=
'same_padding', dilation=1):
super().__init__()
if padding == 'same_padding':
padding = int((kernel_size - 1) / 2 *... |
MSELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
class MSELoss(nn.Module):
def __init__(self):
super(self.__class__, self).__init__()
def forward(self, input, target):
return torch.mean(torch.sum((input - target) ** 2, 1))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), to... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._... | kejiejiang/UnsupervisedDeepLearning-Pytorch | MSELoss | false | 15,788 | [
"MIT"
] | 87 | 6ea7b7151ae62bf0130b56cc023f2be068aa87f0 | https://github.com/kejiejiang/UnsupervisedDeepLearning-Pytorch/tree/6ea7b7151ae62bf0130b56cc023f2be068aa87f0 | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
def __init__(self):
super(self.__class__, self).__init__()
def forward(self, input, target):
return torch.mean(torch.sum((input - target) ** 2, 1))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torc... |
StageBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1):
super(ConvBlock, self).__init__()
self.Mconv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | kacel33/ActionAI_PC | StageBlock | false | 15,789 | [
"MIT"
] | 1,311 | a0528f49ea61cc07d7c1e9a3cd6846e5f50cfae7 | https://github.com/kacel33/ActionAI_PC/tree/a0528f49ea61cc07d7c1e9a3cd6846e5f50cfae7 | import torch
import torch.nn as nn
import torch.utils.data
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1):
super().__init__()
self.Mconv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channels, kernel_size=... |
SeparableConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils
import torch.nn.parallel
class SeparableConv(nn.Module):
def __init__(self, in_planes, out_planes, kernel_size, bias):
super(SeparableConv, self).__init__()
padding = (kernel_size - 1) // 2
self.depthwise = nn.Conv2d(in_planes, in_plan... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils
import torch.nn.parallel
assert_size_st... | kcyu2014/eval-nas | SeparableConv | false | 15,790 | [
"MIT"
] | 47 | 385376a3ef96336b54ee7e696af1d02b97aa5c32 | https://github.com/kcyu2014/eval-nas/tree/385376a3ef96336b54ee7e696af1d02b97aa5c32 | import torch
import torch.nn as nn
import torch.utils
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, in_planes, out_planes, kernel_size, bias):
super().__init__()
padding = (kernel_size - 1) // 2
self.depthwise = nn.Conv2d(in_planes, in_planes, kernel_size=
... |
ConstractiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class ConstractiveLoss(nn.Module):
def __init__(self, margin=2.0, dist_flag='l2'):
super(ConstractiveLoss, self).__init__()
self.margin = margin
self.dist_flag = dist_flag
def various_distance(self,... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import numpy as np
import to... | kensakurada/SceneChangeDet | ConstractiveLoss | false | 15,791 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, margin=2.0, dist_flag='l2'):
super().__init__()
self.margin = margin
self.dist_flag = dist_flag
def various_distance(self, out_vec_t0, out_vec_t1):
... |
l1normalization | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class l1normalization(nn.Module):
def __init__(self, scale):
super(l1normalization, self).__init__()
self.scale = scale
def forward(self, x, dim=1):
return self.scale * x * x.pow(1).sum(dim).clamp(min=1e-12).rsqrt(
).expand_as(x)
def g... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | kensakurada/SceneChangeDet | l1normalization | false | 15,792 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x, dim=1):
return self.scale * x * x.pow(1).sum(dim).clamp(min=1e-12).rsqrt(
).expand_as(x)
def get_inputs():
return [torch.... |
QueryModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class QueryModule(nn.Module):
"""
A neural module that takes as input a feature map and an attention and produces a feature
map as output.
Extended Summary
----------------
A :class:`QueryModule` takes a feature map and an... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | kdexd/probnmn-clevr | QueryModule | false | 15,793 | [
"MIT"
] | 69 | 9c1b2286cf30e9fb045370153c9242a39760e02e | https://github.com/kdexd/probnmn-clevr/tree/9c1b2286cf30e9fb045370153c9242a39760e02e | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
A neural module that takes as input a feature map and an attention and produces a feature
map as output.
Extended Summary
----------------
A :class:`QueryModule` takes a feature map and an atten... |
ComparisonModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class ComparisonModule(nn.Module):
"""
A neural module that takes as input two feature maps and produces a feature map as output.
Extended Summary
----------------
A :class:`ComparisonModule` takes two feature maps as input an... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | kdexd/probnmn-clevr | ComparisonModule | false | 15,794 | [
"MIT"
] | 69 | 9c1b2286cf30e9fb045370153c9242a39760e02e | https://github.com/kdexd/probnmn-clevr/tree/9c1b2286cf30e9fb045370153c9242a39760e02e | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
A neural module that takes as input two feature maps and produces a feature map as output.
Extended Summary
----------------
A :class:`ComparisonModule` takes two feature maps as input and concatena... |
AttentionModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class AttentionModule(nn.Module):
"""
A neural module that takes a feature map and attention, attends to the features, and produces
an attention.
Extended Summary
----------------
A :class:`AttentionModule` takes input fea... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | kdexd/probnmn-clevr | AttentionModule | false | 15,795 | [
"MIT"
] | 69 | 9c1b2286cf30e9fb045370153c9242a39760e02e | https://github.com/kdexd/probnmn-clevr/tree/9c1b2286cf30e9fb045370153c9242a39760e02e | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
A neural module that takes a feature map and attention, attends to the features, and produces
an attention.
Extended Summary
----------------
A :class:`AttentionModule` takes input features and ... |
Aggregation | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn import *
class Aggregation(nn.Module):
"""
Aggregation layer for the Dueling architecture.
https://arxiv.org/abs/1511.06581
This layer computes a Q function by combining
an estimate of V with an estimate of the advantage.
The advantage is normal... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
from torch.nn import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._d... | kcorder/autonomous-learning-library | Aggregation | false | 15,796 | [
"MIT"
] | 584 | 0266195fa47564e51a32087bc007bff6dda5e263 | https://github.com/kcorder/autonomous-learning-library/tree/0266195fa47564e51a32087bc007bff6dda5e263 | import torch
from torch import nn
from torch.nn import *
class Model(nn.Module):
"""
Aggregation layer for the Dueling architecture.
https://arxiv.org/abs/1511.06581
This layer computes a Q function by combining
an estimate of V with an estimate of the advantage.
The advantage is normalized b... |
FeatureCorrelation | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class FeatureCorrelation(nn.Module):
def __init__(self, scale):
super(FeatureCorrelation, self).__init__()
self.scale = scale
def forward(self, feature_A, feature_B):
b, c, h, w = feature_A.size()
feature_A = feature_A.transpose(2, 3).contig... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | kensakurada/SceneChangeDet | FeatureCorrelation | false | 15,797 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, feature_A, feature_B):
b, c, h, w = feature_A.size()
feature_A = feature_A.transpose(2, 3).contiguous().view(b, c, h * w)
feat... |
KLCoefficient | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class KLCoefficient(nn.Module):
def __init__(self):
super(KLCoefficient, self).__init__()
def forward(self, hist1, hist2):
kl = F.kl_div(hist1, hist2)
dist = 1.0 / 1 + kl
return dist
def get_inputs():
re... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | kensakurada/SceneChangeDet | KLCoefficient | false | 15,798 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, hist1, hist2):
kl = F.kl_div(hist1, hist2)
dist = 1.0 / 1 + kl
return dist
def get_inputs():
return [torch.rand([4, 4, 4, ... |
RelateModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class RelateModule(nn.Module):
"""
A neural module that takes as input a feature map and an attention and produces an attention
as output.
Extended Summary
----------------
A :class:`RelateModule` takes input features and ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | kdexd/probnmn-clevr | RelateModule | false | 15,799 | [
"MIT"
] | 69 | 9c1b2286cf30e9fb045370153c9242a39760e02e | https://github.com/kdexd/probnmn-clevr/tree/9c1b2286cf30e9fb045370153c9242a39760e02e | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
A neural module that takes as input a feature map and an attention and produces an attention
as output.
Extended Summary
----------------
A :class:`RelateModule` takes input features and an atte... |
l2normalization | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class l2normalization(nn.Module):
def __init__(self, scale):
super(l2normalization, self).__init__()
self.scale = scale
def forward(self, x, dim=1):
"""out = scale * x / sqrt(\\sum x_i^2)"""
return self.scale * x * x.pow(2).sum(dim).clamp(mi... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | kensakurada/SceneChangeDet | l2normalization | false | 15,800 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x, dim=1):
"""out = scale * x / sqrt(\\sum x_i^2)"""
return self.scale * x * x.pow(2).sum(dim).clamp(min=1e-12).rsqrt(
).e... |
StatsNet | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.utils.data
class StatsNet(nn.Module):
def __init__(self):
super(StatsNet, self).__init__()
def forward(self, x):
x = x.view(x.data.shape[0], x.data.shape[1], x.data.shape[2] * x.
data.shape[3])
mean = torch.mean(x, 2)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | kerenalli/Capsule-Forensics-v2 | StatsNet | false | 15,801 | [
"BSD-3-Clause"
] | 97 | 8e60ca0035f8392a543f7fad37ab3704d43021cf | https://github.com/kerenalli/Capsule-Forensics-v2/tree/8e60ca0035f8392a543f7fad37ab3704d43021cf | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
x = x.view(x.data.shape[0], x.data.shape[1], x.data.shape[2] * x.
data.shape[3])
mean = torch.mean(x, 2)
std = torch.std(... |
GaussianKLLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class GaussianKLLoss(nn.Module):
def __init__(self):
super(GaussianKLLoss, self).__init__()
def forward(self, mu1, logvar1, mu2, logvar2):
numerator = logvar1.exp() + torch.pow(mu1 - mu2, 2)
fraction = torch.div(numerator, logvar2.exp())
kl ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | kekayan/Info-HCVAE | GaussianKLLoss | false | 15,802 | [
"Apache-2.0"
] | 120 | 1f4d536523767f439e689d8963c54a55fb75c6f9 | https://github.com/kekayan/Info-HCVAE/tree/1f4d536523767f439e689d8963c54a55fb75c6f9 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, mu1, logvar1, mu2, logvar2):
numerator = logvar1.exp() + torch.pow(mu1 - mu2, 2)
fraction = torch.div(numerator, logvar2.exp())
kl = 0.5 * torch.sum(logvar2 - l... |
BhattacharyyaDistance | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class BhattacharyyaDistance(nn.Module):
def __init__(self):
super(BhattacharyyaDistance, self).__init__()
def forward(self, hist1, hist2):
bh_dist = torch.sqrt(hist1 * hist2).sum()
return bh_dist
def get_inputs():
return [torch.rand([4, 4, 4, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | kensakurada/SceneChangeDet | BhattacharyyaDistance | false | 15,803 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, hist1, hist2):
bh_dist = torch.sqrt(hist1 * hist2).sum()
return bh_dist
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_in... |
Perplexity | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as t
import torch.nn as nn
import torch.nn.functional as F
class Perplexity(nn.Module):
def __init__(self):
super(Perplexity, self).__init__()
def forward(self, logits, target):
"""
:param logits: tensor with shape of [batch_size, seq_len, input_size]
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | kefirski/contiguous-succotash | Perplexity | false | 15,804 | [
"MIT"
] | 57 | 7497efd1392693248ed98805dcdbbf5dc125afc2 | https://github.com/kefirski/contiguous-succotash/tree/7497efd1392693248ed98805dcdbbf5dc125afc2 | import torch
import torch as t
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, logits, target):
"""
:param logits: tensor with shape of [batch_size, seq_len, input_size]
:param target: tens... |
StableBCELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class StableBCELoss(nn.Module):
def __init__(self):
super(StableBCELoss, self).__init__()
def forward(self, input: 'torch.Tensor', target: 'torch.Tensor'):
input = input.float().view(-1)
target = target.float().view(-1)
neg_abs = -input.abs()... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | kevinkwshin/kaggle-pneumothorax | StableBCELoss | false | 15,805 | [
"MIT"
] | 74 | 24b91a9425097023f0cc7781a9380cb247babe22 | https://github.com/kevinkwshin/kaggle-pneumothorax/tree/24b91a9425097023f0cc7781a9380cb247babe22 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input: 'torch.Tensor', target: 'torch.Tensor'):
input = input.float().view(-1)
target = target.float().view(-1)
neg_abs = -input.abs()
loss = input.clamp... |
MultiHeadedAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
from typing import Optional
from torch import nn
class MultiHeadedAttention(nn.Module):
"""Multi-Head Attention layer
:param int n_head: the number of head s
:param int n_feat: the number of features
:param float dropout_rate: dropout rate
"""
def ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | karan-deepsync/FastSpeech2 | MultiHeadedAttention | false | 15,806 | [
"Apache-2.0"
] | 148 | 84ad261db4a865536b2e15dfb8346644c3192704 | https://github.com/karan-deepsync/FastSpeech2/tree/84ad261db4a865536b2e15dfb8346644c3192704 | import math
import torch
import numpy as np
from typing import Optional
from torch import nn
class Model(nn.Module):
"""Multi-Head Attention layer
:param int n_head: the number of head s
:param int n_feat: the number of features
:param float dropout_rate: dropout rate
"""
def __init__(self, ... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils
import torch.nn.functional as F
import torch.nn.parallel
class Attention(nn.Module):
def __init__(self, input_dim, source_dim=None, output_dim=None, bias=False
):
super(Attention, self).__init__()
if source_dim is None:
sou... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kcyu2014/eval-nas | Attention | false | 15,807 | [
"MIT"
] | 47 | 385376a3ef96336b54ee7e696af1d02b97aa5c32 | https://github.com/kcyu2014/eval-nas/tree/385376a3ef96336b54ee7e696af1d02b97aa5c32 | import torch
import torch.nn as nn
import torch.utils
import torch.nn.functional as F
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, input_dim, source_dim=None, output_dim=None, bias=False
):
super().__init__()
if source_dim is None:
source_dim = input_dim... |
ConstractiveThresholdHingeLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class ConstractiveThresholdHingeLoss(nn.Module):
def __init__(self, hingethresh=0.0, margin=2.0):
super(ConstractiveThresholdHingeLoss, self).__init__()
self.threshold = hingethresh
self.margin = margin
def forward(se... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | kensakurada/SceneChangeDet | ConstractiveThresholdHingeLoss | false | 15,808 | [
"MIT"
] | 199 | 0530e0162863fec0c5296188526f0d27e0109814 | https://github.com/kensakurada/SceneChangeDet/tree/0530e0162863fec0c5296188526f0d27e0109814 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, hingethresh=0.0, margin=2.0):
super().__init__()
self.threshold = hingethresh
self.margin = margin
def forward(self, out_vec_t0, out_vec_t1, label):
distance = F.pair... |
AdjDecoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class AdjDecoder(nn.Module):
u""" Decode an input (parent) feature into a left-child and a right-child feature """
def __init__(self, feature_size, hidden_size):
super(AdjDecoder, self).__init__()
self.mlp = nn.Linear(feature_size, hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | kevin-kaixu/grass_pytorch | AdjDecoder | false | 15,809 | [
"Apache-2.0"
] | 85 | 1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | https://github.com/kevin-kaixu/grass_pytorch/tree/1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
u""" Decode an input (parent) feature into a left-child and a right-child feature """
def __init__(self, feature_size, hidden_size):
super().__init__()
self.mlp = nn.Linear(feature_size, hidden_size)
sel... |
NodeClassifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class NodeClassifier(nn.Module):
def __init__(self, feature_size, hidden_size):
super(NodeClassifier, self).__init__()
self.mlp1 = nn.Linear(feature_size, hidden_size)
self.tanh = nn.Tanh()
self.mlp2 = nn.Linear(hidden_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | kevin-kaixu/grass_pytorch | NodeClassifier | false | 15,810 | [
"Apache-2.0"
] | 85 | 1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | https://github.com/kevin-kaixu/grass_pytorch/tree/1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, feature_size, hidden_size):
super().__init__()
self.mlp1 = nn.Linear(feature_size, hidden_size)
self.tanh = nn.Tanh()
self.mlp2 = nn.Linear(hidden_size, 3)
def forward(self, i... |
CategoricalKLLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class CategoricalKLLoss(nn.Module):
def __init__(self):
super(CategoricalKLLoss, self).__init__()
def forward(self, P, Q):
log_P = P.log()
log_Q = Q.log()
kl = (P * (log_P - log_Q)).sum(dim=-1).sum(dim=-1)
return kl.mean(dim=0)
def... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | kekayan/Info-HCVAE | CategoricalKLLoss | false | 15,811 | [
"Apache-2.0"
] | 120 | 1f4d536523767f439e689d8963c54a55fb75c6f9 | https://github.com/kekayan/Info-HCVAE/tree/1f4d536523767f439e689d8963c54a55fb75c6f9 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, P, Q):
log_P = P.log()
log_Q = Q.log()
kl = (P * (log_P - log_Q)).sum(dim=-1).sum(dim=-1)
return kl.mean(dim=0)
def get_inputs():
return [torch.ra... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1_1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
self.prelu1_1 = nn.PReLU()
self.conv1_2 = nn.Conv2d(32, 32, kernel_size=5, padding=2)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jxgu1016/MNIST_with_centerloss.pytorch | Net | false | 15,812 | [
"MIT"
] | 346 | 4e94cc77fe94056a7f1f081fcaf0325781ba0224 | https://github.com/jxgu1016/MNIST_with_centerloss.pytorch/tree/4e94cc77fe94056a7f1f081fcaf0325781ba0224 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1_1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
self.prelu1_1 = nn.PReLU()
self.conv1_2 = nn.Conv2d(32, 32, kernel_size=5, padding=2)
... |
dilated_1D | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
class dilated_1D(nn.Module):
def __init__(self, cin, cout, dilation_factor=2):
super(dilated_1D, self).__init__()
self.tconv = nn.ModuleList()
self.kernel_set = [2, 3, 6, 7]
self.tconv = nn.Conv2d(cin, cout, (1, 7), dilati... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dyn... | kevin-xuan/Traffic-Benchmark | dilated_1D | false | 15,813 | [
"MIT"
] | 120 | b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | https://github.com/kevin-xuan/Traffic-Benchmark/tree/b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, cin, cout, dilation_factor=2):
super().__init__()
self.tconv = nn.ModuleList()
self.kernel_set = [2, 3, 6, 7]
self.tconv = nn.Conv2d(cin, cout, (1, 7), dilation=(1, dilation_facto... |
SymEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class SymEncoder(nn.Module):
def __init__(self, feature_size, symmetry_size, hidden_size):
super(SymEncoder, self).__init__()
self.left = nn.Linear(feature_size, hidden_size)
self.right = nn.Linear(symmetry_size, hidden_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | kevin-kaixu/grass_pytorch | SymEncoder | false | 15,814 | [
"Apache-2.0"
] | 85 | 1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | https://github.com/kevin-kaixu/grass_pytorch/tree/1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, feature_size, symmetry_size, hidden_size):
super().__init__()
self.left = nn.Linear(feature_size, hidden_size)
self.right = nn.Linear(symmetry_size, hidden_size)
self.second = nn.L... |
gconv_RNN | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn as nn
class gconv_RNN(nn.Module):
def __init__(self):
super(gconv_RNN, self).__init__()
def forward(self, x, A):
x = torch.einsum('nvc,nvw->nwc', (x, A))
return x.contiguous()
def get_inputs():
return [torch.rand([4, 4, 4]), ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dyn... | kevin-xuan/Traffic-Benchmark | gconv_RNN | false | 15,815 | [
"MIT"
] | 120 | b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | https://github.com/kevin-xuan/Traffic-Benchmark/tree/b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, A):
x = torch.einsum('nvc,nvw->nwc', (x, A))
return x.contiguous()
def get_inputs():
return [torch.rand([4, 4, 4]), torch.rand([4, 4, 4... |
AdjEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class AdjEncoder(nn.Module):
def __init__(self, feature_size, hidden_size):
super(AdjEncoder, self).__init__()
self.left = nn.Linear(feature_size, hidden_size)
self.right = nn.Linear(feature_size, hidden_size, bias=False)
s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | kevin-kaixu/grass_pytorch | AdjEncoder | false | 15,816 | [
"Apache-2.0"
] | 85 | 1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | https://github.com/kevin-kaixu/grass_pytorch/tree/1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, feature_size, hidden_size):
super().__init__()
self.left = nn.Linear(feature_size, hidden_size)
self.right = nn.Linear(feature_size, hidden_size, bias=False)
self.second = nn.Linea... |
SymDecoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class SymDecoder(nn.Module):
def __init__(self, feature_size, symmetry_size, hidden_size):
super(SymDecoder, self).__init__()
self.mlp = nn.Linear(feature_size, hidden_size)
self.tanh = nn.Tanh()
self.mlp_sg = nn.Linear(hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | kevin-kaixu/grass_pytorch | SymDecoder | false | 15,817 | [
"Apache-2.0"
] | 85 | 1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | https://github.com/kevin-kaixu/grass_pytorch/tree/1d8dc6dcc0ab3ca029e449f57c37ba3910a4f90a | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, feature_size, symmetry_size, hidden_size):
super().__init__()
self.mlp = nn.Linear(feature_size, hidden_size)
self.tanh = nn.Tanh()
self.mlp_sg = nn.Linear(hidden_size, feature_siz... |
FocalLoss2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class FocalLoss2d(nn.Module):
def __init__(self, gamma=2, ignore_index=255):
super().__init__()
self.gamma = gamma
self.ignore_index = ignore_index
def forward(self, outputs: 'torch.Tensor', targets: 'torch.Tensor'):
outputs = outputs.contigu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | kevinkwshin/kaggle-pneumothorax | FocalLoss2d | false | 15,818 | [
"MIT"
] | 74 | 24b91a9425097023f0cc7781a9380cb247babe22 | https://github.com/kevinkwshin/kaggle-pneumothorax/tree/24b91a9425097023f0cc7781a9380cb247babe22 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, gamma=2, ignore_index=255):
super().__init__()
self.gamma = gamma
self.ignore_index = ignore_index
def forward(self, outputs: 'torch.Tensor', targets: 'torch.Tensor'):
outputs = outputs.contiguous()
... |
AdaptiveAvgPool3dOutSize1 | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import Tuple
import torch.nn as nn
from abc import abstractmethod
import torch.utils.data
import torch.nn
class EfficientBlockBase(nn.Module):
"""
PyTorchVideo/accelerator provides a set of efficient blocks
that have optimal efficiency for each target hardware device.
Each ef... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from typing import Tuple
import torch.nn as nn
from abc import abstractmethod
import torch.utils.data
import torch.nn
assert_size_stride = t... | kevinmtian/pytorchvideo | AdaptiveAvgPool3dOutSize1 | false | 15,819 | [
"Apache-2.0"
] | 2,391 | 168e16859a6029ef8ebeb476f9163bebb6c6b87d | https://github.com/kevinmtian/pytorchvideo/tree/168e16859a6029ef8ebeb476f9163bebb6c6b87d | import torch
from typing import Tuple
import torch.nn as nn
from abc import abstractmethod
import torch.utils.data
import torch.nn
class EfficientBlockBase(nn.Module):
"""
PyTorchVideo/accelerator provides a set of efficient blocks
that have optimal efficiency for each target hardware device.
Each ef... |
JaccardLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
def jaccard(outputs, targets, per_image=False, non_empty=False, min_pixels=5):
batch_size = outputs.size()[0]
eps = 0.001
if not per_image:
batch_size = 1
dice_target = targets.contiguous().view(batch_size, -1).float()
dice_output = outputs.contiguous().vi... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | kevinkwshin/kaggle-pneumothorax | JaccardLoss | false | 15,820 | [
"MIT"
] | 74 | 24b91a9425097023f0cc7781a9380cb247babe22 | https://github.com/kevinkwshin/kaggle-pneumothorax/tree/24b91a9425097023f0cc7781a9380cb247babe22 | import torch
from torch import nn
def jaccard(outputs, targets, per_image=False, non_empty=False, min_pixels=5):
batch_size = outputs.size()[0]
eps = 0.001
if not per_image:
batch_size = 1
dice_target = targets.contiguous().view(batch_size, -1).float()
dice_output = outputs.contiguous().vi... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
def soft_dice_loss(outputs, targets, per_image=False):
batch_size = outputs.size()[0]
eps = 1e-05
if not per_image:
batch_size = 1
dice_target = targets.contiguous().view(batch_size, -1).float()
dice_output = outputs.contiguous().view(batch_size, -1)
i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | kevinkwshin/kaggle-pneumothorax | DiceLoss | false | 15,821 | [
"MIT"
] | 74 | 24b91a9425097023f0cc7781a9380cb247babe22 | https://github.com/kevinkwshin/kaggle-pneumothorax/tree/24b91a9425097023f0cc7781a9380cb247babe22 | import torch
from torch import nn
def soft_dice_loss(outputs, targets, per_image=False):
batch_size = outputs.size()[0]
eps = 1e-05
if not per_image:
batch_size = 1
dice_target = targets.contiguous().view(batch_size, -1).float()
dice_output = outputs.contiguous().view(batch_size, -1)
i... |
MaskedTemporalPooling | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import Optional
import torch.utils.data
import torch.nn
class MaskedTemporalPooling(torch.nn.Module):
"""
Applies temporal pooling operations on masked inputs. For each pooling operation
all masked values are ignored.
"""
def __init__(self, method: 'str'):
"""
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
import torch.nn
assert_size_stride = torch._C._dynamo.guards.asse... | kevinmtian/pytorchvideo | MaskedTemporalPooling | false | 15,822 | [
"Apache-2.0"
] | 2,391 | 168e16859a6029ef8ebeb476f9163bebb6c6b87d | https://github.com/kevinmtian/pytorchvideo/tree/168e16859a6029ef8ebeb476f9163bebb6c6b87d | import torch
from typing import Optional
import torch.utils.data
import torch.nn
class Model(torch.nn.Module):
"""
Applies temporal pooling operations on masked inputs. For each pooling operation
all masked values are ignored.
"""
def __init__(self, method: 'str'):
"""
method (str... |
PSNRLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
def psnr(gt, pred, data_range=None, batch=True, reduce=True):
""" Compute the peak signal to noise ratio (psnr)
:param gt: gt image (torch.Tensor
:param pred: input image (torch.Tensor)
:param data_range: if None, estimated from gt
:return: (mean) psnr
"""
if batch:
ba... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
assert_size... | khammernik/sigmanet | PSNRLoss | false | 15,823 | [
"MIT"
] | 50 | 6eb8dbd1ee350bb9baee60eb254080f7d660bbc5 | https://github.com/khammernik/sigmanet/tree/6eb8dbd1ee350bb9baee60eb254080f7d660bbc5 | import torch
def psnr(gt, pred, data_range=None, batch=True, reduce=True):
""" Compute the peak signal to noise ratio (psnr)
:param gt: gt image (torch.Tensor
:param pred: input image (torch.Tensor)
:param data_range: if None, estimated from gt
:return: (mean) psnr
"""
if batch:
ba... |
LearnMaskedDefault | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn
class LearnMaskedDefault(nn.Module):
"""
Learns default values to fill invalid entries within input tensors. The
invalid entries are represented by a mask which is passed into forward alongside
the input tensor. Note the defaul... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
import torch.nn
assert_size_stride = torch.... | kevinmtian/pytorchvideo | LearnMaskedDefault | false | 15,824 | [
"Apache-2.0"
] | 2,391 | 168e16859a6029ef8ebeb476f9163bebb6c6b87d | https://github.com/kevinmtian/pytorchvideo/tree/168e16859a6029ef8ebeb476f9163bebb6c6b87d | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn
class Model(nn.Module):
"""
Learns default values to fill invalid entries within input tensors. The
invalid entries are represented by a mask which is passed into forward alongside
the input tensor. Note the default value is on... |
SpatialSoftArgmax | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
import torch.nn as nn
import torch.nn.functional as F
class SpatialSoftArgmax(nn.Module):
"""Spatial softmax as defined in `1`_.
Concretely, the spatial softmax of each feature map is used to compute a
weighted mean of the pixel locations, effectively performing a so... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import Tens... | kevinzakka/torchkit | SpatialSoftArgmax | false | 15,825 | [
"MIT"
] | 144 | 930dba9560d2473406b59b99a474dce1a6621813 | https://github.com/kevinzakka/torchkit/tree/930dba9560d2473406b59b99a474dce1a6621813 | import torch
from torch import Tensor
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Spatial softmax as defined in `1`_.
Concretely, the spatial softmax of each feature map is used to compute a
weighted mean of the pixel locations, effectively performing a soft arg-max
... |
TransposeMultiheadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from typing import Optional
import torch.utils.data
import torch.nn
class TransposeMultiheadAttention(nn.Module):
"""
Wrapper for nn.MultiheadAttention which first transposes the input tensor
from (batch_size, seq_len, feature_dim) to (seq_length, batch_size, feature_dim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kevinmtian/pytorchvideo | TransposeMultiheadAttention | false | 15,826 | [
"Apache-2.0"
] | 2,391 | 168e16859a6029ef8ebeb476f9163bebb6c6b87d | https://github.com/kevinmtian/pytorchvideo/tree/168e16859a6029ef8ebeb476f9163bebb6c6b87d | import torch
import torch.nn as nn
from typing import Optional
import torch.utils.data
import torch.nn
class Model(nn.Module):
"""
Wrapper for nn.MultiheadAttention which first transposes the input tensor
from (batch_size, seq_len, feature_dim) to (seq_length, batch_size, feature_dim),
then applies th... |
ScalingBlock | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class ScalingBlock(nn.Module):
def __init__(self, temp=5.0, **kwargs):
super(ScalingBlock, self).__init__()
self.temp = temp
def forward(self, x):
x = x / self.temp
return x
def extra_repr(self):
return 'temp=%.3e' % self.temp
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | kimfunn/spatial-smoothing | ScalingBlock | false | 15,827 | [
"Apache-2.0"
] | 438 | 4f849d57c66c2dbdfaa56fc28727e95eddfd337c | https://github.com/kimfunn/spatial-smoothing/tree/4f849d57c66c2dbdfaa56fc28727e95eddfd337c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, temp=5.0, **kwargs):
super().__init__()
self.temp = temp
def forward(self, x):
x = x / self.temp
return x
def extra_repr(self):
return 'temp=%.3e' % self.temp
def get_inputs():
re... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
class ConvNorm(nn.Module):
""" 1D Convolution """
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=None, dilation=1, bias=True, w_init_gain='linear'):
super(ConvNorm, self).__init__()
if padding is None:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | keonlee9420/DiffSinger | ResidualBlock | false | 15,828 | [
"MIT"
] | 95 | 2bfcae4a78068c2061eae64ee675959a077aa54b | https://github.com/keonlee9420/DiffSinger/tree/2bfcae4a78068c2061eae64ee675959a077aa54b | import math
import torch
import torch.nn as nn
class ConvNorm(nn.Module):
""" 1D Convolution """
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=None, dilation=1, bias=True, w_init_gain='linear'):
super().__init__()
if padding is None:
assert... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss tensor.
"""
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | kivanctezoren/mmclassification | FocalLoss | false | 15,829 | [
"Apache-2.0"
] | 1,190 | 5c73d4b29f61c47d379bbec4621a465099e64bd7 | https://github.com/kivanctezoren/mmclassification/tree/5c73d4b29f61c47d379bbec4621a465099e64bd7 | import torch
import torch.nn as nn
import torch.nn.functional as F
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss tensor.
"""
... |
AsymmetricLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss tensor.
"""
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | kivanctezoren/mmclassification | AsymmetricLoss | false | 15,830 | [
"Apache-2.0"
] | 1,190 | 5c73d4b29f61c47d379bbec4621a465099e64bd7 | https://github.com/kivanctezoren/mmclassification/tree/5c73d4b29f61c47d379bbec4621a465099e64bd7 | import torch
import torch.nn as nn
import torch.nn.functional as F
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss tensor.
"""
... |
TransformerEncoderLayerWithConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class TransformerEncoderLayerWithConv1d(nn.Module):
"""
Input and output shape: seqlen x batch_size x dim
"""
def __init__(self, dim_model, nheads, dim_feedforward, dropout,
kernel_size, stride):
super(TransformerEnc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jzlianglu/pykaldi2 | TransformerEncoderLayerWithConv1d | false | 15,831 | [
"MIT"
] | 179 | 4d31968f8dff7cccf6a8395b7e69005ae3b2b30a | https://github.com/jzlianglu/pykaldi2/tree/4d31968f8dff7cccf6a8395b7e69005ae3b2b30a | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Input and output shape: seqlen x batch_size x dim
"""
def __init__(self, dim_model, nheads, dim_feedforward, dropout,
kernel_size, stride):
super().__init__()
self.encoder_layer = ... |
DeterministicSumming | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class DeterministicSumming(nn.Module):
"""Transform a tensor into repetitions of its sum.
Intended for use in tests, not useful for actual learning. The last
dimension of the input should contain feature vectors. The result will be
an array of matching shape with th... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | kiudee/cs-ranking | DeterministicSumming | false | 15,832 | [
"Apache-2.0"
] | 65 | 47cf648fa286c37b9214bbad1926004d4d7d9796 | https://github.com/kiudee/cs-ranking/tree/47cf648fa286c37b9214bbad1926004d4d7d9796 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Transform a tensor into repetitions of its sum.
Intended for use in tests, not useful for actual learning. The last
dimension of the input should contain feature vectors. The result will be
an array of matching shape with the last dimensio... |
SparsityLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class SparsityLoss(nn.Module):
""" Penalizes small values to encourage sparsity """
def __init__(self):
super(SparsityLoss, self).__init__()
self.power = 0.2
self.loss = nn.L1Loss()
def forward(self, kernel):
retu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | kingsj0405/Explorable-Super-Resolution | SparsityLoss | false | 15,833 | [
"Apache-2.0"
] | 54 | 6582477ec1e2b0c6f4bd781552ac880fabdb4496 | https://github.com/kingsj0405/Explorable-Super-Resolution/tree/6582477ec1e2b0c6f4bd781552ac880fabdb4496 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
""" Penalizes small values to encourage sparsity """
def __init__(self):
super().__init__()
self.power = 0.2
self.loss = nn.L1Loss()
def forward(self, kernel):
return self.loss(torch.abs(ke... |
BertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
class BertSelfAttention(nn.Module):
def __init__(self, config):
super(BertSelfAttention, self).__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | BIT-ENGD/eeqa | BertSelfAttention | false | 15,834 | [
"MIT"
] | 142 | 2995abbaff1fb47131246a247ee7ed62aa94f4c3 | https://github.com/BIT-ENGD/eeqa/tree/2995abbaff1fb47131246a247ee7ed62aa94f4c3 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
'The hidden size (%d) is not a ... |
WayPoly | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class WayPoly(torch.nn.Module):
"""Apply multiple modules to input and sum.
It's equation for `poly_modules` length equal to :math:`N` could be expressed by
!!!math
I + F_1(I) + F_2(I) + ... + F_N
where :math:`I` is identity and consecutive :math:`F_N` are consecutive `poly_mo... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | klaudiapalasz/torchlayers | WayPoly | false | 15,835 | [
"MIT"
] | 573 | e6edd8797875325b7c0539d75a12f0d51f494127 | https://github.com/klaudiapalasz/torchlayers/tree/e6edd8797875325b7c0539d75a12f0d51f494127 | import torch
class Model(torch.nn.Module):
"""Apply multiple modules to input and sum.
It's equation for `poly_modules` length equal to :math:`N` could be expressed by
!!!math
I + F_1(I) + F_2(I) + ... + F_N
where :math:`I` is identity and consecutive :math:`F_N` are consecutive `poly_modu... |
Spatial_Attention_layer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
import torch.nn as nn
class Spatial_Attention_layer(nn.Module):
"""
compute spatial attention scores
"""
def __init__(self, DEVICE, in_channels, num_of_vertices, num_of_timesteps):
super(Spatial_Attention_layer, self).__init... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kevin-xuan/Traffic-Benchmark | Spatial_Attention_layer | false | 15,836 | [
"MIT"
] | 120 | b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | https://github.com/kevin-xuan/Traffic-Benchmark/tree/b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | import torch
import torch.utils.data
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""
compute spatial attention scores
"""
def __init__(self, DEVICE, in_channels, num_of_vertices, num_of_timesteps):
super().__init__()
self.W1 = nn.Parameter(torch.Float... |
Temporal_Attention_layer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
import torch.nn as nn
class Temporal_Attention_layer(nn.Module):
def __init__(self, DEVICE, in_channels, num_of_vertices, num_of_timesteps):
super(Temporal_Attention_layer, self).__init__()
self.U1 = nn.Parameter(torch.FloatTens... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kevin-xuan/Traffic-Benchmark | Temporal_Attention_layer | false | 15,837 | [
"MIT"
] | 120 | b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | https://github.com/kevin-xuan/Traffic-Benchmark/tree/b9f8e40b4df9b58f5ad88432dc070cbbbcdc0228 | import torch
import torch.utils.data
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, DEVICE, in_channels, num_of_vertices, num_of_timesteps):
super().__init__()
self.U1 = nn.Parameter(torch.FloatTensor(num_of_vertices))
self.U2 = nn.Paramet... |
Optimizable_Temperature | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
class Optimizable_Temperature(torch.nn.Module):
def __init__(self, initial_temperature=None):
super(Optimizable_Temperature, self).__init__()
self.log_temperature = torch.nn.Parameter(data=torch.zeros([1]).
type(torch.DoubleTensor))
if init... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_siz... | kingsj0405/Explorable-Super-Resolution | Optimizable_Temperature | false | 15,838 | [
"Apache-2.0"
] | 54 | 6582477ec1e2b0c6f4bd781552ac880fabdb4496 | https://github.com/kingsj0405/Explorable-Super-Resolution/tree/6582477ec1e2b0c6f4bd781552ac880fabdb4496 | import torch
import torch.utils.data
class Model(torch.nn.Module):
def __init__(self, initial_temperature=None):
super().__init__()
self.log_temperature = torch.nn.Parameter(data=torch.zeros([1]).
type(torch.DoubleTensor))
if initial_temperature is not None:
self.l... |
HardSigmoid | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
def hard_sigmoid(tensor: 'torch.Tensor', inplace: 'bool'=False) ->torch.Tensor:
"""
Applies HardSigmoid function element-wise.
See :class:`torchlayers.activations.HardSigmoid` for more details.
Arguments:
tensor :
Tensor activated element-wise
inplace :
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | klaudiapalasz/torchlayers | HardSigmoid | false | 15,839 | [
"MIT"
] | 573 | e6edd8797875325b7c0539d75a12f0d51f494127 | https://github.com/klaudiapalasz/torchlayers/tree/e6edd8797875325b7c0539d75a12f0d51f494127 | import torch
def hard_sigmoid(tensor: 'torch.Tensor', inplace: 'bool'=False) ->torch.Tensor:
"""
Applies HardSigmoid function element-wise.
See :class:`torchlayers.activations.HardSigmoid` for more details.
Arguments:
tensor :
Tensor activated element-wise
inplace :
... |
Blur | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class SamePad(nn.Module):
def __init__(self, filter_size, pad_mode='constant', **kwargs):
super(SamePad, self).__init__()
self.pad_size = [int((filter_size - 1) / 2.0), int(math.ceil((
filter_size - 1) / 2.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
import torch.nn.functional as F
assert_size_st... | kimfunn/spatial-smoothing | Blur | false | 15,840 | [
"Apache-2.0"
] | 438 | 4f849d57c66c2dbdfaa56fc28727e95eddfd337c | https://github.com/kimfunn/spatial-smoothing/tree/4f849d57c66c2dbdfaa56fc28727e95eddfd337c | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class SamePad(nn.Module):
def __init__(self, filter_size, pad_mode='constant', **kwargs):
super().__init__()
self.pad_size = [int((filter_size - 1) / 2.0), int(math.ceil((
filter_size - 1) / 2.0)), int((fil... |
Downsample | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Downsample(nn.Module):
def __init__(self, strides=(2, 2), **kwargs):
super(Downsample, self).__init__()
if isinstance(strides, int):
strides = strides, strides
self.strides = strides
def forward(self... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | kimfunn/spatial-smoothing | Downsample | false | 15,841 | [
"Apache-2.0"
] | 438 | 4f849d57c66c2dbdfaa56fc28727e95eddfd337c | https://github.com/kimfunn/spatial-smoothing/tree/4f849d57c66c2dbdfaa56fc28727e95eddfd337c | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, strides=(2, 2), **kwargs):
super().__init__()
if isinstance(strides, int):
strides = strides, strides
self.strides = strides
def forward(self, x):
shape =... |
SoftDiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class SoftDiceLoss(nn.Module):
def __init__(self, weight=None, size_average=True):
super(SoftDiceLoss, self).__init__()
def forward(self, logits, targets):
smooth = 1.0
logits = F.sigmoid(logits)
iflat = logit... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | kryptonite0/Global_Convolutional_Network | SoftDiceLoss | false | 15,842 | [
"MIT"
] | 88 | 33de71bbe468f485eb38345f4982923945d1a0be | https://github.com/kryptonite0/Global_Convolutional_Network/tree/33de71bbe468f485eb38345f4982923945d1a0be | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, weight=None, size_average=True):
super().__init__()
def forward(self, logits, targets):
smooth = 1.0
logits = F.sigmoid(logits)
iflat = logits.view(-1)
tflat ... |
Swish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
def swish(tensor: 'torch.Tensor', beta: 'float'=1.0) ->torch.Tensor:
"""
Applies Swish function element-wise.
See :class:`torchlayers.activations.Swish` for more details.
Arguments:
tensor :
Tensor activated element-wise
beta :
Multiplier used for... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | klaudiapalasz/torchlayers | Swish | false | 15,843 | [
"MIT"
] | 573 | e6edd8797875325b7c0539d75a12f0d51f494127 | https://github.com/klaudiapalasz/torchlayers/tree/e6edd8797875325b7c0539d75a12f0d51f494127 | import torch
def swish(tensor: 'torch.Tensor', beta: 'float'=1.0) ->torch.Tensor:
"""
Applies Swish function element-wise.
See :class:`torchlayers.activations.Swish` for more details.
Arguments:
tensor :
Tensor activated element-wise
beta :
Multiplier used for... |
ContextualCell | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
def conv_bn_relu(C_in, C_out, kernel_size, stride, padding, affine=True):
return nn.Sequential(nn.Conv2d(C_in, C_out, kernel_size, stride=stride,
padding=padding, bias=False), nn.BatchNorm2d(C_out, affine=affine),
nn.R... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | DrSleep/nas-segm-pytorch | ContextualCell | false | 15,844 | [
"BSD-2-Clause"
] | 155 | 5de0c5c60cc05f94305ff59ae9f822656e3e7a96 | https://github.com/DrSleep/nas-segm-pytorch/tree/5de0c5c60cc05f94305ff59ae9f822656e3e7a96 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
def conv_bn_relu(C_in, C_out, kernel_size, stride, padding, affine=True):
return nn.Sequential(nn.Conv2d(C_in, C_out, kernel_size, stride=stride,
padding=padding, bias=False), nn.BatchNorm2d(C_out, affine=affine),
nn.R... |
DeepSet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class DeepSet(nn.Module):
"""Aggregate object-level embeddings with a mean reduction.
This module evaluates each object individually (using a object level
embedding) and then aggregates the embeddings with a mean reduction.
Parameters
----------
n_features ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | kiudee/cs-ranking | DeepSet | false | 15,845 | [
"Apache-2.0"
] | 65 | 47cf648fa286c37b9214bbad1926004d4d7d9796 | https://github.com/kiudee/cs-ranking/tree/47cf648fa286c37b9214bbad1926004d4d7d9796 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Aggregate object-level embeddings with a mean reduction.
This module evaluates each object individually (using a object level
embedding) and then aggregates the embeddings with a mean reduction.
Parameters
----------
n_features : ... |
ConvertFloatToUint8 | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torchvision
import torch.utils.data
import torchvision.transforms
import torch.nn
class ConvertFloatToUint8(torch.nn.Module):
"""
Converts a video from dtype float32 to dtype uint8.
"""
def __init__(self):
super().__init__()
self.convert_func = torchvision.transfor... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torchvision
import torch.utils.data
import torchvision.transforms
import torch.nn
assert_size_stride = torch._C._dynamo.guards.assert... | kevinmtian/pytorchvideo | ConvertFloatToUint8 | false | 15,846 | [
"Apache-2.0"
] | 2,391 | 168e16859a6029ef8ebeb476f9163bebb6c6b87d | https://github.com/kevinmtian/pytorchvideo/tree/168e16859a6029ef8ebeb476f9163bebb6c6b87d | import torch
import torchvision
import torch.utils.data
import torchvision.transforms
import torch.nn
class Model(torch.nn.Module):
"""
Converts a video from dtype float32 to dtype uint8.
"""
def __init__(self):
super().__init__()
self.convert_func = torchvision.transforms.ConvertImag... |
NormSoftmaxLoss | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
from torch.nn import Parameter
class NormSoftmaxLoss(nn.Module):
"""
L2 normalize weights and apply temperature scaling on logits.
"""
def __init__(self, dim, num_instances, temperature=0.05):
super(NormSoftmaxLoss, self).__init__()
self.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kikaitech/classification_metric_learning | NormSoftmaxLoss | false | 15,847 | [
"Apache-2.0"
] | 93 | 6c90cecf8be01eda6efb7f6aa4049d8449ca33f1 | https://github.com/kikaitech/classification_metric_learning/tree/6c90cecf8be01eda6efb7f6aa4049d8449ca33f1 | import math
import torch
import torch.nn as nn
from torch.nn import Parameter
class Model(nn.Module):
"""
L2 normalize weights and apply temperature scaling on logits.
"""
def __init__(self, dim, num_instances, temperature=0.05):
super().__init__()
self.weight = Parameter(torch.Tensor... |
Recon_Block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class Recon_Block(nn.Module):
def __init__(self, num_chans=64):
super(Recon_Block, self).__init__()
bias = True
self.conv1 = nn.Conv2d(num_chans, num_chans, kernel_size=3, stride=
1, padding=1, bias=bias)
self.relu2 = nn.PReLU()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | khammernik/sigmanet | Recon_Block | false | 15,848 | [
"MIT"
] | 50 | 6eb8dbd1ee350bb9baee60eb254080f7d660bbc5 | https://github.com/khammernik/sigmanet/tree/6eb8dbd1ee350bb9baee60eb254080f7d660bbc5 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, num_chans=64):
super().__init__()
bias = True
self.conv1 = nn.Conv2d(num_chans, num_chans, kernel_size=3, stride=
1, padding=1, bias=bias)
self.relu2 = nn.PReLU()
self.conv3 = nn.Conv2... |
GaussianLayer | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class GaussianLayer(nn.Module):
def __init__(self, std, device):
super().__init__()
self.std = std
self.device = device
def forward(self, x):
return x + self.std * torch.randn_like(x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]... | import torch
from torch import device
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@triton.jit
def triton_poi_... | krylea/mine-pytorch | GaussianLayer | false | 15,849 | [
"MIT"
] | 108 | a638ca3e46ff21a3b9dfebe25480eaed0e3304bc | https://github.com/krylea/mine-pytorch/tree/a638ca3e46ff21a3b9dfebe25480eaed0e3304bc | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, std, device):
super().__init__()
self.std = std
self.device = device
def forward(self, x):
return x + self.std * torch.randn_like(x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def g... |
Expansion2D | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class Expansion2D(torch.nn.Module):
"""
Expands a tensor in the last two dimensions, effectively to a coarse grid
of smaller grids.
"""
def __init__(self, expsize1: 'int', expsize2: 'int'):
"""
:param expsize1: size of the second last dimension to be created
:... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | kpoeppel/pytorch_probgraph | Expansion2D | false | 15,850 | [
"BSD-3-Clause"
] | 47 | b78595ab03bbe92595ad2f6b35f5dd8bf84d6da0 | https://github.com/kpoeppel/pytorch_probgraph/tree/b78595ab03bbe92595ad2f6b35f5dd8bf84d6da0 | import torch
class Model(torch.nn.Module):
"""
Expands a tensor in the last two dimensions, effectively to a coarse grid
of smaller grids.
"""
def __init__(self, expsize1: 'int', expsize2: 'int'):
"""
:param expsize1: size of the second last dimension to be created
:param ... |
Projection | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import Tuple
class Projection(torch.nn.Module):
"""
| A class for a projection of an input to a different shape effectively mapping from
| [..., inshape[1] .. inshape[-1]] -> [..., outshape[1] .. outshape[-1]]
| only going over the subelements.
| Example input (4,6) to... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from typing import Tuple
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty... | kpoeppel/pytorch_probgraph | Projection | false | 15,851 | [
"BSD-3-Clause"
] | 47 | b78595ab03bbe92595ad2f6b35f5dd8bf84d6da0 | https://github.com/kpoeppel/pytorch_probgraph/tree/b78595ab03bbe92595ad2f6b35f5dd8bf84d6da0 | import torch
from typing import Tuple
class Model(torch.nn.Module):
"""
| A class for a projection of an input to a different shape effectively mapping from
| [..., inshape[1] .. inshape[-1]] -> [..., outshape[1] .. outshape[-1]]
| only going over the subelements.
| Example input (4,6) to (4,5... |
AngleSimpleLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data.distributed
import torch.nn as nn
from torch.nn import Parameter
import torch.nn.functional as F
class AngleSimpleLinear(nn.Module):
"""Computes cos of angles between input vectors and weights vectors"""
def __init__(self, in_fe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kprokofi/ML_Decoder | AngleSimpleLinear | false | 15,852 | [
"MIT"
] | 99 | c01c50e0165e607afbebd8d615708ef9c084dd5b | https://github.com/kprokofi/ML_Decoder/tree/c01c50e0165e607afbebd8d615708ef9c084dd5b | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data.distributed
import torch.nn as nn
from torch.nn import Parameter
import torch.nn.functional as F
class Model(nn.Module):
"""Computes cos of angles between input vectors and weights vectors"""
def __init__(self, in_features, out_... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class MultiHeadAttention(nn.Module):
def __init__(self, num_q_channels: 'int', num_kv_channels: 'int',
num_heads: 'int', dropout: 'float'):
super().__init__()
self.attention = nn.MultiheadAttention(embed_dim=num_q_channels,
num_heads=num_head... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | krasserm/perceiver-io | MultiHeadAttention | false | 15,853 | [
"Apache-2.0"
] | 133 | 16e1029300304b617c0b0ae8eb06129ec103c755 | https://github.com/krasserm/perceiver-io/tree/16e1029300304b617c0b0ae8eb06129ec103c755 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_q_channels: 'int', num_kv_channels: 'int',
num_heads: 'int', dropout: 'float'):
super().__init__()
self.attention = nn.MultiheadAttention(embed_dim=num_q_channels,
num_heads=num_heads, kdim=num_k... |
SoftInvDiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class SoftInvDiceLoss(nn.Module):
def __init__(self, weight=None, size_average=True):
super(SoftInvDiceLoss, self).__init__()
def forward(self, logits, targets):
smooth = 1.0
logits = F.sigmoid(logits)
iflat =... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | kryptonite0/Global_Convolutional_Network | SoftInvDiceLoss | false | 15,854 | [
"MIT"
] | 88 | 33de71bbe468f485eb38345f4982923945d1a0be | https://github.com/kryptonite0/Global_Convolutional_Network/tree/33de71bbe468f485eb38345f4982923945d1a0be | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, weight=None, size_average=True):
super().__init__()
def forward(self, logits, targets):
smooth = 1.0
logits = F.sigmoid(logits)
iflat = 1 - logits.view(-1)
tf... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class MultiHeadAttention(nn.Module):
def __init__(self, num_q_channels: 'int', num_kv_channels: 'int',
num_heads: 'int', dropout: 'float'):
super().__init__()
self.attention = nn.MultiheadAttention(embed_dim=num_q_channels,
num_heads=num_head... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | krasserm/perceiver-io | SelfAttention | false | 15,855 | [
"Apache-2.0"
] | 133 | 16e1029300304b617c0b0ae8eb06129ec103c755 | https://github.com/krasserm/perceiver-io/tree/16e1029300304b617c0b0ae8eb06129ec103c755 | import torch
import torch.nn as nn
class MultiHeadAttention(nn.Module):
def __init__(self, num_q_channels: 'int', num_kv_channels: 'int',
num_heads: 'int', dropout: 'float'):
super().__init__()
self.attention = nn.MultiheadAttention(embed_dim=num_q_channels,
num_heads=num_head... |
TransitionUp | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.onnx
import torch.nn.functional as F
import torch.utils.data
class TransitionUp(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
def forward(self, x, skip, concat=True):
out = F.interpolate(x, size=(skip.size(2), ski... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
import torch.onnx
import torch.utils.data
assert_size_stride = torch... | kuanhungchen/CenterNet-HarDNet | TransitionUp | false | 15,856 | [
"MIT"
] | 164 | 050d55a532706d989105982c5bc10f1c89edc8d2 | https://github.com/kuanhungchen/CenterNet-HarDNet/tree/050d55a532706d989105982c5bc10f1c89edc8d2 | import torch
from torch import nn
import torch.onnx
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
def forward(self, x, skip, concat=True):
out = F.interpolate(x, size=(skip.size(2), skip.size(... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.