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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
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
import numpy as np
from torch import nn
class ScaledDotProductAttention(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)
se... | 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.... | ArrowLuo/GRACE | ScaledDotProductAttention | false | 7,744 | [
"Apache-2.0"
] | 17 | f27b500ba905685c03eee6d91d87adc9ef78b4d1 | https://github.com/ArrowLuo/GRACE/tree/f27b500ba905685c03eee6d91d87adc9ef78b4d1 | import torch
import numpy as np
from torch import nn
class Model(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)
self.softmax = nn.Soft... |
ConvNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
class ConvNorm(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=None, dilation=1, bias=True, w_init_gain='linear', dropout=0.0
):
super(ConvNorm, self).__init__()
i... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size... | AstraliteHeart/cookietts | ConvNorm | false | 7,745 | [
"BSD-3-Clause"
] | 25 | c871f5f7b5790656d5b57bcd9e63946a2da52f0f | https://github.com/AstraliteHeart/cookietts/tree/c871f5f7b5790656d5b57bcd9e63946a2da52f0f | import torch
import torch.utils.data
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=None, dilation=1, bias=True, w_init_gain='linear', dropout=0.0
):
super().__init__()
if padding is None... |
Conv1d | # 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
from torch import nn
from torch.nn import Conv1d
class Conv1d(nn.Conv1d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param strid... | 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
from torch import nn
assert_size_stride = torch._C._dyna... | AstraliteHeart/cookietts | Conv1d | false | 7,746 | [
"BSD-3-Clause"
] | 25 | c871f5f7b5790656d5b57bcd9e63946a2da52f0f | https://github.com/AstraliteHeart/cookietts/tree/c871f5f7b5790656d5b57bcd9e63946a2da52f0f | import torch
import torch.utils.data
from torch import nn
from torch.nn import Conv1d
class Model(nn.Conv1d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride... |
Conv2d | # 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
from torch import nn
from torch.nn import Conv2d
class Conv2d(nn.Conv2d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param strid... | 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
from torch import nn
assert_size_stride = torch._C._dyna... | AstraliteHeart/cookietts | Conv2d | false | 7,747 | [
"BSD-3-Clause"
] | 25 | c871f5f7b5790656d5b57bcd9e63946a2da52f0f | https://github.com/AstraliteHeart/cookietts/tree/c871f5f7b5790656d5b57bcd9e63946a2da52f0f | import torch
import torch.utils.data
from torch import nn
from torch.nn import Conv2d
class Model(nn.Conv2d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride... |
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 math
import torch
from torch import 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.pi) * (x + 0.044715 * torch.pow(x, 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._inductor.runtime.triton_helpers import libdevice
import math
from to... | ArrowLuo/GRACE | PositionwiseFeedForward | false | 7,748 | [
"Apache-2.0"
] | 17 | f27b500ba905685c03eee6d91d87adc9ef78b4d1 | https://github.com/ArrowLuo/GRACE/tree/f27b500ba905685c03eee6d91d87adc9ef78b4d1 | import math
import torch
from torch import 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.pi) * (x + 0.044715 * torch.pow(x, 3))))
"... |
Conv2d | # 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.nn import Module
import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch.nn.parameter import Parameter
from torch.nn.functional import pad
from torch.nn.modules import Module
from torch.nn.modules.utils import _pair
import torch.nn.parallel
def conv2d_same_padding(i... | 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.nn import Module
import math
from torch.nn import functional as F
imp... | AvrilCheng/LidarStereoNet | Conv2d | false | 7,749 | [
"MIT"
] | 27 | 96c7cd6d5edb9b2fd302e2edd0c05cbda1ed024e | https://github.com/AvrilCheng/LidarStereoNet/tree/96c7cd6d5edb9b2fd302e2edd0c05cbda1ed024e | from torch.nn import Module
import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch.nn.parameter import Parameter
from torch.nn.functional import pad
from torch.nn.modules import Module
from torch.nn.modules.utils import _pair
import torch.nn.parallel
def conv2d_same_padding(i... |
SiLU | # 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 SiLU(nn.Module):
"""export-friendly version of nn.SiLU()"""
@staticmethod
def forward(x):
return x * torch.sigmoid(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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | Arui66/YOLOX | SiLU | false | 7,750 | [
"Apache-2.0"
] | 16 | 7ee17936db849600817d7de05269bfdfb1a0eb48 | https://github.com/Arui66/YOLOX/tree/7ee17936db849600817d7de05269bfdfb1a0eb48 | import torch
import torch.nn as nn
class Model(nn.Module):
"""export-friendly version of nn.SiLU()"""
@staticmethod
def forward(x):
return x * torch.sigmoid(x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
Auto_Encoder_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
import torch.nn.functional as F
class Auto_Encoder_Model(nn.Module):
def __init__(self):
super(Auto_Encoder_Model, self).__init__()
self.conv1 = nn.Conv2d(1, 64, padding=1, kernel_size=3)
self.max_pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(64... | 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 ... | Awenbocc/med-vqa | Auto_Encoder_Model | false | 7,751 | [
"MIT"
] | 27 | 0cca6811e38cf54aff6a7cce3442296d07875e64 | https://github.com/Awenbocc/med-vqa/tree/0cca6811e38cf54aff6a7cce3442296d07875e64 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 64, padding=1, kernel_size=3)
self.max_pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(64, 32, padding=1, kernel_size=3)
... |
Attention_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
import torch.nn as nn
import torch.nn.functional as F
class Attention_SEblock(nn.Module):
def __init__(self, channels, reduction, temperature):
super(Attention_SEblock, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = nn.Linear(channels, channels // reducti... | 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.... | Andrew-Zhu/DyFPN | Attention_SEblock | false | 7,752 | [
"Apache-2.0"
] | 32 | a74463b59c4ce28253c2449a07c0f6692a0147a1 | https://github.com/Andrew-Zhu/DyFPN/tree/a74463b59c4ce28253c2449a07c0f6692a0147a1 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, channels, reduction, temperature):
super().__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = nn.Linear(channels, channels // reduction)
self.relu = nn.ReLU(inp... |
Conv3d | # 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.nn import Module
import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch.nn.parameter import Parameter
from torch.nn.functional import pad
from torch.nn.modules import Module
from torch.nn.modules.utils import _triple
import torch.nn.parallel
def conv3d_same_padding... | 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.nn import Module
import math
from torch.nn import functional as F
imp... | AvrilCheng/LidarStereoNet | Conv3d | false | 7,753 | [
"MIT"
] | 27 | 96c7cd6d5edb9b2fd302e2edd0c05cbda1ed024e | https://github.com/AvrilCheng/LidarStereoNet/tree/96c7cd6d5edb9b2fd302e2edd0c05cbda1ed024e | from torch.nn import Module
import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch.nn.parameter import Parameter
from torch.nn.functional import pad
from torch.nn.modules import Module
from torch.nn.modules.utils import _triple
import torch.nn.parallel
def conv3d_same_padding... |
ShiftedSoftplus | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class ShiftedSoftplus(torch.nn.Module):
def __init__(self):
super(ShiftedSoftplus, self).__init__()
self.shift = torch.log(torch.tensor(2.0)).item()
def forward(self, x):
return F.softplus(x) - self.shift
def get_inputs():
return [to... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
assert_size_stride = torch._C._dynamo.guards.assert_size_strid... | BaratiLab/AugLiChem | ShiftedSoftplus | false | 7,754 | [
"MIT"
] | 16 | 37258b5ce2c653436b3e819b58d2659052d6edcc | https://github.com/BaratiLab/AugLiChem/tree/37258b5ce2c653436b3e819b58d2659052d6edcc | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
self.shift = torch.log(torch.tensor(2.0)).item()
def forward(self, x):
return F.softplus(x) - self.shift
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def g... |
Upsample | # 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
import torch.nn.functional as F
class Upsample(nn.Module):
def __init__(self, scale_factor=2, size=None):
super(Upsample, self).__init__()
self.upsample = F.upsample_nearest
self.size = size
self.scale_factor = scale_facto... | 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
import torch.utils.data
import torch.nn.functional as F
assert_size_stride = torch._C._dynamo.guards.assert_size_strid... | Bhaskers-Blu-Org1/gfmn | Upsample | false | 7,756 | [
"Apache-2.0"
] | 15 | 52b4fd005f8c52297bd6aa5d93e4a1c8d46f56ce | https://github.com/Bhaskers-Blu-Org1/gfmn/tree/52b4fd005f8c52297bd6aa5d93e4a1c8d46f56ce | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, scale_factor=2, size=None):
super().__init__()
self.upsample = F.upsample_nearest
self.size = size
self.scale_factor = scale_factor
def forwar... |
ChamferLoss | # 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 batch_pairwise_dist(x, y):
_bs, num_points_x, _points_dim = x.size()
_, num_points_y, _ = y.size()
xx = torch.bmm(x, x.transpose(2, 1))
yy = torch.bmm(y, y.transpose(2, 1))
zz = torch.bmm(x, y.transpose(2, 1))
diag_ind_x = torch.arange(0, num_points_x)
... | 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_... | AnTao97/UnsupervisedPointCloudSegmentation | ChamferLoss | false | 7,757 | [
"MIT"
] | 13 | 9bcf0bdf3b1ae62421d9202eb7c0b014d6a69c02 | https://github.com/AnTao97/UnsupervisedPointCloudSegmentation/tree/9bcf0bdf3b1ae62421d9202eb7c0b014d6a69c02 | import torch
import torch.nn as nn
def batch_pairwise_dist(x, y):
_bs, num_points_x, _points_dim = x.size()
_, num_points_y, _ = y.size()
xx = torch.bmm(x, x.transpose(2, 1))
yy = torch.bmm(y, y.transpose(2, 1))
zz = torch.bmm(x, y.transpose(2, 1))
diag_ind_x = torch.arange(0, num_points_x)
... |
Step | # 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 StepF(torch.autograd.Function):
""" A step function that returns values in {-1, 1} and uses the Straigh-Through Estimator
to update upstream weights in the network
"""
@staticmethod
def forward(ctx, input_):
ctx.save_for_backward(input_)
... | 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... | Bhaskers-Blu-Org1/online-alt-min | Step | false | 7,758 | [
"Apache-2.0"
] | 23 | ef31aaad639c0880df8700d34613164298bcadd0 | https://github.com/Bhaskers-Blu-Org1/online-alt-min/tree/ef31aaad639c0880df8700d34613164298bcadd0 | import torch
import torch.nn as nn
class StepF(torch.autograd.Function):
""" A step function that returns values in {-1, 1} and uses the Straigh-Through Estimator
to update upstream weights in the network
"""
@staticmethod
def forward(ctx, input_):
ctx.save_for_backward(input_)
... |
BilinearAttention | # 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
from torch import nn
class BilinearAttention(nn.Module):
"""
:param enc_dim: Scalar.
:param dec_dim: Scalar
"""
def __init__(self, enc_dim, dec_dim):
super(BilinearAttention, self).__init__()
self.W = nn.Linear(enc_dim, dec_dim)
def 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
from torch._inductor.runtime.... | AstraliteHeart/cookietts | BilinearAttention | false | 7,759 | [
"BSD-3-Clause"
] | 25 | c871f5f7b5790656d5b57bcd9e63946a2da52f0f | https://github.com/AstraliteHeart/cookietts/tree/c871f5f7b5790656d5b57bcd9e63946a2da52f0f | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
"""
:param enc_dim: Scalar.
:param dec_dim: Scalar
"""
def __init__(self, enc_dim, dec_dim):
super().__init__()
self.W = nn.Linear(enc_dim, dec_dim)
def forward(self, h, s):
"""
... |
InnerProductLoss | # 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 InnerProductLoss(nn.Module):
"""This is the inner-product loss used in CFKG for optimization.
"""
def __init__(self):
super(InnerProductLoss, self).__init__()
def forward(self, anchor, positive, negative):
pos_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
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.gu... | BELIEVEfxy/LightSANs | InnerProductLoss | false | 7,760 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""This is the inner-product loss used in CFKG for optimization.
"""
def __init__(self):
super().__init__()
def forward(self, anchor, positive, negative):
pos_score = torch.mul(anchor, positive... |
Conv1d2Score | # 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
class Conv1d2Score(nn.Module):
"""Calculate a N*out_dim tensor from N*in_dim*seq_len using nn.Conv1d
Essentially it is a linear layer
Args:
in_dim: int
out_dim: int, usually number of classes
seq_len: int
Shape... | 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.optim
import torch.utils.data
assert_size_str... | BeautyOfWeb/VIN | Conv1d2Score | false | 7,761 | [
"MIT"
] | 34 | 53343d28130f5fd6e5badb58daf8079a5933fd6a | https://github.com/BeautyOfWeb/VIN/tree/53343d28130f5fd6e5badb58daf8079a5933fd6a | import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
class Model(nn.Module):
"""Calculate a N*out_dim tensor from N*in_dim*seq_len using nn.Conv1d
Essentially it is a linear layer
Args:
in_dim: int
out_dim: int, usually number of classes
seq_len: int
Shape:
-... |
IOUloss | # 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 IOUloss(nn.Module):
def __init__(self, reduction='none', loss_type='iou'):
super(IOUloss, self).__init__()
self.reduction = reduction
self.loss_type = loss_type
def forward(self, pred, target):
assert pred.shape[0] == target.shape[0]
... | 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... | Arui66/YOLOX | IOUloss | false | 7,762 | [
"Apache-2.0"
] | 16 | 7ee17936db849600817d7de05269bfdfb1a0eb48 | https://github.com/Arui66/YOLOX/tree/7ee17936db849600817d7de05269bfdfb1a0eb48 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, reduction='none', loss_type='iou'):
super().__init__()
self.reduction = reduction
self.loss_type = loss_type
def forward(self, pred, target):
assert pred.shape[0] == target.shape[0]
pred = p... |
WeightedView | # 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
class WeightedView(nn.Module):
"""Calculate weighted view
Args:
num_groups: int, number of groups (views)
reduce_dimension: bool, default False. If True, reduce dimension dim
dim: default -1. Only used w... | 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
import torch.optim
import torch.utils.data
assert_s... | BeautyOfWeb/AffinityNet | WeightedView | false | 7,763 | [
"MIT"
] | 34 | d3f79823fa0182328894483165d4f0853740ee53 | https://github.com/BeautyOfWeb/AffinityNet/tree/d3f79823fa0182328894483165d4f0853740ee53 | import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
class Model(nn.Module):
"""Calculate weighted view
Args:
num_groups: int, number of groups (views)
reduce_dimension: bool, default False. If True, reduce dimension dim
dim: default -1. Only used when red... |
LearnedUpsampling1d | # 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 LearnedUpsampling1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, bias=True):
super().__init__()
self.conv_t = nn.ConvTranspose1d(in_channels=in_channels,
out_channels=out_channels, kernel_size=kernel_size, 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 import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | Barbany/Multi-speaker-Neural-Vocoder | LearnedUpsampling1d | false | 7,764 | [
"MIT"
] | 13 | a3f5c266603b17bcbe264e750947140f302272c8 | https://github.com/Barbany/Multi-speaker-Neural-Vocoder/tree/a3f5c266603b17bcbe264e750947140f302272c8 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, bias=True):
super().__init__()
self.conv_t = nn.ConvTranspose1d(in_channels=in_channels,
out_channels=out_channels, kernel_size=kernel_size, stride=
kernel_... |
InnerProductLayer | # 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 InnerProductLayer(nn.Module):
"""InnerProduct Layer used in PNN that compute the element-wise
product or inner product between feature vectors.
"""
def __init__(self, num_feature_field, device):
"""
Args:
num_feature_field(int) :nu... | 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... | BELIEVEfxy/LightSANs | InnerProductLayer | false | 7,765 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
"""InnerProduct Layer used in PNN that compute the element-wise
product or inner product between feature vectors.
"""
def __init__(self, num_feature_field, device):
"""
Args:
num_feature_field(int) :number of feat... |
ConvLSTMCell | # 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 ConvLSTMCell(nn.Module):
"""
Implementation of the Basic ConvLSTM.
No peephole connection, no forget gate.
ConvLSTM:
x - input
h - hidden representation
c - memory cell
f - forget gate
o - output gate
Reference:Conv... | 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 ... | BenQLange/AttentionAugmentedConvLSTM | ConvLSTMCell | false | 7,766 | [
"MIT"
] | 30 | d8419b7a628b02ac49e8450deb3d60450c7b2d6b | https://github.com/BenQLange/AttentionAugmentedConvLSTM/tree/d8419b7a628b02ac49e8450deb3d60450c7b2d6b | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Implementation of the Basic ConvLSTM.
No peephole connection, no forget gate.
ConvLSTM:
x - input
h - hidden representation
c - memory cell
f - forget gate
o - output gate
Reference:Convolution... |
BPRLoss | # 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 BPRLoss(nn.Module):
""" BPRLoss, based on Bayesian Personalized Ranking
Args:
- gamma(float): Small value to avoid division by zero
Shape:
- Pos_score: (N)
- Neg_score: (N), same shape as the Pos_score
- Output: scalar.
Exampl... | 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
... | BELIEVEfxy/LightSANs | BPRLoss | false | 7,767 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
""" BPRLoss, based on Bayesian Personalized Ranking
Args:
- gamma(float): Small value to avoid division by zero
Shape:
- Pos_score: (N)
- Neg_score: (N), same shape as the Pos_score
- Output: scalar.
Examples... |
Policy | # 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.nn.parallel
import torch.utils.data
import torch.optim
import torch.autograd
class Policy(nn.Module):
def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.affine2 = nn.Linea... | 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.... | BestSonny/examples | Policy | false | 7,768 | [
"BSD-3-Clause"
] | 13 | 4b7365c0db22133d1793e53bb3674c2d0ebaeac1 | https://github.com/BestSonny/examples/tree/4b7365c0db22133d1793e53bb3674c2d0ebaeac1 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.utils.data
import torch.optim
import torch.autograd
class Model(nn.Module):
def __init__(self):
super().__init__()
self.affine1 = nn.Linear(4, 128)
self.affine2 = nn.Linear(128, 2)
... |
ConvNCFBPRLoss | # 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 ConvNCFBPRLoss(nn.Module):
""" ConvNCFBPRLoss, based on Bayesian Personalized Ranking,
Shape:
- Pos_score: (N)
- Neg_score: (N), same shape as the Pos_score
- Output: scalar.
Examples::
>>> loss = ConvNCFBPRLoss()
>>> ... | 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
... | BELIEVEfxy/LightSANs | ConvNCFBPRLoss | false | 7,769 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
""" ConvNCFBPRLoss, based on Bayesian Personalized Ranking,
Shape:
- Pos_score: (N)
- Neg_score: (N), same shape as the Pos_score
- Output: scalar.
Examples::
>>> loss = ConvNCFBPRLoss()
>>> pos_score... |
AttLayer | # 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 fn
class AttLayer(nn.Module):
"""Calculate the attention signal(weight) according the input tensor.
Args:
infeatures (torch.FloatTensor): A 3D input tensor with shape of[batch_size, M, embed_dim].
Returns:
torch.FloatTensor... | 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.... | BELIEVEfxy/LightSANs | AttLayer | false | 7,770 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
import torch.nn.functional as fn
class Model(nn.Module):
"""Calculate the attention signal(weight) according the input tensor.
Args:
infeatures (torch.FloatTensor): A 3D input tensor with shape of[batch_size, M, embed_dim].
Returns:
torch.FloatTensor: A... |
SpanClassifier | # 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 BCELoss
class SpanClassifier(nn.Module):
"""given the span embeddings, classify whether their relations"""
def __init__(self, d_inp):
super(SpanClassifier, self).__init__()
self.d_inp = d_inp
self.bilinear_layer = nn.Bilinear(d_i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.nn import BCELoss
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
reinterpret_tensor = torc... | Bhaskers-Blu-Org1/superglue-mtl | SpanClassifier | false | 7,771 | [
"Apache-2.0"
] | 15 | 1eb3e581c0ef3b4c261e0256ec26116d2b657c40 | https://github.com/Bhaskers-Blu-Org1/superglue-mtl/tree/1eb3e581c0ef3b4c261e0256ec26116d2b657c40 | import torch
import torch.nn as nn
from torch.nn import BCELoss
class Model(nn.Module):
"""given the span embeddings, classify whether their relations"""
def __init__(self, d_inp):
super().__init__()
self.d_inp = d_inp
self.bilinear_layer = nn.Bilinear(d_inp, d_inp, 1)
self.ou... |
RegLoss | # 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 RegLoss(nn.Module):
""" RegLoss, L2 regularization on model parameters
"""
def __init__(self):
super(RegLoss, self).__init__()
def forward(self, parameters):
reg_loss = None
for W in parameters:
if reg_loss is 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_... | BELIEVEfxy/LightSANs | RegLoss | false | 7,772 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
""" RegLoss, L2 regularization on model parameters
"""
def __init__(self):
super().__init__()
def forward(self, parameters):
reg_loss = None
for W in parameters:
if reg_loss is None:
reg_l... |
OuterProductLayer | # 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 OuterProductLayer(nn.Module):
"""OutterProduct Layer used in PNN. This implemention is
adapted from code that the author of the paper published on https://github.com/Atomu2014/product-nets.
"""
def __init__(self, num_feature_field, embedding_size, device):
... | 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... | BELIEVEfxy/LightSANs | OuterProductLayer | false | 7,773 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
"""OutterProduct Layer used in PNN. This implemention is
adapted from code that the author of the paper published on https://github.com/Atomu2014/product-nets.
"""
def __init__(self, num_feature_field, embedding_size, device):
"""
... |
Sign | # 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.autograd import Function
import torch
import torch.nn as nn
class SignFunction(Function):
def __init__(self):
super(SignFunction, self).__init__()
@staticmethod
def forward(ctx, input, is_training=True):
if is_training:
prob = input.new(input.size()).uniform_()
... | 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.autograd import Function
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda... | Biaze7/lossy-image-compression | Sign | false | 7,774 | [
"MIT"
] | 16 | 88ca2022a306fea52d6671593b314f0de3bf6010 | https://github.com/Biaze7/lossy-image-compression/tree/88ca2022a306fea52d6671593b314f0de3bf6010 | from torch.autograd import Function
import torch
import torch.nn as nn
class SignFunction(Function):
def __init__(self):
super().__init__()
@staticmethod
def forward(ctx, input, is_training=True):
if is_training:
prob = input.new(input.size()).uniform_()
x = input... |
D_phiVpsi | # 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
def add_layer(seq, ix, n_inputs, n_outputs, nonlin, normalization):
seq.add_module('L' + str(ix), nn.Linear(n_inputs, n_outputs))
if ix > 0 and normalization:
if normalization == 'LN':
seq.main.add_module('A' + str(ix), nn.LayerNor... | 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... | Bhaskers-Blu-Org1/SIC | D_phiVpsi | false | 7,775 | [
"Apache-2.0"
] | 12 | c4e45d7736da6e6faabdc56bfc1336445df99204 | https://github.com/Bhaskers-Blu-Org1/SIC/tree/c4e45d7736da6e6faabdc56bfc1336445df99204 | import torch
import torch.utils.data
import torch.nn as nn
def add_layer(seq, ix, n_inputs, n_outputs, nonlin, normalization):
seq.add_module('L' + str(ix), nn.Linear(n_inputs, n_outputs))
if ix > 0 and normalization:
if normalization == 'LN':
seq.main.add_module('A' + str(ix), nn.LayerNor... |
Vgg16 | # 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 Vgg16(nn.Module):
def __init__(self):
super(Vgg16, self).__init__()
self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1... | 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 ... | AllenPu/mbdg | Vgg16 | false | 7,776 | [
"MIT"
] | 27 | 243f53a57dcf4bfb6e717c0c9f64a839cff8d548 | https://github.com/AllenPu/mbdg/tree/243f53a57dcf4bfb6e717c0c9f64a839cff8d548 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1... |
BaseFactorizationMachine | # 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 BaseFactorizationMachine(nn.Module):
"""Calculate FM result over the embeddings
Args:
reduce_sum: bool, whether to sum the result, default is True.
Input:
input_x: tensor, A 3D tensor with shape:``(batch_size,field_size,embed_dim)``.
Output
... | 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... | BELIEVEfxy/LightSANs | BaseFactorizationMachine | false | 7,777 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
"""Calculate FM result over the embeddings
Args:
reduce_sum: bool, whether to sum the result, default is True.
Input:
input_x: tensor, A 3D tensor with shape:``(batch_size,field_size,embed_dim)``.
Output
output: tens... |
AdjEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class AdjEncoder(nn.Module):
def __init__(self, featureSize, hiddenSize):
super(AdjEncoder, self).__init__()
self.left = nn.Linear(featureSize, hiddenSize)
self.right = nn.Linear(featureSize, hiddenSize, bias=False)
self.se... | 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... | BigkoalaZhu/SCORES | AdjEncoder | false | 7,778 | [
"MIT"
] | 16 | 8332733c375ee85c02bd34c2adce6a3213aad3c4 | https://github.com/BigkoalaZhu/SCORES/tree/8332733c375ee85c02bd34c2adce6a3213aad3c4 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, featureSize, hiddenSize):
super().__init__()
self.left = nn.Linear(featureSize, hiddenSize)
self.right = nn.Linear(featureSize, hiddenSize, bias=False)
self.second = nn.Linear(hidd... |
Binarizer | # 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 torch
import torch.nn as nn
import torch.nn.functional as F
class SignFunction(Function):
def __init__(self):
super(SignFunction, self).__init__()
@staticmethod
def forward(ctx, input, is_training=True):
if is_training:
prob = 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.triton_helpers import libdevice
from torch.autograd... | Biaze7/lossy-image-compression | Binarizer | false | 7,779 | [
"MIT"
] | 16 | 88ca2022a306fea52d6671593b314f0de3bf6010 | https://github.com/Biaze7/lossy-image-compression/tree/88ca2022a306fea52d6671593b314f0de3bf6010 | from torch.autograd import Function
import torch
import torch.nn as nn
import torch.nn.functional as F
class SignFunction(Function):
def __init__(self):
super().__init__()
@staticmethod
def forward(ctx, input, is_training=True):
if is_training:
prob = input.new(input.size()).... |
Perceptron | # 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 Perceptron(nn.Module):
"""Implements a 1-layer perceptron."""
def __init__(self, input_dimension, hidden_dimension, output_dimension):
super(Perceptron, self).__init__()
self._layer1 = nn.Linear(input_dimension, hidden_d... | 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_... | Bhaskers-Blu-Org2/PDP-Solver | Perceptron | false | 7,780 | [
"MIT"
] | 28 | 1fca34d81f36268288f46416fb6956e5b36df69e | https://github.com/Bhaskers-Blu-Org2/PDP-Solver/tree/1fca34d81f36268288f46416fb6956e5b36df69e | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Implements a 1-layer perceptron."""
def __init__(self, input_dimension, hidden_dimension, output_dimension):
super().__init__()
self._layer1 = nn.Linear(input_dimension, hidden_dimension)
sel... |
BoxEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class BoxEncoder(nn.Module):
def __init__(self, boxSize, featureSize, hiddenSize):
super(BoxEncoder, self).__init__()
self.encoder = nn.Linear(boxSize, featureSize)
self.middlein = nn.Linear(featureSize, hiddenSize)
self.mi... | 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... | BigkoalaZhu/SCORES | BoxEncoder | false | 7,781 | [
"MIT"
] | 16 | 8332733c375ee85c02bd34c2adce6a3213aad3c4 | https://github.com/BigkoalaZhu/SCORES/tree/8332733c375ee85c02bd34c2adce6a3213aad3c4 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, boxSize, featureSize, hiddenSize):
super().__init__()
self.encoder = nn.Linear(boxSize, featureSize)
self.middlein = nn.Linear(featureSize, hiddenSize)
self.middleout = nn.Linear(h... |
kAttentionPooling | # 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 kAttentionPooling(nn.Module):
def __init__(self, seq_len, hidden_size, k_heads=5):
super().__init__()
self.k_heads = k_heads
self.theta_k = nn.Parameter(torch.randn([hidden_size, k_heads]))
def forward(self, input_tensor):
attention_ma... | 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.... | BELIEVEfxy/LightSANs | kAttentionPooling | false | 7,782 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, seq_len, hidden_size, k_heads=5):
super().__init__()
self.k_heads = k_heads
self.theta_k = nn.Parameter(torch.randn([hidden_size, k_heads]))
def forward(self, input_tensor):
attention_matrix = torch... |
ThreeLayerCNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
class ThreeLayerCNN(torch.nn.Module):
"""
Input: 128x128 face image (eye aligned).
Output: 1-D tensor with 2 elements. Used for binary classification.
Parameters:
Number of conv layers: 3
Number of fully connected layers: 2
"""
def __init__... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
asser... | Bhaskers-Blu-Org1/Trusted-ML-Pipelines | ThreeLayerCNN | false | 7,783 | [
"Apache-2.0"
] | 13 | 3805a2e72f73cef318e1992eee70aeb319b06d1a | https://github.com/Bhaskers-Blu-Org1/Trusted-ML-Pipelines/tree/3805a2e72f73cef318e1992eee70aeb319b06d1a | import torch
import torch.utils.data
class Model(torch.nn.Module):
"""
Input: 128x128 face image (eye aligned).
Output: 1-D tensor with 2 elements. Used for binary classification.
Parameters:
Number of conv layers: 3
Number of fully connected layers: 2
"""
def __init__(self):
... |
AdjDecoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class AdjDecoder(nn.Module):
def __init__(self, featureSize, hiddenSize):
super(AdjDecoder, self).__init__()
self.decode = nn.Linear(featureSize, hiddenSize)
self.second = nn.Linear(hiddenSize, hiddenSize)
self.left = nn.Li... | 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... | BigkoalaZhu/SCORES | AdjDecoder | false | 7,784 | [
"MIT"
] | 16 | 8332733c375ee85c02bd34c2adce6a3213aad3c4 | https://github.com/BigkoalaZhu/SCORES/tree/8332733c375ee85c02bd34c2adce6a3213aad3c4 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, featureSize, hiddenSize):
super().__init__()
self.decode = nn.Linear(featureSize, hiddenSize)
self.second = nn.Linear(hiddenSize, hiddenSize)
self.left = nn.Linear(hiddenSize, feat... |
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
from torch import nn
class HardSwish(nn.Module):
def __init__(self, inplace=True):
super(HardSwish, self).__init__()
self.relu6 = nn.ReLU6(inplace=inplace)
def forward(self, x):
return x * self.relu6(x + 3) / 6
def get_inputs():
return [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
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | Bo396543018/Picodet_Pytorch | HardSwish | false | 7,785 | [
"Apache-2.0"
] | 16 | 276ecbf6f4f7eefbf046d1bccc25293acf28ba25 | https://github.com/Bo396543018/Picodet_Pytorch/tree/276ecbf6f4f7eefbf046d1bccc25293acf28ba25 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, inplace=True):
super().__init__()
self.relu6 = nn.ReLU6(inplace=inplace)
def forward(self, x):
return x * self.relu6(x + 3) / 6
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs... |
NormedLinear | # 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
class NormedLinear(nn.Linear):
"""Normalized Linear Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value ... | 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... | Bo396543018/mmdetection | NormedLinear | false | 7,786 | [
"Apache-2.0"
] | 16 | eb337336d3c239dc1d20534496f69df41ae9a300 | https://github.com/Bo396543018/mmdetection/tree/eb337336d3c239dc1d20534496f69df41ae9a300 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Linear):
"""Normalized Linear Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value of divi... |
NodeClassifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class NodeClassifier(nn.Module):
def __init__(self, featureSize, hiddenSize):
super(NodeClassifier, self).__init__()
self.first = nn.Linear(featureSize, hiddenSize)
self.tanh = nn.Tanh()
self.second = nn.Linear(hiddenSize, ... | 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... | BigkoalaZhu/SCORES | NodeClassifier | false | 7,787 | [
"MIT"
] | 16 | 8332733c375ee85c02bd34c2adce6a3213aad3c4 | https://github.com/BigkoalaZhu/SCORES/tree/8332733c375ee85c02bd34c2adce6a3213aad3c4 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, featureSize, hiddenSize):
super().__init__()
self.first = nn.Linear(featureSize, hiddenSize)
self.tanh = nn.Tanh()
self.second = nn.Linear(hiddenSize, 3)
self.softmax = nn.... |
CNNLayerNorm | # 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 CNNLayerNorm(nn.Module):
"""Layer normalization built for cnns input"""
def __init__(self, n_feats):
super(CNNLayerNorm, self).__init__()
self.layer_norm = nn.LayerNorm(n_feats)
def forward(self, x):
x = x.transpose(2, 3).contiguous()
... | 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_... | BlackyYen/Speech_Recognition-PyTorch | CNNLayerNorm | false | 7,788 | [
"MIT"
] | 16 | 0a986f467c540c2be88f65064ebf5ce0f6bcf70a | https://github.com/BlackyYen/Speech_Recognition-PyTorch/tree/0a986f467c540c2be88f65064ebf5ce0f6bcf70a | import torch
import torch.nn as nn
class Model(nn.Module):
"""Layer normalization built for cnns input"""
def __init__(self, n_feats):
super().__init__()
self.layer_norm = nn.LayerNorm(n_feats)
def forward(self, x):
x = x.transpose(2, 3).contiguous()
x = self.layer_norm(x... |
SymEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class SymEncoder(nn.Module):
def __init__(self, featureSize, symmetrySize, hiddenSize):
super(SymEncoder, self).__init__()
self.left = nn.Linear(featureSize, hiddenSize)
self.right = nn.Linear(symmetrySize, hiddenSize)
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
from torch import n... | BigkoalaZhu/SCORES | SymEncoder | false | 7,789 | [
"MIT"
] | 16 | 8332733c375ee85c02bd34c2adce6a3213aad3c4 | https://github.com/BigkoalaZhu/SCORES/tree/8332733c375ee85c02bd34c2adce6a3213aad3c4 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, featureSize, symmetrySize, hiddenSize):
super().__init__()
self.left = nn.Linear(featureSize, hiddenSize)
self.right = nn.Linear(symmetrySize, hiddenSize)
self.second = nn.Linear(h... |
D_concat | # 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
def add_layer(seq, ix, n_inputs, n_outputs, nonlin, normalization):
seq.add_module('L' + str(ix), nn.Linear(n_inputs, n_outputs))
if ix > 0 and normalization:
if normalization == 'LN':
seq.main.add_module('A' + str(ix), nn.LayerNor... | 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... | Bhaskers-Blu-Org1/SIC | D_concat | false | 7,790 | [
"Apache-2.0"
] | 12 | c4e45d7736da6e6faabdc56bfc1336445df99204 | https://github.com/Bhaskers-Blu-Org1/SIC/tree/c4e45d7736da6e6faabdc56bfc1336445df99204 | import torch
import torch.utils.data
import torch.nn as nn
def add_layer(seq, ix, n_inputs, n_outputs, nonlin, normalization):
seq.add_module('L' + str(ix), nn.Linear(n_inputs, n_outputs))
if ix > 0 and normalization:
if normalization == 'LN':
seq.main.add_module('A' + str(ix), nn.LayerNor... |
RSoftmax | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
from torch import nn
class RSoftmax(nn.Module):
"""Radix Softmax module in ``SplitAttentionConv2d``.
Args:
radix (int): Radix of input.
groups (int): Groups of input.
"""
def __init__(self, radix, groups):
super().__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | Bo396543018/Picodet_Pytorch | RSoftmax | false | 7,791 | [
"Apache-2.0"
] | 16 | 276ecbf6f4f7eefbf046d1bccc25293acf28ba25 | https://github.com/Bo396543018/Picodet_Pytorch/tree/276ecbf6f4f7eefbf046d1bccc25293acf28ba25 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""Radix Softmax module in ``SplitAttentionConv2d``.
Args:
radix (int): Radix of input.
groups (int): Groups of input.
"""
def __init__(self, radix, groups):
super().__init__()
s... |
PerceptronTanh | # 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 PerceptronTanh(nn.Module):
"""Implements a 1-layer perceptron with Tanh activaton."""
def __init__(self, input_dimension, hidden_dimension, output_dimension):
super(PerceptronTanh, self).__init__()
self._layer1 = nn.Line... | 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.... | Bhaskers-Blu-Org2/PDP-Solver | PerceptronTanh | false | 7,792 | [
"MIT"
] | 28 | 1fca34d81f36268288f46416fb6956e5b36df69e | https://github.com/Bhaskers-Blu-Org2/PDP-Solver/tree/1fca34d81f36268288f46416fb6956e5b36df69e | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Implements a 1-layer perceptron with Tanh activaton."""
def __init__(self, input_dimension, hidden_dimension, output_dimension):
super().__init__()
self._layer1 = nn.Linear(input_dimension, hidden_di... |
SymDecoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
class SymDecoder(nn.Module):
def __init__(self, featureSize, symmetrySize, hiddenSize):
super(SymDecoder, self).__init__()
self.decode = nn.Linear(featureSize, hiddenSize)
self.second = nn.Linear(hiddenSize, hiddenSize)
sel... | 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... | BigkoalaZhu/SCORES | SymDecoder | false | 7,793 | [
"MIT"
] | 16 | 8332733c375ee85c02bd34c2adce6a3213aad3c4 | https://github.com/BigkoalaZhu/SCORES/tree/8332733c375ee85c02bd34c2adce6a3213aad3c4 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, featureSize, symmetrySize, hiddenSize):
super().__init__()
self.decode = nn.Linear(featureSize, hiddenSize)
self.second = nn.Linear(hiddenSize, hiddenSize)
self.tanh = nn.Tanh()
... |
NormedConv2d | # 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 NormedConv2d(nn.Conv2d):
"""Normalized Conv2d Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value of divisor to
keep ... | 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... | Bo396543018/mmdetection | NormedConv2d | false | 7,794 | [
"Apache-2.0"
] | 16 | eb337336d3c239dc1d20534496f69df41ae9a300 | https://github.com/Bo396543018/mmdetection/tree/eb337336d3c239dc1d20534496f69df41ae9a300 | import torch
from torch import nn
class Model(nn.Conv2d):
"""Normalized Conv2d Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value of divisor to
keep numeric... |
GAT | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class GraphAttentionLayer(nn.Module):
"""
Simple GAT layer, similar to https://arxiv.org/abs/1710.10903
"""
def __init__(self, in_features, out_features, dropout, alpha, concat=True):
super(GraphAttentionLayer, self).__init__(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Anou9531/GUA | GAT | false | 7,795 | [
"MIT"
] | 20 | 354acceb69656e76fb4ee296c66ae42c18cd939f | https://github.com/Anou9531/GUA/tree/354acceb69656e76fb4ee296c66ae42c18cd939f | import torch
import torch.nn.functional as F
import torch.nn as nn
class GraphAttentionLayer(nn.Module):
"""
Simple GAT layer, similar to https://arxiv.org/abs/1710.10903
"""
def __init__(self, in_features, out_features, dropout, alpha, concat=True):
super().__init__()
self.dropout = ... |
PairwiseRankingLoss | # 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 PairwiseRankingLoss(nn.Module):
"""
Pairwise ranking loss
"""
def __init__(self, margin):
super(PairwiseRankingLoss, self).__init__()
self.margin = margin
def forward(self, anchor1, anchor2, img_sentc, sent_imgc):
cost_sent = torch... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | BinWang28/EvalRank-Embedding-Evaluation | PairwiseRankingLoss | false | 7,796 | [
"BSD-3-Clause"
] | 15 | 454dac5c7345f01993688f33375f637129c285e3 | https://github.com/BinWang28/EvalRank-Embedding-Evaluation/tree/454dac5c7345f01993688f33375f637129c285e3 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Pairwise ranking loss
"""
def __init__(self, margin):
super().__init__()
self.margin = margin
def forward(self, anchor1, anchor2, img_sentc, sent_imgc):
cost_sent = torch.clamp(self.margin - anchor1 + img_sent... |
ZeroConv2d | # 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 ZeroConv2d(nn.Module):
def __init__(self, in_channel, out_channel, padding=1):
super().__init__()
self.in_channel = in_channel
self.conv = nn.Conv2d(in_channel, out_channel, [1, 1], padding=0)
self.conv.weight.data.zero_()
self.conv... | 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 torch.... | BinWang28/EvalRank-Embedding-Evaluation | ZeroConv2d | false | 7,797 | [
"BSD-3-Clause"
] | 15 | 454dac5c7345f01993688f33375f637129c285e3 | https://github.com/BinWang28/EvalRank-Embedding-Evaluation/tree/454dac5c7345f01993688f33375f637129c285e3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channel, out_channel, padding=1):
super().__init__()
self.in_channel = in_channel
self.conv = nn.Conv2d(in_channel, out_channel, [1, 1], padding=0)
self.conv.weight.data.zero_()
self.conv.bias... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.optim
class DiceLoss(nn.Module):
def __init__(self, smooth=1.0):
super(DiceLoss, self).__init__()
self.smooth = smooth
def _dice_coeff(self, pred, target):
"""
Args:
pred: [N, 1] within [0, 1]
target: [N,... | 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.optim
assert_size_stride = torch._C._dynamo.guards.ass... | Bobholamovic/SimpleCV | DiceLoss | false | 7,798 | [
"MIT"
] | 44 | f4edacf088d0155725a469e227de847820bdfa53 | https://github.com/Bobholamovic/SimpleCV/tree/f4edacf088d0155725a469e227de847820bdfa53 | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
def __init__(self, smooth=1.0):
super().__init__()
self.smooth = smooth
def _dice_coeff(self, pred, target):
"""
Args:
pred: [N, 1] within [0, 1]
target: [N, 1]
Retur... |
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
class ResidualBlock(nn.Sequential):
def __init__(self, *args):
super(ResidualBlock, self).__init__(*args)
def forward(self, x):
identity = x
x = super(ResidualBlock, self).forward(x)
x += identity
return x
def get_inputs():
ret... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@triton.jit
def triton_poi_fused_add_0(in_ptr0, out_... | Bobholamovic/ever | ResidualBlock | false | 7,799 | [
"Apache-2.0"
] | 22 | f38060674a40ed53072b9d9be99cc656a830398f | https://github.com/Bobholamovic/ever/tree/f38060674a40ed53072b9d9be99cc656a830398f | import torch
import torch.nn as nn
class Model(nn.Sequential):
def __init__(self, *args):
super().__init__(*args)
def forward(self, x):
identity = x
x = super(ResidualBlock, self).forward(x)
x += identity
return x
def get_inputs():
return [torch.rand([4, 4, 4, 4... |
GlobalAvgPool2DBaseline | # 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.optim
class GlobalAvgPool2DBaseline(nn.Module):
def __init__(self):
super(GlobalAvgPool2DBaseline, self).__init__()
def forward(self, x):
x_pool = torch.mean(x.view(x.size(0), x.size(1), x.size(2) * x.size
(3)), dim=2)
x_poo... | 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
import torch.optim
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dyna... | Bobholamovic/SimpleCV | GlobalAvgPool2DBaseline | false | 7,800 | [
"MIT"
] | 44 | f4edacf088d0155725a469e227de847820bdfa53 | https://github.com/Bobholamovic/SimpleCV/tree/f4edacf088d0155725a469e227de847820bdfa53 | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
x_pool = torch.mean(x.view(x.size(0), x.size(1), x.size(2) * x.size
(3)), dim=2)
x_pool = x_pool.view(x.size(0), x.size(1), 1, 1).con... |
LinkClassifier | # 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 LinkClassifier(nn.Module):
def __init__(self, in_features, dropout=0.2):
super(LinkClassifier, self).__init__()
self.input = nn.Linear(in_features, 32)
self.hidden1 = nn.Linear(32, 16)
self.hidden2 = nn.Linea... | 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.... | BlackReap-er/Sia | LinkClassifier | false | 7,801 | [
"MIT"
] | 13 | 70654d55caa3315187282c88a59cf9b6e0b7c52b | https://github.com/BlackReap-er/Sia/tree/70654d55caa3315187282c88a59cf9b6e0b7c52b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_features, dropout=0.2):
super().__init__()
self.input = nn.Linear(in_features, 32)
self.hidden1 = nn.Linear(32, 16)
self.hidden2 = nn.Linear(16, 8)
self.output ... |
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 math
import torch
import torch.nn as nn
class MultiHeadAttention(nn.Module):
"""
Multi-head Self-attention layers, a attention score dropout layer is introduced.
Args:
input_tensor (torch.Tensor): the input of the multi-head self-attention layer
attention_mask (torch.Tensor): the a... | 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.... | BELIEVEfxy/LightSANs | MultiHeadAttention | false | 7,802 | [
"MIT"
] | 17 | 94ce7e59d144dbc787153b8c486cad334790ec6e | https://github.com/BELIEVEfxy/LightSANs/tree/94ce7e59d144dbc787153b8c486cad334790ec6e | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""
Multi-head Self-attention layers, a attention score dropout layer is introduced.
Args:
input_tensor (torch.Tensor): the input of the multi-head self-attention layer
attention_mask (torch.Tensor): the attention mask... |
DiceWithLogitsLoss | # 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.optim
class DiceWithLogitsLoss(nn.Module):
def __init__(self, smooth=1.0):
super(DiceWithLogitsLoss, self).__init__()
self.smooth = smooth
def _dice_coeff(self, pred, target):
"""
Args:
pred: [N, 1] within [0, 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 import triton_helpers
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._dynamo.guards.ass... | Bobholamovic/SimpleCV | DiceWithLogitsLoss | false | 7,803 | [
"MIT"
] | 44 | f4edacf088d0155725a469e227de847820bdfa53 | https://github.com/Bobholamovic/SimpleCV/tree/f4edacf088d0155725a469e227de847820bdfa53 | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
def __init__(self, smooth=1.0):
super().__init__()
self.smooth = smooth
def _dice_coeff(self, pred, target):
"""
Args:
pred: [N, 1] within [0, 1]
target: [N, 1]
Retur... |
SigmoidRange | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
def sigmoid_range(x, low, high):
"""Sigmoid function with range `(low, high)`"""
return torch.sigmoid(x) * (high - low) + low
class SigmoidRange(torch.nn.Module):
"""Sigmoid module with range `(low, x_max)`"""
def __init__(self, low, high):
super(SigmoidRange, self).__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | BojarLab/glycowork | SigmoidRange | false | 7,804 | [
"MIT"
] | 22 | 72d37d406ad70bb9def4a5632a6605778e295fbb | https://github.com/BojarLab/glycowork/tree/72d37d406ad70bb9def4a5632a6605778e295fbb | import torch
def sigmoid_range(x, low, high):
"""Sigmoid function with range `(low, high)`"""
return torch.sigmoid(x) * (high - low) + low
class Model(torch.nn.Module):
"""Sigmoid module with range `(low, x_max)`"""
def __init__(self, low, high):
super().__init__()
self.low, self.hi... |
SCS_Cell | # 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 random
import torch
import torch.nn.init
from torch import nn
from torch.autograd import Variable
import torch.utils.data
class SCS_Cell(nn.Module):
def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias,
p_TD):
super(SCS_Cell, self).__init__()
self.height, self.wi... | 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.ini... | BoPang1996/Semi-Coupled-Structure-for-visual-sequental-tasks | SCS_Cell | false | 7,805 | [
"Apache-2.0"
] | 13 | c6fe7c77d08928bb30cc8683123f978b0e877394 | https://github.com/BoPang1996/Semi-Coupled-Structure-for-visual-sequental-tasks/tree/c6fe7c77d08928bb30cc8683123f978b0e877394 | import random
import torch
import torch.nn.init
from torch import nn
from torch.autograd import Variable
import torch.utils.data
class Model(nn.Module):
def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias,
p_TD):
super().__init__()
self.height, self.width = input_size
... |
RelativeL1 | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch.jit
class RelativeL1(nn.Module):
def __init__(self):
super().__init__()
self.criterion = torch.nn.L1Loss()
def forward(self, input, target):
base = target + 0.01
return self.criterion(input / base, 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
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.dat... | BlueAmulet/BasicSR | RelativeL1 | false | 7,806 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.jit
class Model(nn.Module):
def __init__(self):
super().__init__()
self.criterion = torch.nn.L1Loss()
def forward(self, input, target):
base = target + 0.01
return self.criterion(input / base, target / bas... |
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
import torch.nn as nn
import torch.nn.functional as F
class ScaledDotProductAttention(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropo... | 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.... | BlackNoodle/TUCORE-GCN | ScaledDotProductAttention | false | 7,807 | [
"MIT"
] | 27 | 16fb37d81c5b1182a31fcf7da08a9c0013b20cd6 | https://github.com/BlackNoodle/TUCORE-GCN/tree/16fb37d81c5b1182a31fcf7da08a9c0013b20cd6 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)
def forward... |
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
class ScaledDotProductAttention(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropo... | 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.... | BlackNoodle/TUCORE-GCN | MultiHeadAttention | false | 7,808 | [
"MIT"
] | 27 | 16fb37d81c5b1182a31fcf7da08a9c0013b20cd6 | https://github.com/BlackNoodle/TUCORE-GCN/tree/16fb37d81c5b1182a31fcf7da08a9c0013b20cd6 | import torch
import torch.nn as nn
import torch.nn.functional as F
class ScaledDotProductAttention(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropo... |
Classifier | # 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.distributed
import torch
import torch.nn as nn
class Classifier(nn.Module):
def __init__(self, hidden_size):
super(Classifier, self).__init__()
self.linear1 = nn.Linear(hidden_size, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x, mask_cls):
h = 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
import torch.distributed
import torch
import torch.nn as nn
assert_size_stride =... | BoonthichaSaejia/ThaiSum | Classifier | false | 7,809 | [
"Apache-2.0"
] | 23 | fdb99eab23e60a933acf4e84836f53ddf05b7c8b | https://github.com/BoonthichaSaejia/ThaiSum/tree/fdb99eab23e60a933acf4e84836f53ddf05b7c8b | import torch
import torch.distributed
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.linear1 = nn.Linear(hidden_size, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x, mask_cls):
h = self.linear1(x).squeez... |
Get_gradient_nopadding | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch.nn.functional as F
import torch.jit
class Get_gradient_nopadding(nn.Module):
def __init__(self):
super(Get_gradient_nopadding, self).__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, ... | 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.utils.... | BlueAmulet/BasicSR | Get_gradient_nopadding | false | 7,811 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.nn.functional as F
import torch.jit
class Model(nn.Module):
def __init__(self):
super().__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1], [0, 0, 0]]
kernel_h = torch.Fl... |
Quantinizer | # 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 Quantinizer(torch.nn.Module):
def __init__(self, size):
super(Quantinizer, self).__init__()
self.size = size
def forward(self, x):
x = (x * self.size * 0.999).long()
return torch.nn.functional.one_hot(x, num_classes=self.size).float()
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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | CODEJIN/SPEECHSPLIT | Quantinizer | false | 7,812 | [
"MIT"
] | 13 | b4201ca9822b2e73f98f60c160c00db3b49a0050 | https://github.com/CODEJIN/SPEECHSPLIT/tree/b4201ca9822b2e73f98f60c160c00db3b49a0050 | import torch
class Model(torch.nn.Module):
def __init__(self, size):
super().__init__()
self.size = size
def forward(self, x):
x = (x * self.size * 0.999).long()
return torch.nn.functional.one_hot(x, num_classes=self.size).float()
def get_inputs():
return [torch.rand([4... |
CharbonnierLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch.jit
class CharbonnierLoss(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=1e-06):
super(CharbonnierLoss, self).__init__()
self.eps = eps
def forward(self, x, y):
b, c, h, w = y.size()
di... | 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.utils.data
from... | BlueAmulet/BasicSR | CharbonnierLoss | false | 7,813 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.jit
class Model(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=1e-06):
super().__init__()
self.eps = eps
def forward(self, x, y):
b, c, h, w = y.size()
diff = x - y
loss = torch... |
SpatialCrossMapLRN | # 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.dataloader
import torch.utils.data
import torch.backends.cudnn
import torch.autograd
import torch.nn
class SpatialCrossMapLRN(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, k=1,
ACROSS_CHANNELS=True):
super(SpatialCros... | 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.utils.data.dataloader
import torch.utils.dat... | CASIA-IVA-Lab/DCFST | SpatialCrossMapLRN | false | 7,814 | [
"Apache-2.0"
] | 22 | ca881ba3aae1ce00e4a7a6db01d99e5f6efff68b | https://github.com/CASIA-IVA-Lab/DCFST/tree/ca881ba3aae1ce00e4a7a6db01d99e5f6efff68b | import torch
import torch.nn as nn
import torch.utils.data.dataloader
import torch.utils.data
import torch.backends.cudnn
import torch.autograd
import torch.nn
class Model(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, k=1,
ACROSS_CHANNELS=True):
super().__init__()
sel... |
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 math
import torch
import torch.distributed
import torch
import torch.nn as nn
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class PositionwiseFeedForward(nn.Module):
""" A two-layer Feed-Forward-Network with residual layer norm.
... | 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 ... | BoonthichaSaejia/ThaiSum | PositionwiseFeedForward | false | 7,815 | [
"Apache-2.0"
] | 23 | fdb99eab23e60a933acf4e84836f53ddf05b7c8b | https://github.com/BoonthichaSaejia/ThaiSum/tree/fdb99eab23e60a933acf4e84836f53ddf05b7c8b | import math
import torch
import torch.distributed
import torch
import torch.nn as nn
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class Model(nn.Module):
""" A two-layer Feed-Forward-Network with residual layer norm.
Args:
d_m... |
L1CosineSim | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch.jit
class L1CosineSim(nn.Module):
def __init__(self, loss_lambda=5):
super(L1CosineSim, self).__init__()
self.similarity = torch.nn.CosineSimilarity(dim=1, eps=1e-20)
self.l1_loss = nn.L1Loss()
self.loss_lambda... | 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... | BlueAmulet/BasicSR | L1CosineSim | false | 7,816 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.jit
class Model(nn.Module):
def __init__(self, loss_lambda=5):
super().__init__()
self.similarity = torch.nn.CosineSimilarity(dim=1, eps=1e-20)
self.l1_loss = nn.L1Loss()
self.loss_lambda = loss_lambda
def... |
statm_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.nn as nn
class statm_loss(nn.Module):
def __init__(self, eps=2):
super(statm_loss, self).__init__()
self.eps = eps
def forward(self, x, y):
x = x.view(x.size(0), x.size(1), -1)
y = y.view(y.size(0), y.size(1), -1)
x_mean = x.mean(dim=2)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | COMP6248-Reproducability-Challenge/KD_SRRL | statm_loss | false | 7,817 | [
"MIT"
] | 27 | 958c8f9fbeb7893f9bd866aff5b065b2bde87f23 | https://github.com/COMP6248-Reproducability-Challenge/KD_SRRL/tree/958c8f9fbeb7893f9bd866aff5b065b2bde87f23 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps=2):
super().__init__()
self.eps = eps
def forward(self, x, y):
x = x.view(x.size(0), x.size(1), -1)
y = y.view(y.size(0), y.size(1), -1)
x_mean = x.mean(dim=2)
y_mean = y.mean(di... |
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.nn as nn
class mfm(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1, type=1):
super(mfm, self).__init__()
self.out_channels = out_channels
if type == 1:
self.filter = nn.Conv2d(in_channels, 2 * out_c... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | BradyFU/DVG-Face | resblock | false | 7,818 | [
"MIT"
] | 33 | 16d51fe7da6e4a52d144e938afb3072eb8e4e8de | https://github.com/BradyFU/DVG-Face/tree/16d51fe7da6e4a52d144e938afb3072eb8e4e8de | import torch
import torch.nn as nn
class mfm(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1, type=1):
super().__init__()
self.out_channels = out_channels
if type == 1:
self.filter = nn.Conv2d(in_channels, 2 * out_channels,
... |
group | # 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 mfm(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1, type=1):
super(mfm, self).__init__()
self.out_channels = out_channels
if type == 1:
self.filter = nn.Conv2d(in_channels, 2 * out_c... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | BradyFU/DVG-Face | group | false | 7,819 | [
"MIT"
] | 33 | 16d51fe7da6e4a52d144e938afb3072eb8e4e8de | https://github.com/BradyFU/DVG-Face/tree/16d51fe7da6e4a52d144e938afb3072eb8e4e8de | import torch
import torch.nn as nn
class mfm(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1, type=1):
super().__init__()
self.out_channels = out_channels
if type == 1:
self.filter = nn.Conv2d(in_channels, 2 * out_channels,
... |
biLinearModel | # 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.distributed
import torch
import torch.nn as nn
class biLinearModel(nn.Module):
"""Currently just for a pair"""
def __init__(self, hidden_size):
super(biLinearModel, self).__init__()
self.bilinear = nn.Bilinear(hidden_size, hidden_size, 1)
def forward(self, doc_e... | 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.distributed
import torch
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cu... | BoonthichaSaejia/ThaiSum | biLinearModel | false | 7,820 | [
"Apache-2.0"
] | 23 | fdb99eab23e60a933acf4e84836f53ddf05b7c8b | https://github.com/BoonthichaSaejia/ThaiSum/tree/fdb99eab23e60a933acf4e84836f53ddf05b7c8b | import torch
import torch.distributed
import torch
import torch.nn as nn
class Model(nn.Module):
"""Currently just for a pair"""
def __init__(self, hidden_size):
super().__init__()
self.bilinear = nn.Bilinear(hidden_size, hidden_size, 1)
def forward(self, doc_emb, group_embs, candi_sent_... |
FiLM | # 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 FiLM(nn.Module):
def __init__(self, zdim, maskdim):
super(FiLM, self).__init__()
self.gamma = nn.Linear(zdim, maskdim)
self.beta = nn.Linear(zdim, maskdim)
def forward(self, x, z):
gamma = self.gamma(z).unsqueeze(-1).unsqueeze(-1)
... | 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... | CPJKU/audio_conditioned_unet | FiLM | false | 7,821 | [
"MIT"
] | 20 | 68f20f5280079e99be260f9fe9933c0064eb2d7f | https://github.com/CPJKU/audio_conditioned_unet/tree/68f20f5280079e99be260f9fe9933c0064eb2d7f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, zdim, maskdim):
super().__init__()
self.gamma = nn.Linear(zdim, maskdim)
self.beta = nn.Linear(zdim, maskdim)
def forward(self, x, z):
gamma = self.gamma(z).unsqueeze(-1).unsqueeze(-1)
beta ... |
Swish | # 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
from torch import nn
import torch.jit
def swish_func(x, beta=1.0):
"""
"Swish: a Self-Gated Activation Function"
Searching for Activation Functions (https://arxiv.org/abs/1710.05941)
If beta=1 applies the Sigmoid Linear Unit (SiLU) function element-wise
If... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
from torch import nn
import torch.jit
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_... | BlueAmulet/BasicSR | Swish | false | 7,822 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.jit
def swish_func(x, beta=1.0):
"""
"Swish: a Self-Gated Activation Function"
Searching for Activation Functions (https://arxiv.org/abs/1710.05941)
If beta=1 applies the Sigmoid Linear Unit (SiLU) function element-wise
If... |
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
from torch import nn
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
def norm(dim):
return nn.GroupNorm(min(32, dim), dim)
class ResBlock(nn.Module):
e... | 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.... | BoyanJIANG/4D-Compositional-Representation | ResBlock | false | 7,823 | [
"Apache-2.0"
] | 12 | 64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | https://github.com/BoyanJIANG/4D-Compositional-Representation/tree/64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | import torch
from torch import nn
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
def norm(dim):
return nn.GroupNorm(min(32, dim), dim)
class Model(nn.Module):
expa... |
convblock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class AdaptiveInstanceNorm2d(nn.Module):
def __init__(self, num_features, eps=1e-05, momentum=0.1):
super(AdaptiveInstanceNorm2d, self).__init__()
self.num_features = num_features
self.eps = eps
self.momentum = mom... | 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 ... | BradyFU/DVG-Face | convblock | false | 7,824 | [
"MIT"
] | 33 | 16d51fe7da6e4a52d144e938afb3072eb8e4e8de | https://github.com/BradyFU/DVG-Face/tree/16d51fe7da6e4a52d144e938afb3072eb8e4e8de | import torch
import torch.nn as nn
import torch.nn.functional as F
class AdaptiveInstanceNorm2d(nn.Module):
def __init__(self, num_features, eps=1e-05, momentum=0.1):
super().__init__()
self.num_features = num_features
self.eps = eps
self.momentum = momentum
self.weight = ... |
SirenLayer | # 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 numpy as np
import torch.nn as nn
class SirenLayer(nn.Module):
def __init__(self, in_f, out_f, w0=30, is_first=False, is_last=False):
super().__init__()
self.in_f = in_f
self.w0 = w0
self.linear = nn.Linear(in_f, out_f)
self.is_first = is_first
... | 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 ... | BoyuanChen/neural-state-variables | SirenLayer | false | 7,825 | [
"MIT"
] | 17 | 10483d93ac8c006f3786c434fb57d70d9ab465ec | https://github.com/BoyuanChen/neural-state-variables/tree/10483d93ac8c006f3786c434fb57d70d9ab465ec | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_f, out_f, w0=30, is_first=False, is_last=False):
super().__init__()
self.in_f = in_f
self.w0 = w0
self.linear = nn.Linear(in_f, out_f)
self.is_first = is_first
self.... |
ConstantODE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class ConstantODE(torch.nn.Module):
def __init__(self, device):
super(ConstantODE, self).__init__()
self.a = torch.nn.Parameter(torch.tensor(0.2))
self.b = torch.nn.Parameter(torch.tensor(3.0))
def forward(self, t, y):
return self.a + (y - (self.a * t + 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | BoyanJIANG/4D-Compositional-Representation | ConstantODE | false | 7,826 | [
"Apache-2.0"
] | 12 | 64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | https://github.com/BoyanJIANG/4D-Compositional-Representation/tree/64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | import torch
class Model(torch.nn.Module):
def __init__(self, device):
super().__init__()
self.a = torch.nn.Parameter(torch.tensor(0.2))
self.b = torch.nn.Parameter(torch.tensor(3.0))
def forward(self, t, y):
return self.a + (y - (self.a * t + self.b)) ** 5
def y_exact(s... |
LatentPredModel | # 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 LatentPredModel(torch.nn.Module):
def __init__(self, in_channels):
super(LatentPredModel, self).__init__()
self.layer1 = nn.Linear(in_channels, 32)
self.relu1 = nn.ReLU()
self.layer2 = nn.Linear(32, 64)
self.relu2 = nn.ReLU()
... | 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_... | BoyuanChen/neural-state-variables | LatentPredModel | false | 7,827 | [
"MIT"
] | 17 | 10483d93ac8c006f3786c434fb57d70d9ab465ec | https://github.com/BoyuanChen/neural-state-variables/tree/10483d93ac8c006f3786c434fb57d70d9ab465ec | import torch
import torch.nn as nn
class Model(torch.nn.Module):
def __init__(self, in_channels):
super().__init__()
self.layer1 = nn.Linear(in_channels, 32)
self.relu1 = nn.ReLU()
self.layer2 = nn.Linear(32, 64)
self.relu2 = nn.ReLU()
self.layer3 = nn.Linear(64, 6... |
GatedConv2d | # 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
import torch.utils
import torch.distributions
class GatedConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride,
padding, dilation=1):
super(GatedConv2d, self).__init__()
self.conv = nn.Co... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.utils
import torch.distributions
assert_size_s... | Butters-cloud/denoising-normalizing-flow | GatedConv2d | false | 7,828 | [
"MIT"
] | 12 | 12d56a0d069e10a744acabf5e78fdbfba8df54ee | https://github.com/Butters-cloud/denoising-normalizing-flow/tree/12d56a0d069e10a744acabf5e78fdbfba8df54ee | import torch
from torch import nn
from torch.nn import functional as F
import torch.utils
import torch.distributions
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride,
padding, dilation=1):
super().__init__()
self.conv = nn.Conv2d(in_channels, 2 * o... |
GlobalAttention | # 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.distributed
import torch
import torch.nn as nn
import torch.nn.functional as F
def sequence_mask(lengths, max_len=None):
"""
Creates a boolean mask from sequence lengths.
"""
batch_size = lengths.numel()
max_len = max_len or lengths.max()
return torch.arange(0, max_le... | 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.... | BoonthichaSaejia/ThaiSum | GlobalAttention | false | 7,829 | [
"Apache-2.0"
] | 23 | fdb99eab23e60a933acf4e84836f53ddf05b7c8b | https://github.com/BoonthichaSaejia/ThaiSum/tree/fdb99eab23e60a933acf4e84836f53ddf05b7c8b | import torch
import torch.distributed
import torch
import torch.nn as nn
import torch.nn.functional as F
def sequence_mask(lengths, max_len=None):
"""
Creates a boolean mask from sequence lengths.
"""
batch_size = lengths.numel()
max_len = max_len or lengths.max()
return torch.arange(0, max_le... |
Swish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class Swish(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.sigmoid(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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | CW-Huang/sdeflow-light | Swish | false | 7,830 | [
"MIT"
] | 35 | 524650bc5ad69522b3e0905672deef0650374512 | https://github.com/CW-Huang/sdeflow-light/tree/524650bc5ad69522b3e0905672deef0650374512 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.sigmoid(x) * x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
mfm | # 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 mfm(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1, type=1):
super(mfm, self).__init__()
self.out_channels = out_channels
if type == 1:
self.filter = nn.Conv2d(in_channels, 2 * out_c... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | BradyFU/DVG-Face | mfm | false | 7,831 | [
"MIT"
] | 33 | 16d51fe7da6e4a52d144e938afb3072eb8e4e8de | https://github.com/BradyFU/DVG-Face/tree/16d51fe7da6e4a52d144e938afb3072eb8e4e8de | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=1, type=1):
super().__init__()
self.out_channels = out_channels
if type == 1:
self.filter = nn.Conv2d(in_channels, 2 * out_channels... |
LinearDiag | # 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 LinearDiag(nn.Module):
def __init__(self, num_features, bias=False):
super(LinearDiag, self).__init__()
weight = torch.FloatTensor(num_features).fill_(1)
self.weight = nn.Parameter(weight, requires_grad=True)
if bias:
bias = tor... | 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... | CSer-Tang-hao/FS-KTN | LinearDiag | false | 7,832 | [
"MIT"
] | 19 | 8e5b1637e0f86f9d29dad7ff740a9c7a4a292a74 | https://github.com/CSer-Tang-hao/FS-KTN/tree/8e5b1637e0f86f9d29dad7ff740a9c7a4a292a74 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_features, bias=False):
super().__init__()
weight = torch.FloatTensor(num_features).fill_(1)
self.weight = nn.Parameter(weight, requires_grad=True)
if bias:
bias = torch.FloatTensor(num_fe... |
GaussianFilter | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch.jit
class GaussianFilter(nn.Module):
def __init__(self, kernel_size=13, stride=1, padding=6):
super(GaussianFilter, self).__init__()
mean = (kernel_size - 1) / 2.0
variance = ((kernel_size - 1) / 6.0) ** 2.0
x_... | 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
from torch import nn
import torch.jit
assert_size_stride... | BlueAmulet/BasicSR | GaussianFilter | false | 7,833 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.jit
class Model(nn.Module):
def __init__(self, kernel_size=13, stride=1, padding=6):
super().__init__()
mean = (kernel_size - 1) / 2.0
variance = ((kernel_size - 1) / 6.0) ** 2.0
x_coord = torch.arange(kernel_s... |
Get_gradient | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch.nn.functional as F
import torch.jit
class Get_gradient(nn.Module):
def __init__(self):
super(Get_gradient, self).__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1], [0, 0, 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
import torch.utils.... | BlueAmulet/BasicSR | Get_gradient | false | 7,834 | [
"Apache-2.0"
] | 12 | 7040913d8659a05af4c2428feb71c260efbf1e9c | https://github.com/BlueAmulet/BasicSR/tree/7040913d8659a05af4c2428feb71c260efbf1e9c | import torch
import torch.utils.data
from torch import nn
import torch.nn.functional as F
import torch.jit
class Model(nn.Module):
def __init__(self):
super().__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1], [0, 0, 0]]
kernel_h = torch.Fl... |
GAP | # 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 GAP(nn.Module):
def __init__(self, dimension=1):
"""
:param dimension:
"""
super(GAP, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
def forward(self, x):
"""
:param 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
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | CaptainEven/MCMOT-ByteTrack | GAP | false | 7,835 | [
"MIT"
] | 20 | e014275cfb25147dfa6f49cdbed24e91e5d6c41e | https://github.com/CaptainEven/MCMOT-ByteTrack/tree/e014275cfb25147dfa6f49cdbed24e91e5d6c41e | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, dimension=1):
"""
:param dimension:
"""
super().__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
def forward(self, x):
"""
:param x:
:return... |
ODEfunc | # 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
def norm(dim):
return nn.GroupNorm(min(32, dim), dim)
class ConcatConv2d(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False):
super(ConcatConv2d, self).__init__()
module = 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 import triton_helpers
from torch._inductor.runtime.... | BoyanJIANG/4D-Compositional-Representation | ODEfunc | false | 7,836 | [
"Apache-2.0"
] | 12 | 64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | https://github.com/BoyanJIANG/4D-Compositional-Representation/tree/64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | import torch
from torch import nn
def norm(dim):
return nn.GroupNorm(min(32, dim), dim)
class ConcatConv2d(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False):
super().__init__()
module = nn.ConvTranspose2d ... |
WeightedFeatureFusion | # 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 WeightedFeatureFusion(nn.Module):
def __init__(self, layers, weight=False):
"""
:param layers:
:param weight:
"""
super(WeightedFeatureFusion, self).__init__()
self.layers = layers
self.weight... | 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
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | CaptainEven/MCMOT-ByteTrack | WeightedFeatureFusion | false | 7,837 | [
"MIT"
] | 20 | e014275cfb25147dfa6f49cdbed24e91e5d6c41e | https://github.com/CaptainEven/MCMOT-ByteTrack/tree/e014275cfb25147dfa6f49cdbed24e91e5d6c41e | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, layers, weight=False):
"""
:param layers:
:param weight:
"""
super().__init__()
self.layers = layers
self.weight = weight
self.n = len(layers) + 1
... |
ResnetBlockFC | # 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 ResnetBlockFC(nn.Module):
""" Fully connected ResNet Block class.
Args:
size_in (int): input dimension
size_out (int): output dimension
size_h (int): hidden dimension
"""
def __init__(self, size_in, size_out=None, size_h=None):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | BoyanJIANG/4D-Compositional-Representation | ResnetBlockFC | false | 7,838 | [
"Apache-2.0"
] | 12 | 64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | https://github.com/BoyanJIANG/4D-Compositional-Representation/tree/64d5f4bbd6b8e6bc3bfd8f76736f6d468c71a73c | import torch
from torch import nn
class Model(nn.Module):
""" Fully connected ResNet Block class.
Args:
size_in (int): input dimension
size_out (int): output dimension
size_h (int): hidden dimension
"""
def __init__(self, size_in, size_out=None, size_h=None):
super().... |
simple_decoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils
import torch.distributions
class simple_decoder(nn.Module):
def __init__(self, channels, width, height, dropout):
super(simple_decoder, self).__init__()
self.width = width
self.height = height
self.channels = channels
se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.utils
import torch.distributions
assert_size_s... | Butters-cloud/denoising-normalizing-flow | simple_decoder | false | 7,839 | [
"MIT"
] | 12 | 12d56a0d069e10a744acabf5e78fdbfba8df54ee | https://github.com/Butters-cloud/denoising-normalizing-flow/tree/12d56a0d069e10a744acabf5e78fdbfba8df54ee | import torch
from torch import nn
import torch.utils
import torch.distributions
class Model(nn.Module):
def __init__(self, channels, width, height, dropout):
super().__init__()
self.width = width
self.height = height
self.channels = channels
self.dec_conv = nn.Conv2d(in_ch... |
Reorg | # 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 Reorg(nn.Module):
def __init__(self, stride=2):
super(Reorg, self).__init__()
self.stride = stride
def forward(self, x):
assert x.data.dim() == 4
B = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.da... | 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... | CharlesPikachu/CharlesFace | Reorg | false | 7,840 | [
"MIT"
] | 13 | 90bfe38c58068228d0069dce43b55b2570acaa16 | https://github.com/CharlesPikachu/CharlesFace/tree/90bfe38c58068228d0069dce43b55b2570acaa16 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, stride=2):
super().__init__()
self.stride = stride
def forward(self, x):
assert x.data.dim() == 4
B = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.data.size(3)
... |
ContrastiveLoss | # 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 ContrastiveLoss(nn.Module):
"""
Contrastive loss function. ref: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super(ContrastiveLoss, self).__init__()
se... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_... | CV-ZMH/human-action-recognition | ContrastiveLoss | false | 7,841 | [
"MIT"
] | 36 | 009bd1da71c087c3071173b325e34ed342599581 | https://github.com/CV-ZMH/human-action-recognition/tree/009bd1da71c087c3071173b325e34ed342599581 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
Contrastive loss function. ref: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super().__init__()
self.margin = margin
self... |
Upsample | # 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 Upsample(nn.Module):
def __init__(self, stride=2):
super(Upsample, self).__init__()
self.stride = stride
def forward(self, x):
assert x.data.dim() == 4
B = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W ... | 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... | CharlesPikachu/CharlesFace | Upsample | false | 7,842 | [
"MIT"
] | 13 | 90bfe38c58068228d0069dce43b55b2570acaa16 | https://github.com/CharlesPikachu/CharlesFace/tree/90bfe38c58068228d0069dce43b55b2570acaa16 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, stride=2):
super().__init__()
self.stride = stride
def forward(self, x):
assert x.data.dim() == 4
B = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.data.size(3)
... |
softmax_SR | # 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 softmax_SR(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
sr = F.softmax(x.reshape(x.size(0), x.size(1), -1), dim=2)
sr = sr.transpose(1, 2)
return sr
def get_inputs():
re... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | CILAB-MA/Machine_ToM | softmax_SR | false | 7,843 | [
"MIT"
] | 13 | 8c168ee31cc95a7f57998e8907273799533fe04f | https://github.com/CILAB-MA/Machine_ToM/tree/8c168ee31cc95a7f57998e8907273799533fe04f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
sr = F.softmax(x.reshape(x.size(0), x.size(1), -1), dim=2)
sr = sr.transpose(1, 2)
return sr
def get_inputs():
return ... |
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.functional as F
from torch import nn
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.... | ChansongJo/DAMD | Attn | false | 7,844 | [
"Apache-2.0"
] | 39 | 9b0456d7e590fb5de77ec81e967e8010487eeb56 | https://github.com/ChansongJo/DAMD/tree/9b0456d7e590fb5de77ec81e967e8010487eeb56 | import torch
import torch.nn.functional as F
from torch import nn
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)
... |
InputInjection | # 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._C
import torch.serialization
class InputInjection(nn.Module):
"""Downsampling module for CGNet."""
def __init__(self, num_downsampling):
super(InputInjection, self).__init__()
self.pool = nn.ModuleList()
for i in range(num_downsampling)... | 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
import torch._C
import torch.serialization
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strid... | CarnoZhao/mmsegmentation | InputInjection | false | 7,845 | [
"Apache-2.0"
] | 18 | bdaf3d93c4d33c3f0c15f95879fdd7ab78290c1c | https://github.com/CarnoZhao/mmsegmentation/tree/bdaf3d93c4d33c3f0c15f95879fdd7ab78290c1c | import torch
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
"""Downsampling module for CGNet."""
def __init__(self, num_downsampling):
super().__init__()
self.pool = nn.ModuleList()
for i in range(num_downsampling):
self.pool.appen... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.