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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
SaAdaIN | # 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.optim
import torch.utils.data
def calc_mean_std(feat, eps=1e-05):
size = feat.size()
assert len(size) == 4
N, C = size[:2]
feat_var = feat.view(N, C, -1).var(dim=2) + eps
feat_std = feat_var.sqrt().view(N, C, 1, 1)
feat_mean = feat.view(N, C, -1)... | 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.optim
import torch.utils.data
assert_size_st... | VITA-Group/Sandwich-Batch-Normalization | SaAdaIN | false | 14,541 | [
"MIT"
] | 46 | 25e7df6e64a67cebd7e70b911f874cfc1bd19df0 | https://github.com/VITA-Group/Sandwich-Batch-Normalization/tree/25e7df6e64a67cebd7e70b911f874cfc1bd19df0 | import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
def calc_mean_std(feat, eps=1e-05):
size = feat.size()
assert len(size) == 4
N, C = size[:2]
feat_var = feat.view(N, C, -1).var(dim=2) + eps
feat_std = feat_var.sqrt().view(N, C, 1, 1)
feat_mean = feat.view(N, C, -1)... |
DenoisingNet | # 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 DenoisingNet(nn.Module):
def __init__(self, input_vec_size):
super(DenoisingNet, self).__init__()
self.linear_layer = nn.Linear(input_vec_size, 1)
self.elu_layer = nn.ELU()
self.propensity_net = nn.Sequential(self.linear_layer, self.elu_lay... | 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 ... | ULTR-Community/ULTRA_Pytorch | DenoisingNet | false | 14,542 | [
"Apache-2.0"
] | 46 | ec4fe329e4239b588a940cb4bcdd6a321aade679 | https://github.com/ULTR-Community/ULTRA_Pytorch/tree/ec4fe329e4239b588a940cb4bcdd6a321aade679 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_vec_size):
super().__init__()
self.linear_layer = nn.Linear(input_vec_size, 1)
self.elu_layer = nn.ELU()
self.propensity_net = nn.Sequential(self.linear_layer, self.elu_layer)
self.list_siz... |
AdaptiveConcatPool2d | # 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 AdaptiveConcatPool2d(nn.Module):
"""
Pools with AdaptiveMaxPool2d AND AdaptiveAvgPool2d and concatenates both
results.
Args:
target_size: the target output size (single integer or
double-integer tuple)
"""
def __init__(self, target... | 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... | Vermeille/Torchelie | AdaptiveConcatPool2d | false | 14,543 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Pools with AdaptiveMaxPool2d AND AdaptiveAvgPool2d and concatenates both
results.
Args:
target_size: the target output size (single integer or
double-integer tuple)
"""
def __init__(self, target_size):
... |
MLP_CIFAR10 | # 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 MLP_CIFAR10(nn.Module):
def __init__(self, save_features=None, bench_model=False):
super(MLP_CIFAR10, self).__init__()
self.fc1 = nn.Linear(3 * 32 * 32, 1024)
self.fc2 = nn.Linear(1024, 512)
self.fc3 = nn.Lin... | 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.... | VITA-Group/SViTE | MLP_CIFAR10 | false | 14,544 | [
"MIT"
] | 50 | b0c62fd153c8b0b99917ab935ee76925c9de1149 | https://github.com/VITA-Group/SViTE/tree/b0c62fd153c8b0b99917ab935ee76925c9de1149 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, save_features=None, bench_model=False):
super().__init__()
self.fc1 = nn.Linear(3 * 32 * 32, 1024)
self.fc2 = nn.Linear(1024, 512)
self.fc3 = nn.Linear(512, 10)
def f... |
OrthoLoss | # 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
def ortho(w: 'torch.Tensor') ->torch.Tensor:
"""
Returns the orthogonal loss for weight matrix `m`, from Big GAN.
https://arxiv.org/abs/1809.11096
:math:`R_{\\beta}(W)= ||W^T W \\odot (1 - I)||_F^2`
"""
cosine = torch.einsum('ij,ji->ij', w, w)
no_diag ... | 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... | Vermeille/Torchelie | OrthoLoss | false | 14,545 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
import torch.nn as nn
def ortho(w: 'torch.Tensor') ->torch.Tensor:
"""
Returns the orthogonal loss for weight matrix `m`, from Big GAN.
https://arxiv.org/abs/1809.11096
:math:`R_{\\beta}(W)= ||W^T W \\odot (1 - I)||_F^2`
"""
cosine = torch.einsum('ij,ji->ij', w, w)
no_diag ... |
Model | # 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 Model(nn.Module):
def __init__(self, n_input_features):
super(Model, self).__init__()
self.linear = nn.Linear(n_input_features, 1)
def forward(self, x):
y_pred = torch.sigmoid(self.linear(x))
return y_pred
def get_inputs():
retur... | 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... | ValerioMessina/Logistic-Regression | Model | false | 14,546 | [
"MIT"
] | 832 | 7cd3223b5ddfc228f9eae1adabaa5de5fa8f26e9 | https://github.com/ValerioMessina/Logistic-Regression/tree/7cd3223b5ddfc228f9eae1adabaa5de5fa8f26e9 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_input_features):
super(Model, self).__init__()
self.linear = nn.Linear(n_input_features, 1)
def forward(self, x):
y_pred = torch.sigmoid(self.linear(x))
return y_pred
def get_inputs():
retur... |
RoundSTE | # 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 RoundSTE(nn.Module):
def __init__(self):
"""
This module perform element-wise rounding with straight through estimator (STE).
"""
super(RoundSTE, self).__init__()
def forward(self, x):
"""
The forward function of the rou... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | UniSerj/ai-research | RoundSTE | false | 14,547 | [
"Apache-2.0"
] | 46 | 79f0093c93408cc5dd7d3f56aafd7dc1f901421c | https://github.com/UniSerj/ai-research/tree/79f0093c93408cc5dd7d3f56aafd7dc1f901421c | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
"""
This module perform element-wise rounding with straight through estimator (STE).
"""
super().__init__()
def forward(self, x):
"""
The forward function of the rounding module
... |
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
import torch.nn as nn
class HardSigmoid(nn.Module):
"""
Hard Sigmoid
"""
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
return x.add_(0.5).clamp_(min=0, max=1)
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._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@... | Vermeille/Torchelie | HardSigmoid | false | 14,548 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Hard Sigmoid
"""
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
return x.add_(0.5).clamp_(min=0, max=1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
StyledConv | # 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 torch.autograd import Function
import math
import torch
from torch import nn
import torch.nn.functional as F
def make_kernel(k):
k = torch.tensor(k, dtype=torch.float32)
if k.ndim == 1:
k = k[None, :] * k[:, None]
k /= k.sum()
return k
def upfirdn2d(input, kernel, up=1, down=1, pad=(0, ... | 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.autograd... | Ugness/CIPS_SR | StyledConv | false | 14,549 | [
"MIT"
] | 172 | abce872f5bc1b84afb9634a7dd1991e8c74d7616 | https://github.com/Ugness/CIPS_SR/tree/abce872f5bc1b84afb9634a7dd1991e8c74d7616 | from torch.autograd import Function
import math
import torch
from torch import nn
import torch.nn.functional as F
def make_kernel(k):
k = torch.tensor(k, dtype=torch.float32)
if k.ndim == 1:
k = k[None, :] * k[:, None]
k /= k.sum()
return k
def upfirdn2d(input, kernel, up=1, down=1, pad=(0, ... |
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
from typing import Optional
def focal_loss(input: 'torch.Tensor', target: 'torch.Tensor', gamma:
'float'=0, weight: 'Optional[torch.Tensor]'=None) ->torch.Tensor:
"""
Returns the focal loss between `target` and `input`
:math:`\\text{FL}(p_t)=-(1-p_t)^\\gamma\\log(p_... | 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
... | Vermeille/Torchelie | FocalLoss | false | 14,550 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
import torch.nn as nn
from typing import Optional
def focal_loss(input: 'torch.Tensor', target: 'torch.Tensor', gamma:
'float'=0, weight: 'Optional[torch.Tensor]'=None) ->torch.Tensor:
"""
Returns the focal loss between `target` and `input`
:math:`\\text{FL}(p_t)=-(1-p_t)^\\gamma\\log(p_... |
HardSwish | # 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 HardSwish(nn.Module):
"""
Hard Swish
"""
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
return x.add(0.5).clamp_(min=0, max=1).mul_(x)
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._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | Vermeille/Torchelie | HardSwish | false | 14,551 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Hard Swish
"""
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
return x.add(0.5).clamp_(min=0, max=1).mul_(x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
PixelNorm | # 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 PixelNorm(torch.nn.Module):
"""
PixelNorm from ProgressiveGAN
"""
def forward(self, x):
return x / (x.mean(dim=1, keepdim=True).sqrt() + 1e-08)
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._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | Vermeille/Torchelie | PixelNorm | false | 14,552 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
class Model(torch.nn.Module):
"""
PixelNorm from ProgressiveGAN
"""
def forward(self, x):
return x / (x.mean(dim=1, keepdim=True).sqrt() + 1e-08)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
LeNet_300_100 | # 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 LeNet_300_100(nn.Module):
"""Simple NN with hidden layers [300, 100]
Based on https://github.com/mi-lad/snip/blob/master/train.py
by Milad Alizadeh.
"""
def __init__(self, save_features=None, bench_model=False):
sup... | 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.... | VITA-Group/SViTE | LeNet_300_100 | false | 14,553 | [
"MIT"
] | 50 | b0c62fd153c8b0b99917ab935ee76925c9de1149 | https://github.com/VITA-Group/SViTE/tree/b0c62fd153c8b0b99917ab935ee76925c9de1149 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Simple NN with hidden layers [300, 100]
Based on https://github.com/mi-lad/snip/blob/master/train.py
by Milad Alizadeh.
"""
def __init__(self, save_features=None, bench_model=False):
super().__i... |
RobertaClassificationHead | # 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 as nn
class RobertaClassificationHead(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size * 2, config.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
import torch.nn as ... | AlexShypula/CodeGen | RobertaClassificationHead | false | 14,554 | [
"MIT"
] | 241 | 2e5f8090c4369fd3f0ebec4a867503edc1362d5d | https://github.com/AlexShypula/CodeGen/tree/2e5f8090c4369fd3f0ebec4a867503edc1362d5d | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size * 2, config.hidden_size)
self.dropout =... |
MinibatchStddev | # 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 MinibatchStddev(nn.Module):
"""Minibatch Stddev layer from Progressive GAN"""
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
stddev_map = torch.sqrt(x.var(dim=0) + 1e-08).mean()
stddev = stddev_map.expand(x.shape[0], 1, *x.shape[2:])
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.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | Vermeille/Torchelie | MinibatchStddev | false | 14,555 | [
"MIT"
] | 117 | 43957d83238372ae6436aac90127865c2040b76c | https://github.com/Vermeille/Torchelie/tree/43957d83238372ae6436aac90127865c2040b76c | import torch
import torch.nn as nn
class Model(nn.Module):
"""Minibatch Stddev layer from Progressive GAN"""
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
stddev_map = torch.sqrt(x.var(dim=0) + 1e-08).mean()
stddev = stddev_map.expand(x.shape[0], 1, *x.shape[2:])
return torch.c... |
Copy | # 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 Copy(nn.Module):
def __init__(self, hidden_size, copy_weight=1.0):
super().__init__()
self.Wcopy = nn.Linear(hidden_size, hidden_size)
self.copy_weight = copy_weight
def forward(self, enc_out_hs, dec_hs):
"""
get unnormalized 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.triton_helpers import libdevice
import torch.nn as ... | Verylovenlp/MinTL-SKKU | Copy | false | 14,556 | [
"MIT"
] | 60 | 15b5cb870c7d6dcd0f5d895aac2806539cc5101f | https://github.com/Verylovenlp/MinTL-SKKU/tree/15b5cb870c7d6dcd0f5d895aac2806539cc5101f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size, copy_weight=1.0):
super().__init__()
self.Wcopy = nn.Linear(hidden_size, hidden_size)
self.copy_weight = copy_weight
def forward(self, enc_out_hs, dec_hs):
"""
get unnormalized ... |
ChannelPool | # 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 ChannelPool(nn.Module):
def forward(self, x):
return torch.mean(x, 1).unsqueeze(1)
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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | VictorSuciu/ICCV2019_MirrorNet | ChannelPool | false | 14,557 | [
"BSD-3-Clause"
] | 48 | e7ce3c269feaf33a0b156091beebbaebdabf6155 | https://github.com/VictorSuciu/ICCV2019_MirrorNet/tree/e7ce3c269feaf33a0b156091beebbaebdabf6155 | import torch
from torch import nn
class Model(nn.Module):
def forward(self, x):
return torch.mean(x, 1).unsqueeze(1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
FFN | # 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 torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class FFN(nn.Module):
def __init__(self, d_model, d_ffn, dropout=0):
super().__init__()
self.linear1 = nn.Linear(d_model, d_ffn)
self.activation = F.rel... | 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.... | Tarandro/MOTR | FFN | false | 14,558 | [
"MIT"
] | 191 | f2bcc2df0b3bd959208e78c54a3e9d8a3434f9f4 | https://github.com/Tarandro/MOTR/tree/f2bcc2df0b3bd959208e78c54a3e9d8a3434f9f4 | import torch
import torch.utils.data
import torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_model, d_ffn, dropout=0):
super().__init__()
self.linear1 = nn.Linear(d_model, d_ffn)
self.activation = F.r... |
MaskUpdate | # 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 MaskUpdate(nn.Module):
def __init__(self, alpha):
super(MaskUpdate, self).__init__()
self.updateFunc = nn.ReLU(True)
self.alpha = alpha
def forward(self, inputMaskMap):
""" self.alpha.data = torch.clamp(self.alpha.data, 0.6, 0.8)
... | 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... | Vious/LBAM_Pytorch | MaskUpdate | false | 14,559 | [
"MIT"
] | 112 | b9292440e7a7559c027f48d6fd061dcabc41a6bf | https://github.com/Vious/LBAM_Pytorch/tree/b9292440e7a7559c027f48d6fd061dcabc41a6bf | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, alpha):
super().__init__()
self.updateFunc = nn.ReLU(True)
self.alpha = alpha
def forward(self, inputMaskMap):
""" self.alpha.data = torch.clamp(self.alpha.data, 0.6, 0.8)
print(self.alpha) ... |
PONO | # 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
def pono(x, epsilon=1e-05):
"""Positional normalization"""
mean = x.mean(dim=1, keepdim=True)
std = x.var(dim=1, keepdim=True).add(epsilon).sqrt()
output = (x - mean) / std
return output, mean, std
class PONO(nn.Module):
def forward(self, x, mask=None):
... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_... | Warvito/lmconv | PONO | false | 14,560 | [
"MIT"
] | 69 | 01adba51e3fff1e7da99324dc64a9fc9cd38621e | https://github.com/Warvito/lmconv/tree/01adba51e3fff1e7da99324dc64a9fc9cd38621e | import torch
import torch.nn as nn
def pono(x, epsilon=1e-05):
"""Positional normalization"""
mean = x.mean(dim=1, keepdim=True)
std = x.var(dim=1, keepdim=True).add(epsilon).sqrt()
output = (x - mean) / std
return output, mean, std
class Model(nn.Module):
def forward(self, x, mask=None):
... |
CORblock_Z | # 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.model_zoo
class Identity(nn.Module):
"""
Helper module that stores the current tensor. Useful for accessing by name
"""
def forward(self, x):
return x
class CORblock_Z(nn.Module):
def __init__(self, in_channels, out_channels, 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
import torch.nn as nn
import ... | ViCCo-Group/THINGSvision | CORblock_Z | false | 14,561 | [
"MIT"
] | 45 | 27273564631605639287f9b3bd3c57ba8cdb720f | https://github.com/ViCCo-Group/THINGSvision/tree/27273564631605639287f9b3bd3c57ba8cdb720f | import torch
import torch.nn as nn
import torch.utils.model_zoo
class Identity(nn.Module):
"""
Helper module that stores the current tensor. Useful for accessing by name
"""
def forward(self, x):
return x
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size... |
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 Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features o... | 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.... | Vegetebird/MHFormer | Block | false | 14,562 | [
"MIT"
] | 83 | 68d793414e13c256249431a45ac49949930c8e7f | https://github.com/Vegetebird/MHFormer/tree/68d793414e13c256249431a45ac49949930c8e7f | import torch
import torch.nn as nn
import torch.utils.data
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features o... |
SymLinear | # 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.utils.data
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import torch.nn.init as init
class SymLinear(nn.Module):
"""Linear with symmetric weight matrices"""
def __init__(self, in_features, out_features, bias=True):
... | 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.utils.data
import torch.nn as nn
from torch.nn.paramete... | Waasem/graph2nn | SymLinear | false | 14,563 | [
"MIT"
] | 133 | b112eb6c6805a1813e433442b0b1f5cabb4ad1a2 | https://github.com/Waasem/graph2nn/tree/b112eb6c6805a1813e433442b0b1f5cabb4ad1a2 | import math
import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import torch.nn.init as init
class Model(nn.Module):
"""Linear with symmetric weight matrices"""
def __init__(self, in_features, out_features, bias=True):
su... |
PositionwiseFeedForward | # 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 PositionwiseFeedForward(nn.Module):
"""Implements FFN equation."""
def __init__(self, d_model, d_ff, dropout=0.1):
super(PositionwiseFeedForward, self).__init__()
self.w_1 = nn.Linear(d_model, d_ff)
self.w_2 = nn... | 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... | WangYueFt/prnet | PositionwiseFeedForward | false | 14,564 | [
"MIT"
] | 105 | ffceaf1a891286f5ac8a452fca737dd3c44202fd | https://github.com/WangYueFt/prnet/tree/ffceaf1a891286f5ac8a452fca737dd3c44202fd | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Implements FFN equation."""
def __init__(self, d_model, d_ff, dropout=0.1):
super().__init__()
self.w_1 = nn.Linear(d_model, d_ff)
self.w_2 = nn.Linear(d_ff, d_model)
self.dropout = n... |
BilinearUpsample | # 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 Union
from typing import List
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class BilinearUpsample(nn.Module):
"""
Overview:
Upsamples the input to the given member varible scale_factor using mode biliner
Interface:
forward
... | 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 typing import Union
from typing import List
import torch.nn as nn
import torch.utils... | Weiyuhong-1998/DI-engine | BilinearUpsample | false | 14,565 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
from typing import Union
from typing import List
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
"""
Overview:
Upsamples the input to the given member varible scale_factor using mode biliner
Interface:
forward
"""
... |
Attn | # 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 Attn(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.hidden_size = hidden_size
self.attn = nn.Linear(self.hidden_size * 2, hidden_size)
self.v = nn.Linear(hidden_size, 1, bias=False)
... | 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.... | Verylovenlp/MinTL-SKKU | Attn | false | 14,566 | [
"MIT"
] | 60 | 15b5cb870c7d6dcd0f5d895aac2806539cc5101f | https://github.com/Verylovenlp/MinTL-SKKU/tree/15b5cb870c7d6dcd0f5d895aac2806539cc5101f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.hidden_size = hidden_size
self.attn = nn.Linear(self.hidden_size * 2, hidden_size)
self.v = nn.Linear(hidden_size, 1, bias=False)
... |
FRN | # 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 FRN(nn.Module):
def __init__(self, num_features, eps=1e-06):
super(FRN, self).__init__()
self.eps = eps
self.gamma = nn.Parameter(torch.ones(1, num_features, 1, 1))
self.beta = nn.Parameter(torch.zeros(1, num_features, 1, 1))
self.t ... | 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
from torch import nn
assert_... | WangGodder/deep-cross-modal-hashing | FRN | false | 14,567 | [
"MIT"
] | 65 | 9784397c1076c81b43ebd856cb24b8a67cf8f41e | https://github.com/WangGodder/deep-cross-modal-hashing/tree/9784397c1076c81b43ebd856cb24b8a67cf8f41e | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, num_features, eps=1e-06):
super().__init__()
self.eps = eps
self.gamma = nn.Parameter(torch.ones(1, num_features, 1, 1))
self.beta = nn.Parameter(torch.zeros(1, num_features, 1, 1))
self.t = nn.Pa... |
RobertaClassificationHead | # 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 as nn
class RobertaClassificationHead(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config):
super(RobertaClassificationHead, self).__init__()
self.dense = nn.Linear(config.hidden_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
import torch.nn as ... | AkariAsai/logic_guided_qa | RobertaClassificationHead | false | 14,568 | [
"MIT"
] | 69 | 96ae70f01b7267ef0b472b8497c903035d052fd9 | https://github.com/AkariAsai/logic_guided_qa/tree/96ae70f01b7267ef0b472b8497c903035d052fd9 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.dropout = nn.... |
LabelSmoothCELoss | # 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.utils.data
def one_hot(val: 'torch.LongTensor', num: 'int', num_first: 'bool'=False
) ->torch.FloatTensor:
"""
Overview:
Convert a ``torch.LongTensor`` to one hot encoding.
This implementation can be slightly f... | 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
... | Weiyuhong-1998/DI-engine | LabelSmoothCELoss | false | 14,569 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def one_hot(val: 'torch.LongTensor', num: 'int', num_first: 'bool'=False
) ->torch.FloatTensor:
"""
Overview:
Convert a ``torch.LongTensor`` to one hot encoding.
This implementation can be slightly f... |
nin | # 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.utils import weight_norm as wn
class nin(nn.Module):
def __init__(self, dim_in, dim_out, weight_norm=True):
super(nin, self).__init__()
if weight_norm:
self.lin_a = wn(nn.Linear(dim_in, dim_out))
else:
self.lin_a = n... | 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 ... | Warvito/lmconv | nin | false | 14,570 | [
"MIT"
] | 69 | 01adba51e3fff1e7da99324dc64a9fc9cd38621e | https://github.com/Warvito/lmconv/tree/01adba51e3fff1e7da99324dc64a9fc9cd38621e | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm as wn
class Model(nn.Module):
def __init__(self, dim_in, dim_out, weight_norm=True):
super().__init__()
if weight_norm:
self.lin_a = wn(nn.Linear(dim_in, dim_out))
else:
self.lin_a = nn.Linea... |
Encoder | # 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 Conv(nn.Module):
def __init__(self, filters0, filters1, kernel_size, bn, bias=True):
super().__init__()
if bn:
bias = False
self.conv = nn.Conv2d(filters0, filters1, kernel_size, stride=1,
padding=ker... | 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... | Weiyuhong-1998/DI-engine | Encoder | false | 14,571 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Conv(nn.Module):
def __init__(self, filters0, filters1, kernel_size, bn, bias=True):
super().__init__()
if bn:
bias = False
self.conv = nn.Conv2d(filters0, filters1, kernel_size, stride=1,
padding=ker... |
GaussActivation | # 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.parameter import Parameter
class GaussActivation(nn.Module):
def __init__(self, a, mu, sigma1, sigma2):
super(GaussActivation, self).__init__()
self.a = Parameter(torch.tensor(a, dtype=torch.float32))
self.mu = Parameter(torch.tensor(mu, dt... | 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
... | Vious/LBAM_Pytorch | GaussActivation | false | 14,572 | [
"MIT"
] | 112 | b9292440e7a7559c027f48d6fd061dcabc41a6bf | https://github.com/Vious/LBAM_Pytorch/tree/b9292440e7a7559c027f48d6fd061dcabc41a6bf | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, a, mu, sigma1, sigma2):
super().__init__()
self.a = Parameter(torch.tensor(a, dtype=torch.float32))
self.mu = Parameter(torch.tensor(mu, dtype=torch.float32))
sel... |
ResidualBlock | # 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 ResidualBlock(nn.Module):
def __init__(self, in_channels, out_channels, activation='relu'):
super().__init__()
self.in_channels, self.out_channels, self.activation = (in_channels,
out_channels, activation)
self.b... | 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
assert_size_stride = torch._C._dynamo.guard... | Weiyuhong-1998/DI-engine | ResidualBlock | false | 14,573 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_channels, out_channels, activation='relu'):
super().__init__()
self.in_channels, self.out_channels, self.activation = (in_channels,
out_channels, activation)
self.blocks = ... |
EnsembleFC | # 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 EnsembleFC(nn.Module):
__constants__ = ['in_features', 'out_features']
in_features: 'int'
out_features: 'int'
ensemble_size: 'int'
weight: 'torch.Tensor'
def __init__(self, in_features: 'int', out_features: 'int',
ensemb... | 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... | Weiyuhong-1998/DI-engine | EnsembleFC | false | 14,574 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
__constants__ = ['in_features', 'out_features']
in_features: 'int'
out_features: 'int'
ensemble_size: 'int'
weight: 'torch.Tensor'
def __init__(self, in_features: 'int', out_features: 'int',
ensemble_si... |
GLU | # 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 GLU(nn.Module):
"""
Overview:
Gating Linear Unit.
This class does a thing like this:
.. code:: python
# Inputs: input, context, output_size
# The gate value is a learnt function of the input.
... | 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... | Weiyuhong-1998/DI-engine | GLU | false | 14,575 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
Overview:
Gating Linear Unit.
This class does a thing like this:
.. code:: python
# Inputs: input, context, output_size
# The gate value is a learnt function of the input.
... |
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
from torch import nn
from torch.nn import functional as F
class HardSigmoid(nn.Module):
def __init__(self, slope=0.2, offset=0.5):
super().__init__()
self.slope = slope
self.offset = offset
def forward(self, x):
x = self.slope * x + self.offset
x = F.thre... | 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... | WenmuZhou/crnn.pytorch | HardSigmoid | false | 14,576 | [
"Apache-2.0"
] | 46 | bf7a7c62376eee93943ca7c68e88e3d563c09aa8 | https://github.com/WenmuZhou/crnn.pytorch/tree/bf7a7c62376eee93943ca7c68e88e3d563c09aa8 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, slope=0.2, offset=0.5):
super().__init__()
self.slope = slope
self.offset = offset
def forward(self, x):
x = self.slope * x + self.offset
x = F.threshold(... |
Head | # 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 Conv(nn.Module):
def __init__(self, filters0, filters1, kernel_size, bn, bias=True):
super().__init__()
if bn:
bias = False
self.conv = nn.Conv2d(filters0, filters1, kernel_size, stride=1,
padding=ker... | 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... | Weiyuhong-1998/DI-engine | Head | false | 14,577 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Conv(nn.Module):
def __init__(self, filters0, filters1, kernel_size, bn, bias=True):
super().__init__()
if bn:
bias = False
self.conv = nn.Conv2d(filters0, filters1, kernel_size, stride=1,
padding=ker... |
RewardModelNetwork | # 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 RewardModelNetwork(nn.Module):
def __init__(self, input_size: 'int', hidden_size: 'int', output_size:
'int') ->None:
super(RewardModelNetwork, self).__init__()
self.l1 = nn.Linear(input_size, hidden_size)
self.l2 = n... | 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 ... | Weiyuhong-1998/DI-engine | RewardModelNetwork | false | 14,578 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, input_size: 'int', hidden_size: 'int', output_size:
'int') ->None:
super().__init__()
self.l1 = nn.Linear(input_size, hidden_size)
self.l2 = nn.Linear(hidden_size, output_size)
... |
SENet | # 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 SENet(nn.Module):
"""support estimation network"""
def __init__(self, input_size: 'int', hidden_size: 'int', output_dims:
'int') ->None:
super(SENet, self).__init__()
self.l_1 = nn.Linear(input_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
import torch.nn as ... | Weiyuhong-1998/DI-engine | SENet | false | 14,579 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""support estimation network"""
def __init__(self, input_size: 'int', hidden_size: 'int', output_dims:
'int') ->None:
super().__init__()
self.l_1 = nn.Linear(input_size, hidden_size)
self.l_2 =... |
ATOCAttentionUnit | # 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 typing import Union
import torch.nn as nn
from typing import Dict
import torch.utils.data
class ATOCAttentionUnit(nn.Module):
"""
Overview:
the attention unit of the atoc network. We now implement it as two-layer MLP, same as the original paper
Interface:
__init__, forwa... | 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 ... | Weiyuhong-1998/DI-engine | ATOCAttentionUnit | false | 14,580 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
from typing import Union
import torch.nn as nn
from typing import Dict
import torch.utils.data
class Model(nn.Module):
"""
Overview:
the attention unit of the atoc network. We now implement it as two-layer MLP, same as the original paper
Interface:
__init__, forward
.. n... |
ReverseMaskConv | # 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.parameter import Parameter
def weights_init(init_type='gaussian'):
def init_fun(m):
classname = m.__class__.__name__
if (classname.find('Conv') == 0 or classname.find('Linear') == 0
) and hasattr(m, 'weight'):
if... | 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.... | Vious/LBAM_Pytorch | ReverseMaskConv | false | 14,581 | [
"MIT"
] | 112 | b9292440e7a7559c027f48d6fd061dcabc41a6bf | https://github.com/Vious/LBAM_Pytorch/tree/b9292440e7a7559c027f48d6fd061dcabc41a6bf | import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
def weights_init(init_type='gaussian'):
def init_fun(m):
classname = m.__class__.__name__
if (classname.find('Conv') == 0 or classname.find('Linear') == 0
) and hasattr(m, 'weight'):
if... |
AvgPool2dSame | # 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 numpy as np
from typing import List
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def get_same_padding(x: 'int', k: 'int', s: 'int', d: 'int'):
return max((math.ceil(x / s) - 1) * s + (k - 1) * d + 1 - x, 0)
def pad_same(x, k: 'List[int]', s: 'List... | 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 math
import numpy as np
from typing import List
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
assert_... | Weiyuhong-1998/DI-engine | AvgPool2dSame | false | 14,582 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import math
import torch
import numpy as np
from typing import List
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def get_same_padding(x: 'int', k: 'int', s: 'int', d: 'int'):
return max((math.ceil(x / s) - 1) * s + (k - 1) * d + 1 - x, 0)
def pad_same(x, k: 'List[int]', s: 'List... |
ScaledDotProductAttention | # 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.nn as nn
import torch.nn.functional as F
import torch.utils.data
class ScaledDotProductAttention(nn.Module):
"""
Overview:
Implementation of dot product attentionn with scaling.
"""
def __init__(self, d_k: 'int', dropout: 'float'=0.0) ->No... | 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.... | Weiyuhong-1998/DI-engine | ScaledDotProductAttention | false | 14,583 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
"""
Overview:
Implementation of dot product attentionn with scaling.
"""
def __init__(self, d_k: 'int', dropout: 'float'=0.0) ->None:
super().... |
BertIntermediate | # 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
import torch.nn as nn
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT's gelu is slightly different (and gives slightly different results):
0.5 * x * (1 + torch.tanh(math.sqrt(2 / math... | 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
import ... | VinodS7/sota-music-tagging-models | BertIntermediate | false | 14,584 | [
"MIT"
] | 199 | 6232abe693ebe6a99ea64a3ea1fe65c34d0a9dd0 | https://github.com/VinodS7/sota-music-tagging-models/tree/6232abe693ebe6a99ea64a3ea1fe65c34d0a9dd0 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT's gelu is slightly different (and gives slightly different results):
0.5 * x * (1 + torch.tanh(math.sqrt(2 / math... |
SHR_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 Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features o... | 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.... | Vegetebird/MHFormer | SHR_Block | false | 14,585 | [
"MIT"
] | 83 | 68d793414e13c256249431a45ac49949930c8e7f | https://github.com/Vegetebird/MHFormer/tree/68d793414e13c256249431a45ac49949930c8e7f | import torch
import torch.nn as nn
import torch.utils.data
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features o... |
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
import torch.nn.functional as F
import torch.utils.data
class MultiHeadAttention(nn.Module):
def __init__(self, in_dim, out_dim, out_heads, relation_dim=0, residual
=False, projection=True, layer_norm=True):
super().__init__()
self.in_dim = in_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.... | Weiyuhong-1998/DI-engine | MultiHeadAttention | false | 14,586 | [
"Apache-2.0"
] | 464 | 88658ea358298c6e61e95a454284b8853a3e9484 | https://github.com/Weiyuhong-1998/DI-engine/tree/88658ea358298c6e61e95a454284b8853a3e9484 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_dim, out_dim, out_heads, relation_dim=0, residual
=False, projection=True, layer_norm=True):
super().__init__()
self.in_dim = in_dim
self.out_di... |
CNN | # 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 CNN(nn.Module):
def __init__(self, input_size=50, hidden_size=256, dropout=0,
kernel_size=3, padding=1, activation_function=F.relu):
"""
Args:
input_size: dimention of input embedding
kernel_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 import triton_helpers
import torch.nn as nn
import ... | WinterSoHot/OpenNRE | CNN | false | 14,587 | [
"MIT"
] | 3,284 | bc58d8fff2a2f42a5349c184f16ab7a8c50ae32b | https://github.com/WinterSoHot/OpenNRE/tree/bc58d8fff2a2f42a5349c184f16ab7a8c50ae32b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size=50, hidden_size=256, dropout=0,
kernel_size=3, padding=1, activation_function=F.relu):
"""
Args:
input_size: dimention of input embedding
kernel... |
MS_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
from torch.nn.functional import interpolate
class MS_Block(nn.Module):
def __init__(self, in_channel, out_channel, pool_level, txt_length):
super(MS_Block, self).__init__()
self.txt_length = txt_length
pool_kernel = 5 * pool_level, 1
pool_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
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | WangGodder/deep-cross-modal-hashing | MS_Block | false | 14,588 | [
"MIT"
] | 65 | 9784397c1076c81b43ebd856cb24b8a67cf8f41e | https://github.com/WangGodder/deep-cross-modal-hashing/tree/9784397c1076c81b43ebd856cb24b8a67cf8f41e | import torch
from torch import nn
from torch.nn.functional import interpolate
class Model(nn.Module):
def __init__(self, in_channel, out_channel, pool_level, txt_length):
super().__init__()
self.txt_length = txt_length
pool_kernel = 5 * pool_level, 1
pool_stride = 5 * pool_level, ... |
MaxMarginRankingLoss | # 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 MaxMarginRankingLoss(nn.Module):
def __init__(self, margin=1):
super(MaxMarginRankingLoss, self).__init__()
self.margin = margin
def forward(self, x):
n = x.size()[0]
x1 = torch.diag(x)
x1 = x1.u... | 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... | Worm4047/TVR | MaxMarginRankingLoss | false | 14,589 | [
"MIT"
] | 106 | 2a8ce2edbdc0966aef3b84c28872267039f01700 | https://github.com/Worm4047/TVR/tree/2a8ce2edbdc0966aef3b84c28872267039f01700 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, margin=1):
super().__init__()
self.margin = margin
def forward(self, x):
n = x.size()[0]
x1 = torch.diag(x)
x1 = x1.unsqueeze(1)
x1 = x1.expand(n, n)
... |
BertOutput | # 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 as nn
class BertOutput(nn.Module):
def __init__(self, config):
super(BertOutput, self).__init__()
self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
self.LayerNorm = nn.LayerNorm(config.hidden_siz... | 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 ... | Worm4047/TVR | BertOutput | false | 14,590 | [
"MIT"
] | 106 | 2a8ce2edbdc0966aef3b84c28872267039f01700 | https://github.com/Worm4047/TVR/tree/2a8ce2edbdc0966aef3b84c28872267039f01700 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
self.LayerNorm = nn.LayerNorm(config.hidden_size)
self.dropo... |
StdConv2d | # 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 StdConv2d(nn.Conv2d):
def forward(self, x):
w = self.weight
v, m = torch.var_mean(w, dim=[1, 2, 3], keepdim=True, unbiased=False)
w = (w - m) / torch.sqrt(v + 1e-05)
return F.conv2d(x, w, self.bias, self.stri... | 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 ... | Willy0919/progressive-coordinate-transforms | StdConv2d | false | 14,591 | [
"Apache-2.0",
"MIT"
] | 142 | b637fa2541a815d270e162a4c9cd3348b098d48a | https://github.com/Willy0919/progressive-coordinate-transforms/tree/b637fa2541a815d270e162a4c9cd3348b098d48a | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Conv2d):
def forward(self, x):
w = self.weight
v, m = torch.var_mean(w, dim=[1, 2, 3], keepdim=True, unbiased=False)
w = (w - m) / torch.sqrt(v + 1e-05)
return F.conv2d(x, w, self.bias, self.stride, ... |
DWConv | # 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 BasicConv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros',
use_bn=True, use_relu=True, inplace=True):
super().__init__()
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._inductor.runtime import triton_helpers
from torch import nn
assert_s... | WenmuZhou/crnn.pytorch | DWConv | false | 14,592 | [
"Apache-2.0"
] | 46 | bf7a7c62376eee93943ca7c68e88e3d563c09aa8 | https://github.com/WenmuZhou/crnn.pytorch/tree/bf7a7c62376eee93943ca7c68e88e3d563c09aa8 | import torch
from torch import nn
class BasicConv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros',
use_bn=True, use_relu=True, inplace=True):
super().__init__()
self.conv = nn.Conv2d(... |
Gradient_Loss | # 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.utils.data
import torch.nn as nn
class Gradient_Loss(nn.Module):
def __init__(self, losstype='l2'):
super(Gradient_Loss, self).__init__()
a = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])
conv1 = nn.Conv2d(3, 3, kernel_size=3, stride=1, paddin... | 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 math as tl_math
import numpy ... | WestCityInstitute/InvDN | Gradient_Loss | false | 14,593 | [
"Apache-2.0"
] | 122 | 3846cf3548ccf6690e58be3aafe1f6d98c56b90d | https://github.com/WestCityInstitute/InvDN/tree/3846cf3548ccf6690e58be3aafe1f6d98c56b90d | import torch
import numpy as np
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, losstype='l2'):
super().__init__()
a = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])
conv1 = nn.Conv2d(3, 3, kernel_size=3, stride=1, padding=1, bias=
Fals... |
CHI_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 Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features o... | 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.... | Vegetebird/MHFormer | CHI_Block | false | 14,594 | [
"MIT"
] | 83 | 68d793414e13c256249431a45ac49949930c8e7f | https://github.com/Vegetebird/MHFormer/tree/68d793414e13c256249431a45ac49949930c8e7f | import torch
import torch.nn as nn
import torch.utils.data
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features o... |
FeatureResizer | # 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 FeatureResizer(nn.Module):
"""
This class takes as input a set of embeddings of dimension C1 and outputs a set of
embedding of dimension C2, after a linear transformation, dropout and normalization (LN).
"""
def __init__(self, input_feat_size, output_feat_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... | XiaoJake/MTTR | FeatureResizer | false | 14,595 | [
"Apache-2.0"
] | 516 | c383c5b151e3c97aeb45cd2fb4bf08719016498b | https://github.com/XiaoJake/MTTR/tree/c383c5b151e3c97aeb45cd2fb4bf08719016498b | import torch
from torch import nn
class Model(nn.Module):
"""
This class takes as input a set of embeddings of dimension C1 and outputs a set of
embedding of dimension C2, after a linear transformation, dropout and normalization (LN).
"""
def __init__(self, input_feat_size, output_feat_size, drop... |
BertAttention | # 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
import torch.nn as 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.... | Worm4047/TVR | BertAttention | false | 14,596 | [
"MIT"
] | 106 | 2a8ce2edbdc0966aef3b84c28872267039f01700 | https://github.com/Worm4047/TVR/tree/2a8ce2edbdc0966aef3b84c28872267039f01700 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
class BertSelfAttention(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
'The hidden size (... |
multi_head_attention_2d | # 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 multi_head_attention_2d(torch.nn.Module):
def __init__(self, in_channel, key_filters, value_filters,
output_filters, num_heads, dropout_prob=0.5, layer_type='SAME'):
super().__init__()
"""Multihead scaled-dot-product attention with input/output tra... | 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.... | Whu-wxy/Non-local-U-Nets-2D-block | multi_head_attention_2d | false | 14,597 | [
"MIT"
] | 117 | 668d0356b9a276f6cfdc69d669da7d47b260c4c0 | https://github.com/Whu-wxy/Non-local-U-Nets-2D-block/tree/668d0356b9a276f6cfdc69d669da7d47b260c4c0 | import torch
import torch.nn as nn
class Model(torch.nn.Module):
def __init__(self, in_channel, key_filters, value_filters,
output_filters, num_heads, dropout_prob=0.5, layer_type='SAME'):
super().__init__()
"""Multihead scaled-dot-product attention with input/output transformations.
... |
MNIST_CNN | # 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
import torch.utils.data
import torch.optim
class MNIST_CNN(nn.Module):
"""
Hand-tuned architecture for MNIST.
Weirdness I've noticed so far with this architecture:
- adding a linear layer after the mean-pool in features hurts
R... | 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.... | Weixin-Liang/MetaShift | MNIST_CNN | false | 14,598 | [
"MIT"
] | 54 | 84e090a13652437f8f392065f6bebf938e4c7fa3 | https://github.com/Weixin-Liang/MetaShift/tree/84e090a13652437f8f392065f6bebf938e4c7fa3 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
import torch.optim
class Model(nn.Module):
"""
Hand-tuned architecture for MNIST.
Weirdness I've noticed so far with this architecture:
- adding a linear layer after the mean-pool in features hurts
Rotat... |
DCHR | # 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 DCHR(nn.Module):
def __init__(self, stride):
super(DCHR, self).__init__()
self.pool = nn.AvgPool2d(kernel_size=stride)
def forward(self, x):
pool = self.pool(x)
shape = pool.shape
shape = [i for i in shape]
shape[1] = s... | 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... | XiaotaoChen/model-quantization | DCHR | false | 14,599 | [
"BSD-2-Clause"
] | 66 | a745ef691e9329b9c973a2dd795761cd3da8b6ae | https://github.com/XiaotaoChen/model-quantization/tree/a745ef691e9329b9c973a2dd795761cd3da8b6ae | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, stride):
super().__init__()
self.pool = nn.AvgPool2d(kernel_size=stride)
def forward(self, x):
pool = self.pool(x)
shape = pool.shape
shape = [i for i in shape]
shape[1] = shape[1] /... |
ESA | # 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 ESA(nn.Module):
def __init__(self, channel=64, reduction=4, bias=True):
super(ESA, self).__init__()
self.r_nc = channel // reduction
self.conv1 = nn.Conv2d(channel, self.r_nc, kernel_size=1)
self.conv21 = nn.... | 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
assert_... | WestCityInstitute/KAIR | ESA | false | 14,600 | [
"MIT"
] | 1,521 | 3eb3cc7776fa8c57e8ed7c71bfa8039beb4c6677 | https://github.com/WestCityInstitute/KAIR/tree/3eb3cc7776fa8c57e8ed7c71bfa8039beb4c6677 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, channel=64, reduction=4, bias=True):
super().__init__()
self.r_nc = channel // reduction
self.conv1 = nn.Conv2d(channel, self.r_nc, kernel_size=1)
self.conv21 = nn.Conv2d(... |
SEBlock | # 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 HardSigmoid(nn.Module):
def __init__(self, slope=0.2, offset=0.5):
super().__init__()
self.slope = slope
self.offset = offset
def forward(self, x):
x = self.slope * x + self.offset
x = F.thre... | 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
from tor... | WenmuZhou/crnn.pytorch | SEBlock | false | 14,601 | [
"Apache-2.0"
] | 46 | bf7a7c62376eee93943ca7c68e88e3d563c09aa8 | https://github.com/WenmuZhou/crnn.pytorch/tree/bf7a7c62376eee93943ca7c68e88e3d563c09aa8 | import torch
from torch import nn
from torch.nn import functional as F
class HardSigmoid(nn.Module):
def __init__(self, slope=0.2, offset=0.5):
super().__init__()
self.slope = slope
self.offset = offset
def forward(self, x):
x = self.slope * x + self.offset
x = F.thre... |
GlobalAvgPool | # 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 th
from torch import nn
class GlobalAvgPool(nn.Module):
def __init__(self):
super(GlobalAvgPool, self).__init__()
def forward(self, x):
return th.mean(x, dim=[-2, -1])
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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | XudongLinthu/video_feature_extractor | GlobalAvgPool | false | 14,602 | [
"Apache-2.0"
] | 250 | 54bdbeef2e9f4db8d7697b26edef124979625f58 | https://github.com/XudongLinthu/video_feature_extractor/tree/54bdbeef2e9f4db8d7697b26edef124979625f58 | import torch
import torch as th
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return th.mean(x, dim=[-2, -1])
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
UNetSeeInDark | # 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 UNetSeeInDark(nn.Module):
def __init__(self, in_channels=4, out_channels=3):
super(UNetSeeInDark, self).__init__()
self.conv1_1 = nn.Conv2d(in_channels, 32, kernel_size=3, stride=1,
padding=1)
self.conv1_2 = nn.Conv2d(32, 32, kernel_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 import nn
assert_s... | Vandermode/ELD | UNetSeeInDark | false | 14,603 | [
"MIT"
] | 258 | aa0edb44a8fc20e01f83c1f6e93ee70d3190e142 | https://github.com/Vandermode/ELD/tree/aa0edb44a8fc20e01f83c1f6e93ee70d3190e142 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_channels=4, out_channels=3):
super().__init__()
self.conv1_1 = nn.Conv2d(in_channels, 32, kernel_size=3, stride=1,
padding=1)
self.conv1_2 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1)
... |
TrainablePositionalEncoding | # 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 TrainablePositionalEncoding(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings.
"""
def __init__(self, max_position_embeddings, hidden_size, dropout=0.1):
super(TrainablePositionalEncoding, self).__init__()
self.p... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_... | Worm4047/TVR | TrainablePositionalEncoding | false | 14,604 | [
"MIT"
] | 106 | 2a8ce2edbdc0966aef3b84c28872267039f01700 | https://github.com/Worm4047/TVR/tree/2a8ce2edbdc0966aef3b84c28872267039f01700 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings.
"""
def __init__(self, max_position_embeddings, hidden_size, dropout=0.1):
super().__init__()
self.position_embeddings = nn.Embedding(max_position_embeddin... |
EnchanceReLU | # 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
import torch.nn as nn
class EnchanceReLU(nn.ReLU):
def __init__(self, args):
super(EnchanceReLU, self).__init__(inplace=True)
self.shift = getattr(args, 'fm_boundary', 0.25)
def forward(self, x):
x = x + self.shift
x ... | 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... | XiaotaoChen/model-quantization | EnchanceReLU | false | 14,605 | [
"BSD-2-Clause"
] | 66 | a745ef691e9329b9c973a2dd795761cd3da8b6ae | https://github.com/XiaotaoChen/model-quantization/tree/a745ef691e9329b9c973a2dd795761cd3da8b6ae | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.ReLU):
def __init__(self, args):
super().__init__(inplace=True)
self.shift = getattr(args, 'fm_boundary', 0.25)
def forward(self, x):
x = x + self.shift
x = super(EnchanceReLU, sel... |
GeM | # 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 GeM(nn.Module):
def __init__(self, p=3, eps=1e-06):
super(GeM, self).__init__()
self.p = nn.Parameter(torch.ones(1) * p)
self.eps = eps
def forward(self, x):
return nn.functional.avg_pool2d(x.clamp(min=self.eps).pow(self.p),
... | 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... | XiaoJake/MinkLocMultimodal | GeM | false | 14,606 | [
"MIT"
] | 49 | 683ef1aae35ab1b60f13cefccfdd0e3f9cb9ea6e | https://github.com/XiaoJake/MinkLocMultimodal/tree/683ef1aae35ab1b60f13cefccfdd0e3f9cb9ea6e | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, p=3, eps=1e-06):
super().__init__()
self.p = nn.Parameter(torch.ones(1) * p)
self.eps = eps
def forward(self, x):
return nn.functional.avg_pool2d(x.clamp(min=self.eps).pow(self.p),
(x.si... |
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
import torch.nn as 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.... | Worm4047/TVR | BertSelfAttention | false | 14,607 | [
"MIT"
] | 106 | 2a8ce2edbdc0966aef3b84c28872267039f01700 | https://github.com/Worm4047/TVR/tree/2a8ce2edbdc0966aef3b84c28872267039f01700 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as 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... |
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... | import torch
import torch.utils.data
import torch.nn as nn
class ResBlock(nn.Module):
def __init__(self, channel_in, channel_out):
super(ResBlock, self).__init__()
feature = 64
self.conv1 = nn.Conv2d(channel_in, feature, kernel_size=3, padding=1)
self.relu1 = nn.LeakyReLU(negative... | 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... | WestCityInstitute/InvDN | ResBlock | false | 14,608 | [
"Apache-2.0"
] | 122 | 3846cf3548ccf6690e58be3aafe1f6d98c56b90d | https://github.com/WestCityInstitute/InvDN/tree/3846cf3548ccf6690e58be3aafe1f6d98c56b90d | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, channel_in, channel_out):
super().__init__()
feature = 64
self.conv1 = nn.Conv2d(channel_in, feature, kernel_size=3, padding=1)
self.relu1 = nn.LeakyReLU(negative_slope=0.2, inpla... |
GeLU | # 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 GeLU(nn.Module):
def forward(self, x):
return 0.5 * x * (1.0 + torch.tanh(x * 0.7978845608 * (1.0 +
0.044715 * x * x)))
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._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | YJiangcm/Chinese-sentence-pair-modeling | GeLU | false | 14,609 | [
"Apache-2.0"
] | 49 | 90adbc5c121832ce3e4a4057e30417a6ec5e7ebc | https://github.com/YJiangcm/Chinese-sentence-pair-modeling/tree/90adbc5c121832ce3e4a4057e30417a6ec5e7ebc | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, x):
return 0.5 * x * (1.0 + torch.tanh(x * 0.7978845608 * (1.0 +
0.044715 * x * x)))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
PatchMerging | # 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 torchvision.transforms.functional as F
import torch.nn.functional as F
from torch import nn
class PatchMerging(nn.Module):
""" Patch Merging Layer
Args:
dim (int): Number of input channels.
norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
"... | 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... | XiaoJake/MTTR | PatchMerging | false | 14,610 | [
"Apache-2.0"
] | 516 | c383c5b151e3c97aeb45cd2fb4bf08719016498b | https://github.com/XiaoJake/MTTR/tree/c383c5b151e3c97aeb45cd2fb4bf08719016498b | import torch
import torchvision.transforms.functional as F
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
""" Patch Merging Layer
Args:
dim (int): Number of input channels.
norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
"""
... |
NIN2d | # 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 Parameter
def norm(p: 'torch.Tensor', dim: 'int'):
"""Computes the norm over all dimensions except dim"""
if dim is None:
return p.norm()
elif dim == 0:
output_size = (p.size(0),) + (1,) * (p.dim() - 1)
return p.contiguous().v... | 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 ... | XuezheMax/macow | NIN2d | false | 14,611 | [
"Apache-2.0"
] | 60 | 6de247c09b590a037c9eec2d6b1248845f6efb31 | https://github.com/XuezheMax/macow/tree/6de247c09b590a037c9eec2d6b1248845f6efb31 | import torch
import torch.nn as nn
from torch.nn import Parameter
def norm(p: 'torch.Tensor', dim: 'int'):
"""Computes the norm over all dimensions except dim"""
if dim is None:
return p.norm()
elif dim == 0:
output_size = (p.size(0),) + (1,) * (p.dim() - 1)
return p.contiguous().v... |
NIN4d | # 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 Parameter
def norm(p: 'torch.Tensor', dim: 'int'):
"""Computes the norm over all dimensions except dim"""
if dim is None:
return p.norm()
elif dim == 0:
output_size = (p.size(0),) + (1,) * (p.dim() - 1)
return p.contiguous().v... | 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 ... | XuezheMax/macow | NIN4d | false | 14,612 | [
"Apache-2.0"
] | 60 | 6de247c09b590a037c9eec2d6b1248845f6efb31 | https://github.com/XuezheMax/macow/tree/6de247c09b590a037c9eec2d6b1248845f6efb31 | import torch
import torch.nn as nn
from torch.nn import Parameter
def norm(p: 'torch.Tensor', dim: 'int'):
"""Computes the norm over all dimensions except dim"""
if dim is None:
return p.norm()
elif dim == 0:
output_size = (p.size(0),) + (1,) * (p.dim() - 1)
return p.contiguous().v... |
LinearWeightNorm | # 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 LinearWeightNorm(nn.Module):
def __init__(self, in_features, out_features, bias=True):
super(LinearWeightNorm, self).__init__()
self.linear = nn.Linear(in_features, out_features, bias=bias)
self.reset_parameters()
def reset_parameters(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.triton_helpers import libdevice
import torch.nn as ... | XuezheMax/macow | LinearWeightNorm | false | 14,613 | [
"Apache-2.0"
] | 60 | 6de247c09b590a037c9eec2d6b1248845f6efb31 | https://github.com/XuezheMax/macow/tree/6de247c09b590a037c9eec2d6b1248845f6efb31 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_features, out_features, bias=True):
super().__init__()
self.linear = nn.Linear(in_features, out_features, bias=bias)
self.reset_parameters()
def reset_parameters(self):
nn.init.normal_(self.linea... |
DepthwiseSeparableConv | # 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 DepthwiseSeparableConv(nn.Module):
"""
Depth-wise separable convolution uses less parameters to generate output by convolution.
:Examples:
>>> m = DepthwiseSeparableConv(300, 200, 5, dim=1)
>>> input_tensor = torch.ra... | 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
assert_... | Worm4047/TVR | DepthwiseSeparableConv | false | 14,614 | [
"MIT"
] | 106 | 2a8ce2edbdc0966aef3b84c28872267039f01700 | https://github.com/Worm4047/TVR/tree/2a8ce2edbdc0966aef3b84c28872267039f01700 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Depth-wise separable convolution uses less parameters to generate output by convolution.
:Examples:
>>> m = DepthwiseSeparableConv(300, 200, 5, dim=1)
>>> input_tensor = torch.randn(32, 300, 20)
... |
McDalNetLoss | # 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 discrepancy_slice_wasserstein(p1, p2):
s = p1.shape
if s[1] > 1:
proj = torch.randn(s[1], 128)
proj *= torch.rsqrt(torch.sum(torch.mul(proj, proj), 0, keepdim=True))
p1 = torch.matmul(p1, proj)
p2 = torch.ma... | 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
... | YBZh/MultiClassDA | McDalNetLoss | false | 14,615 | [
"MIT"
] | 53 | b0f61a5fe82f8b5414a14e8d77753fbf5d4bcb93 | https://github.com/YBZh/MultiClassDA/tree/b0f61a5fe82f8b5414a14e8d77753fbf5d4bcb93 | import torch
import torch.nn as nn
import torch.nn.functional as F
def discrepancy_slice_wasserstein(p1, p2):
s = p1.shape
if s[1] > 1:
proj = torch.randn(s[1], 128)
proj *= torch.rsqrt(torch.sum(torch.mul(proj, proj), 0, keepdim=True))
p1 = torch.matmul(p1, proj)
p2 = torch.ma... |
TorchAdd | # 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 TorchAdd(nn.Module):
"""
TorchAdd Module.
"""
def forward(self, input_list):
return input_list[0] + input_list[1]
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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | Yakings/AIPerf | TorchAdd | false | 14,616 | [
"MIT"
] | 52 | 6e5c50a3b769ab4b1075aaab9841b5554f40bceb | https://github.com/Yakings/AIPerf/tree/6e5c50a3b769ab4b1075aaab9841b5554f40bceb | import torch
import torch.nn as nn
class Model(nn.Module):
"""
TorchAdd Module.
"""
def forward(self, input_list):
return input_list[0] + input_list[1]
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
GlobalAvgPool1d | # 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 abc import abstractmethod
from torch.nn import functional
class AvgPool(nn.Module):
"""
AvgPool Module.
"""
def __init__(self):
super().__init__()
@abstractmethod
def forward(self, input_tensor):
pass
class GlobalAvgPool1d(AvgPool):
... | 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 abc import abstractmethod
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = to... | Yakings/AIPerf | GlobalAvgPool1d | false | 14,617 | [
"MIT"
] | 52 | 6e5c50a3b769ab4b1075aaab9841b5554f40bceb | https://github.com/Yakings/AIPerf/tree/6e5c50a3b769ab4b1075aaab9841b5554f40bceb | import torch
import torch.nn as nn
from abc import abstractmethod
from torch.nn import functional
class AvgPool(nn.Module):
"""
AvgPool Module.
"""
def __init__(self):
super().__init__()
@abstractmethod
def forward(self, input_tensor):
pass
class Model(AvgPool):
"""
... |
Log_Loss | # 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
import torch.nn.parallel
class Log_Loss(nn.Module):
def __init__(self):
super(Log_Loss, self).__init__()
def forward(self, ytrue, ypred):
delta = ypred - ytrue
return torch.mean(torch.log(torch.cosh(delta)))
def get_inputs(... | 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... | YanLu-nyu/transferlearning | Log_Loss | false | 14,618 | [
"MIT"
] | 9,657 | 037806c6eb8b0c12aefbfbf3e35cbf893093cff9 | https://github.com/YanLu-nyu/transferlearning/tree/037806c6eb8b0c12aefbfbf3e35cbf893093cff9 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, ytrue, ypred):
delta = ypred - ytrue
return torch.mean(torch.log(torch.cosh(delta)))
def get_inputs():
return [to... |
GCN | # 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.parallel
class GCN(nn.Module):
""" Graph convolution unit (single layer)
"""
def __init__(self, num_state, num_node, bias=False):
super(GCN, self).__init__()
self.conv1 = nn.Conv1d(num_node, num_node, kernel_size=1)
self.relu = nn... | 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 ... | YJSYJSYJS/GloRe | GCN | false | 14,619 | [
"MIT"
] | 200 | b236dc92bd89f59c2b591c1b1ba5ead134ea75cd | https://github.com/YJSYJSYJS/GloRe/tree/b236dc92bd89f59c2b591c1b1ba5ead134ea75cd | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
""" Graph convolution unit (single layer)
"""
def __init__(self, num_state, num_node, bias=False):
super().__init__()
self.conv1 = nn.Conv1d(num_node, num_node, kernel_size=1)
self.relu = nn.ReLU(i... |
Sine | # 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 Sine(nn.Module):
def __init__(self, w0):
super().__init__()
self.w0 = w0
def forward(self, x):
return torch.sin(self.w0 * x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {'w0': 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.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | YangChenye/neurecon | Sine | false | 14,620 | [
"MIT"
] | 432 | 972e810ec252cfd16f630b1de6d2802d1b8de59a | https://github.com/YangChenye/neurecon/tree/972e810ec252cfd16f630b1de6d2802d1b8de59a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, w0):
super().__init__()
self.w0 = w0
def forward(self, x):
return torch.sin(self.w0 * x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [4]
|
Prone | # 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 logging
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _quadruple
def conv1x1(in_planes, out_planes, stride=1, args=None, force_fp=False):
"""1x1 convolution"""
if args is not None and hasattr(args, 'keyword'):
return custom_conv(in_planes,... | 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 logging
import torch.nn as nn
import torch.nn.functional as F
from torch.... | XiaotaoChen/model-quantization | Prone | false | 14,621 | [
"BSD-2-Clause"
] | 66 | a745ef691e9329b9c973a2dd795761cd3da8b6ae | https://github.com/XiaotaoChen/model-quantization/tree/a745ef691e9329b9c973a2dd795761cd3da8b6ae | import logging
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _quadruple
def conv1x1(in_planes, out_planes, stride=1, args=None, force_fp=False):
"""1x1 convolution"""
if args is not None and hasattr(args, 'keyword'):
return custom_conv(in_planes,... |
CFRB | # 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 collections import OrderedDict
import torch.nn as nn
import torch.nn.functional as F
def sequential(*args):
"""Advanced nn.Sequential.
Args:
nn.Sequential, nn.Module
Returns:
nn.Sequential
"""
if len(args) == 1:
if isinstance(args[0], OrderedDict):
... | 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 collections import Order... | WestCityInstitute/KAIR | CFRB | false | 14,622 | [
"MIT"
] | 1,521 | 3eb3cc7776fa8c57e8ed7c71bfa8039beb4c6677 | https://github.com/WestCityInstitute/KAIR/tree/3eb3cc7776fa8c57e8ed7c71bfa8039beb4c6677 | import torch
from collections import OrderedDict
import torch.nn as nn
import torch.nn.functional as F
def sequential(*args):
"""Advanced nn.Sequential.
Args:
nn.Sequential, nn.Module
Returns:
nn.Sequential
"""
if len(args) == 1:
if isinstance(args[0], OrderedDict):
... |
PatchEmbed3D | # 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 torchvision.transforms.functional as F
import torch.nn.functional as F
from torch import nn
class PatchEmbed3D(nn.Module):
""" Video to Patch Embedding.
Args:
patch_size (int): Patch token size. Default: (2,4,4).
in_chans (int): Number of input video channels. Default: 3.
... | 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... | XiaoJake/MTTR | PatchEmbed3D | false | 14,623 | [
"Apache-2.0"
] | 516 | c383c5b151e3c97aeb45cd2fb4bf08719016498b | https://github.com/XiaoJake/MTTR/tree/c383c5b151e3c97aeb45cd2fb4bf08719016498b | import torch
import torchvision.transforms.functional as F
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
""" Video to Patch Embedding.
Args:
patch_size (int): Patch token size. Default: (2,4,4).
in_chans (int): Number of input video channels. Default: 3.
... |
convBlock_basic | # 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 convBlock_basic(nn.Module):
def __init__(self, inChannel, outChannel, kernel, stride, pad,
use_batchnorm=False):
super(convBlock_basic, self).__init__()
self.use_batchnorm = use_batchnorm
self.conv = nn.Conv2d(inChannel, outChannel, 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 import nn
assert_s... | YacobBY/ICDAR2019-ArT-Recognition-Alchemy | convBlock_basic | false | 14,624 | [
"MIT"
] | 209 | 911c572c2aff4599a74b7974d46ef4cfb17078b9 | https://github.com/YacobBY/ICDAR2019-ArT-Recognition-Alchemy/tree/911c572c2aff4599a74b7974d46ef4cfb17078b9 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, inChannel, outChannel, kernel, stride, pad,
use_batchnorm=False):
super().__init__()
self.use_batchnorm = use_batchnorm
self.conv = nn.Conv2d(inChannel, outChannel, kernel, stride=stride,
padd... |
AttentionUnit | # 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
from torch import nn
from torch.nn import init
class AttentionUnit(nn.Module):
def __init__(self, sDim, xDim, attDim):
super(AttentionUnit, self).__init__()
self.sDim = sDim
self.xDim = xDim
self.attDim = attDim
self.sEmbed = nn... | 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.... | YacobBY/ICDAR2019-ArT-Recognition-Alchemy | AttentionUnit | false | 14,625 | [
"MIT"
] | 209 | 911c572c2aff4599a74b7974d46ef4cfb17078b9 | https://github.com/YacobBY/ICDAR2019-ArT-Recognition-Alchemy/tree/911c572c2aff4599a74b7974d46ef4cfb17078b9 | import torch
import torch.nn.functional as F
from torch import nn
from torch.nn import init
class Model(nn.Module):
def __init__(self, sDim, xDim, attDim):
super().__init__()
self.sDim = sDim
self.xDim = xDim
self.attDim = attDim
self.sEmbed = nn.Linear(sDim, attDim)
... |
SoftmaxAttention | # 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
def masked_softmax(tensor, mask):
"""
Apply a masked softmax on the last dimension of a tensor.
The input tensor and mask should be of size (batch, *, sequence_length).
Args:
tensor: The tensor on which the softmax function must be applied along
t... | 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.... | YJiangcm/Chinese-sentence-pair-modeling | SoftmaxAttention | false | 14,626 | [
"Apache-2.0"
] | 49 | 90adbc5c121832ce3e4a4057e30417a6ec5e7ebc | https://github.com/YJiangcm/Chinese-sentence-pair-modeling/tree/90adbc5c121832ce3e4a4057e30417a6ec5e7ebc | import torch
import torch.nn as nn
def masked_softmax(tensor, mask):
"""
Apply a masked softmax on the last dimension of a tensor.
The input tensor and mask should be of size (batch, *, sequence_length).
Args:
tensor: The tensor on which the softmax function must be applied along
t... |
OZELoss | # 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
import torch.nn.parallel
class OZELoss(nn.Module):
"""Custom loss for TRNSys metamodel.
Compute, for temperature and consumptions, the intergral of the squared differences
over time. Sum the log with a coeficient ``alpha``.
.. math::
... | 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.utils.data
import torch.nn as nn
import torch.nn.parallel
as... | YanLu-nyu/transferlearning | OZELoss | false | 14,627 | [
"MIT"
] | 9,657 | 037806c6eb8b0c12aefbfbf3e35cbf893093cff9 | https://github.com/YanLu-nyu/transferlearning/tree/037806c6eb8b0c12aefbfbf3e35cbf893093cff9 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
"""Custom loss for TRNSys metamodel.
Compute, for temperature and consumptions, the intergral of the squared differences
over time. Sum the log with a coeficient ``alpha``.
.. math::
\... |
AdjustSigmoid | # 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 torch.nn import Module
import torch
from torch import Tensor
from typing import Optional
def KORNIA_CHECK_IS_TENSOR(x, msg: 'Optional[str]'=None):
if not isinstance(x, Tensor):
raise TypeError(f'Not a Tensor type. Got: {type(x)}.\n{msg}')
def adjust_sigmoid(image: 'Tensor', cutoff: 'float'=0.5, gai... | 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
from torch.nn import Module
from torch import Tensor
from typing import O... | YanivHollander/kornia | AdjustSigmoid | false | 14,628 | [
"ECL-2.0",
"Apache-2.0"
] | 418 | ccd258d0956da89b1feca96448eff8e4969d405a | https://github.com/YanivHollander/kornia/tree/ccd258d0956da89b1feca96448eff8e4969d405a | from torch.nn import Module
import torch
from torch import Tensor
from typing import Optional
def KORNIA_CHECK_IS_TENSOR(x, msg: 'Optional[str]'=None):
if not isinstance(x, Tensor):
raise TypeError(f'Not a Tensor type. Got: {type(x)}.\n{msg}')
def adjust_sigmoid(image: 'Tensor', cutoff: 'float'=0.5, gai... |
PositionwiseFeedForward | # 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
import torch.nn.functional as F
import torch.nn.parallel
from typing import Optional
class PositionwiseFeedForward(nn.Module):
"""Position-wise Feed Forward Network block from Attention is All You Need.
Apply two linear transformations to each input,... | 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.utils.data
impor... | YanLu-nyu/transferlearning | PositionwiseFeedForward | false | 14,629 | [
"MIT"
] | 9,657 | 037806c6eb8b0c12aefbfbf3e35cbf893093cff9 | https://github.com/YanLu-nyu/transferlearning/tree/037806c6eb8b0c12aefbfbf3e35cbf893093cff9 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
from typing import Optional
class Model(nn.Module):
"""Position-wise Feed Forward Network block from Attention is All You Need.
Apply two linear transformations to each input, separately but in... |
Hflip | # 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
def hflip(input: 'torch.Tensor') ->torch.Tensor:
"""Horizontally flip a tensor image or a batch of tensor images.
.. image:: _static/img/hflip.png
Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
Args:
input: input tens... | 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... | YanivHollander/kornia | Hflip | false | 14,630 | [
"ECL-2.0",
"Apache-2.0"
] | 418 | ccd258d0956da89b1feca96448eff8e4969d405a | https://github.com/YanivHollander/kornia/tree/ccd258d0956da89b1feca96448eff8e4969d405a | import torch
import torch.nn as nn
def hflip(input: 'torch.Tensor') ->torch.Tensor:
"""Horizontally flip a tensor image or a batch of tensor images.
.. image:: _static/img/hflip.png
Input must be a tensor of shape (C, H, W) or a batch of tensors :math:`(*, C, H, W)`.
Args:
input: input tens... |
BinaryFocalLossWithLogits | # 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 warnings
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
def binary_focal_loss_with_logits(input: 'torch.Tensor', target:
'torch.Tensor', alpha: 'float'=0.25, gamma: 'float'=2.0, reduction:
'str'='none', eps: 'Optional[float]'=None) ->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 torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import warn... | YanivHollander/kornia | BinaryFocalLossWithLogits | false | 14,631 | [
"ECL-2.0",
"Apache-2.0"
] | 418 | ccd258d0956da89b1feca96448eff8e4969d405a | https://github.com/YanivHollander/kornia/tree/ccd258d0956da89b1feca96448eff8e4969d405a | import torch
import warnings
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
def binary_focal_loss_with_logits(input: 'torch.Tensor', target:
'torch.Tensor', alpha: 'float'=0.25, gamma: 'float'=2.0, reduction:
'str'='none', eps: 'Optional[float]'=None) ->torch.Tensor:
"""... |
AdjustLog | # 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 torch.nn import Module
import torch
from torch import Tensor
from typing import Optional
def KORNIA_CHECK_IS_TENSOR(x, msg: 'Optional[str]'=None):
if not isinstance(x, Tensor):
raise TypeError(f'Not a Tensor type. Got: {type(x)}.\n{msg}')
def adjust_log(image: 'Tensor', gain: 'float'=1, inv: 'bool'... | 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
from torch.nn import Module
... | YanivHollander/kornia | AdjustLog | false | 14,632 | [
"ECL-2.0",
"Apache-2.0"
] | 418 | ccd258d0956da89b1feca96448eff8e4969d405a | https://github.com/YanivHollander/kornia/tree/ccd258d0956da89b1feca96448eff8e4969d405a | from torch.nn import Module
import torch
from torch import Tensor
from typing import Optional
def KORNIA_CHECK_IS_TENSOR(x, msg: 'Optional[str]'=None):
if not isinstance(x, Tensor):
raise TypeError(f'Not a Tensor type. Got: {type(x)}.\n{msg}')
def adjust_log(image: 'Tensor', gain: 'float'=1, inv: 'bool'... |
FullAttention | # 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 torch.nn import Module
import torch
from torch.nn import Dropout
class FullAttention(Module):
def __init__(self, use_dropout=False, attention_dropout=0.1):
super().__init__()
self.use_dropout = use_dropout
self.dropout = Dropout(attention_dropout)
def forward(self, queries, keys... | 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.... | YanivHollander/kornia | FullAttention | false | 14,633 | [
"ECL-2.0",
"Apache-2.0"
] | 418 | ccd258d0956da89b1feca96448eff8e4969d405a | https://github.com/YanivHollander/kornia/tree/ccd258d0956da89b1feca96448eff8e4969d405a | from torch.nn import Module
import torch
from torch.nn import Dropout
class Model(Module):
def __init__(self, use_dropout=False, attention_dropout=0.1):
super().__init__()
self.use_dropout = use_dropout
self.dropout = Dropout(attention_dropout)
def forward(self, queries, keys, values... |
Alignment | # 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
from torch.nn import Module
import math
import torch
import torch.nn as nn
import torch.nn.functional as f
class Module(nn.Module):
def __init__(self):
super().__init__()
self.summary = {}
def add_summary(self, name, val):
if self.trainin... | 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.... | YJiangcm/Chinese-sentence-pair-modeling | Alignment | false | 14,634 | [
"Apache-2.0"
] | 49 | 90adbc5c121832ce3e4a4057e30417a6ec5e7ebc | https://github.com/YJiangcm/Chinese-sentence-pair-modeling/tree/90adbc5c121832ce3e4a4057e30417a6ec5e7ebc | from _paritybench_helpers import _mock_config
from torch.nn import Module
import math
import torch
import torch.nn as nn
import torch.nn.functional as f
class Module(nn.Module):
def __init__(self):
super().__init__()
self.summary = {}
def add_summary(self, name, val):
if self.trainin... |
PatchEmbed | # 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 PatchEmbed(nn.Module):
""" Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
num_patches = img_size // patch_size * (img_size // patch_size)
self.img_size = img_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 import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | YangtaoWANG95/TokenCut | PatchEmbed | false | 14,635 | [
"MIT"
] | 97 | ea585c55e631d17c239f875550b2d0b230446b25 | https://github.com/YangtaoWANG95/TokenCut/tree/ea585c55e631d17c239f875550b2d0b230446b25 | import torch
from torch import nn
class Model(nn.Module):
""" Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
num_patches = img_size // patch_size * (img_size // patch_size)
self.img_size = img_size
... |
BlobDoG | # 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
from typing import Optional
import torch.nn as nn
from typing import List
def KORNIA_CHECK_IS_TENSOR(x, msg: 'Optional[str]'=None):
if not isinstance(x, Tensor):
raise TypeError(f'Not a Tensor type. Got: {type(x)}.\n{msg}')
def KORNIA_CHECK_SHAPE(x, shape: 'List[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 import Tensor
from typing import Optional
import torch.nn as nn
from typing import List
assert_size_stride = torch._C._dynamo.gua... | YanivHollander/kornia | BlobDoG | false | 14,636 | [
"ECL-2.0",
"Apache-2.0"
] | 418 | ccd258d0956da89b1feca96448eff8e4969d405a | https://github.com/YanivHollander/kornia/tree/ccd258d0956da89b1feca96448eff8e4969d405a | import torch
from torch import Tensor
from typing import Optional
import torch.nn as nn
from typing import List
def KORNIA_CHECK_IS_TENSOR(x, msg: 'Optional[str]'=None):
if not isinstance(x, Tensor):
raise TypeError(f'Not a Tensor type. Got: {type(x)}.\n{msg}')
def KORNIA_CHECK_SHAPE(x, shape: 'List[str... |
EltwiseSubEmbed | # 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 EltwiseSubEmbed(nn.Module):
def __init__(self, nonlinearity='square', use_batch_norm=False,
use_classifier=False, num_features=0, num_classes=0):
super(EltwiseSubEmbed, self).__init__()
self.nonlinearity = nonlinearity
if nonlinearity is not... | 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... | YantaoShen/kpm_rw_person_reid | EltwiseSubEmbed | false | 14,637 | [
"MIT"
] | 112 | 01393e024aa1139c9e7e934954cc35826f438a54 | https://github.com/YantaoShen/kpm_rw_person_reid/tree/01393e024aa1139c9e7e934954cc35826f438a54 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, nonlinearity='square', use_batch_norm=False,
use_classifier=False, num_features=0, num_classes=0):
super().__init__()
self.nonlinearity = nonlinearity
if nonlinearity is not None and nonlinearity not in [... |
Qux | # 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.jit
import torch.onnx
import torch.nn
class Qux(torch.nn.Module):
def __init__(self, x):
super(Qux, self).__init__()
self.x = x
def forward(self, a, b):
return a - b - self.x
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 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
import torch.jit
import torch.onnx
import torch.nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | YaronBenAtar/glow | Qux | false | 14,638 | [
"Apache-2.0"
] | 2,838 | a13706a4239fa7eaf059c670dc573e3eb0768f86 | https://github.com/YaronBenAtar/glow/tree/a13706a4239fa7eaf059c670dc573e3eb0768f86 | import torch
import torch.jit
import torch.onnx
import torch.nn
class Model(torch.nn.Module):
def __init__(self, x):
super().__init__()
self.x = x
def forward(self, a, b):
return a - b - self.x
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def ... |
SimpleACosModule | # 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.jit
import torch.onnx
import torch.nn
class SimpleACosModule(torch.nn.Module):
def __init__(self):
super(SimpleACosModule, self).__init__()
def forward(self, a):
return torch.acos(a + a)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs... | 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.jit
import torch.onnx
import torch.nn
assert_size_stride = torch._... | YaronBenAtar/glow | SimpleACosModule | false | 14,639 | [
"Apache-2.0"
] | 2,838 | a13706a4239fa7eaf059c670dc573e3eb0768f86 | https://github.com/YaronBenAtar/glow/tree/a13706a4239fa7eaf059c670dc573e3eb0768f86 | import torch
import torch.jit
import torch.onnx
import torch.nn
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, a):
return torch.acos(a + a)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
SimpleClampModel | # 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.jit
import torch.onnx
import torch.nn
class SimpleClampModel(torch.nn.Module):
def __init__(self, min, max):
super(SimpleClampModel, self).__init__()
self.min = min
self.max = max
def forward(self, input):
return torch.clamp(input, self.min, self.max... | 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.jit
import torch.onnx
import torch.nn
assert_size_stride = torch._C._dynamo.... | YaronBenAtar/glow | SimpleClampModel | false | 14,640 | [
"Apache-2.0"
] | 2,838 | a13706a4239fa7eaf059c670dc573e3eb0768f86 | https://github.com/YaronBenAtar/glow/tree/a13706a4239fa7eaf059c670dc573e3eb0768f86 | import torch
import torch.jit
import torch.onnx
import torch.nn
class Model(torch.nn.Module):
def __init__(self, min, max):
super().__init__()
self.min = min
self.max = max
def forward(self, input):
return torch.clamp(input, self.min, self.max)
def get_inputs():
return ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.