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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
PoolingAverage | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch
import torch.nn as nn
class PoolingAverage(nn.Module):
def __init__(self, input_dim=2048):
super(PoolingAverage, self).__init__()
self.pool = nn.AdaptiveAvgPool2d((1, 1))
self.output_dim = input_dim
def forward(self, x):
x = t... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cud... | ZhaofanQiu/Optimization-Planning-for-3D-ConvNets | PoolingAverage | false | 18,191 | [
"Apache-2.0"
] | 6 | d9f1b777811ca0d8f462798ca2efcea39b96fcc5 | https://github.com/ZhaofanQiu/Optimization-Planning-for-3D-ConvNets/tree/d9f1b777811ca0d8f462798ca2efcea39b96fcc5 | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim=2048):
super().__init__()
self.pool = nn.AdaptiveAvgPool2d((1, 1))
self.output_dim = input_dim
def forward(self, x):
x = torch.flatten(self.pool(x.view... |
SimpleModel | # 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
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class SimpleModel(nn.Module):
def __init__(self):
super(SimpleModel, self).__init__()
def forward(self, x):
return x * 2
def... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data... | ZVK/jukebox | SimpleModel | false | 18,192 | [
"MIT"
] | 5 | 23fd6753f2892214ad3d97f6f2b59f8cc8d0c57a | https://github.com/ZVK/jukebox/tree/23fd6753f2892214ad3d97f6f2b59f8cc8d0c57a | import torch
import torch.nn as nn
import torch.nn.functional
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return x * 2
def get_inputs():
retu... |
MedianPool2d | # 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
from torch.nn.modules.utils import _pair
from torch.nn.modules.utils import _quadruple
class MedianPool2d(nn.Module):
""" Median pool (usable as median filter when stride=1) module.
Args:
kernel_size: size of pooling kernel, int ... | 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
from torch.nn.modules.utils import _pair
from torch... | Zhang-Jack/adversarial_yolo2 | MedianPool2d | false | 18,193 | [
"MIT"
] | 8 | 91c2a4793047f656482cebf0309984db823e8030 | https://github.com/Zhang-Jack/adversarial_yolo2/tree/91c2a4793047f656482cebf0309984db823e8030 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _pair
from torch.nn.modules.utils import _quadruple
class Model(nn.Module):
""" Median pool (usable as median filter when stride=1) module.
Args:
kernel_size: size of pooling kernel, int or 2-tu... |
WPMLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
import torch.utils.data
class WPMLoss(nn.Module):
def __init__(self, weight):
super(WPMLoss, self).__init__()
self.weight = weight
def forward(self, y_real, y_imag, y_real_hat, y_imag_hat):
torch.FloatTensor([np.pi])
mag =... | 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... | ZhangJingshu/WMP-loss-for-dereverberation | WPMLoss | false | 18,194 | [
"MIT"
] | 5 | 9f742634d8f30f0e17b8d4e44bd2e3bf66ced992 | https://github.com/ZhangJingshu/WMP-loss-for-dereverberation/tree/9f742634d8f30f0e17b8d4e44bd2e3bf66ced992 | import torch
import numpy as np
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, weight):
super().__init__()
self.weight = weight
def forward(self, y_real, y_imag, y_real_hat, y_imag_hat):
torch.FloatTensor([np.pi])
mag = torch.sqrt(y_r... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class DiceLoss(nn.Module):
"""DiceLoss implemented from 'Dice Loss for Data-imbalanced NLP Tasks'
Useful in dealing with unbalanced data
Add softmax automatically
"""
def __init__(self):
super(DiceLoss, self).__init__()
self.m = nn.Sigmoid()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | ZhaoZhibin/Physionet2020model | DiceLoss | false | 18,195 | [
"BSD-2-Clause",
"MIT"
] | 6 | ea7379bd1e4c145c84fd254faa0d5d1330cd2f6e | https://github.com/ZhaoZhibin/Physionet2020model/tree/ea7379bd1e4c145c84fd254faa0d5d1330cd2f6e | import torch
from torch import nn
class Model(nn.Module):
"""DiceLoss implemented from 'Dice Loss for Data-imbalanced NLP Tasks'
Useful in dealing with unbalanced data
Add softmax automatically
"""
def __init__(self):
super().__init__()
self.m = nn.Sigmoid()
self.gamma = 1... |
LocalConv2d | # 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 LocalConv2d(nn.Module):
def __init__(self, num_rows, num_feats_in, num_feats_out, kernel=1,
padding=0):
super(LocalConv2d, self).__init__()
self.num_rows = num_rows
self.out_channels = num_feats_out
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.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | abhi1kumar/M3D-RPN | LocalConv2d | false | 18,196 | [
"MIT"
] | 4 | cf79ec95ad84b3548c57af90aedd59da3ad4af5b | https://github.com/abhi1kumar/M3D-RPN/tree/cf79ec95ad84b3548c57af90aedd59da3ad4af5b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_rows, num_feats_in, num_feats_out, kernel=1,
padding=0):
super().__init__()
self.num_rows = num_rows
self.out_channels = num_feats_out
self.kernel = kernel
... |
GNN_Valuator | # 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.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
"""
def __in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn import Module
i... | Zhen-Tan-dmml/GFCIL | GNN_Valuator | false | 18,197 | [
"MIT"
] | 7 | 9b78210418711a795280c588f55aef63f7df5b3b | https://github.com/Zhen-Tan-dmml/GFCIL/tree/9b78210418711a795280c588f55aef63f7df5b3b | from torch.nn import Module
import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
"""
def __in... |
ILN | # 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
from torch.nn.parameter import Parameter
class ILN(nn.Module):
def __init__(self, num_features, eps=1e-05):
super(ILN, self).__init__()
self.eps = eps
self.rho = Parameter(torch.Tensor(1, num_features, 1, 1))
self.gamma = P... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
import torch.utils.data
from torch.nn.parameter import Par... | ZAKAUDD/-GEU-Net | ILN | false | 18,198 | [
"MIT"
] | 8 | 5251d329afb80c74328e72fd2fc21ff691ef3353 | https://github.com/ZAKAUDD/-GEU-Net/tree/5251d329afb80c74328e72fd2fc21ff691ef3353 | import torch
from torch import nn
import torch.utils.data
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, num_features, eps=1e-05):
super().__init__()
self.eps = eps
self.rho = Parameter(torch.Tensor(1, num_features, 1, 1))
self.gamma = Paramete... |
GCN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
import torch.utils.data
from torch.nn import Conv1d
from torch.nn import ReLU
class GCN(Module):
def __init__(self, num_state, num_node, bias=False):
super(GCN, self).__init__()
self.conv1 = Conv1d(num_node, num_node, kernel_size=1, padding=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 import triton_helpers
from torch.nn import Module
i... | ZhihuaLiuEd/canetbrats | GCN | false | 18,199 | [
"MIT"
] | 7 | a23f008b2876a21026b2564588f4f51692083ae2 | https://github.com/ZhihuaLiuEd/canetbrats/tree/a23f008b2876a21026b2564588f4f51692083ae2 | from torch.nn import Module
import torch
import torch.utils.data
from torch.nn import Conv1d
from torch.nn import ReLU
class Model(Module):
def __init__(self, num_state, num_node, bias=False):
super().__init__()
self.conv1 = Conv1d(num_node, num_node, kernel_size=1, padding=0,
stride=... |
FactoredAttention | # 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
import torch.nn.functional as F
import torch.nn.functional
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch as t
def checkpoint(func, inputs, params, flag):
if flag:
args = inputs + tuple(par... | 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.... | ZVK/jukebox | FactoredAttention | false | 18,200 | [
"MIT"
] | 5 | 23fd6753f2892214ad3d97f6f2b59f8cc8d0c57a | https://github.com/ZVK/jukebox/tree/23fd6753f2892214ad3d97f6f2b59f8cc8d0c57a | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.functional
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch as t
def checkpoint(func, inputs, params, flag):
if flag:
args = inputs + tuple(par... |
ln | # 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 ln(nn.Module):
"""
Layer Normalization
"""
def __init__(self, input):
super(ln, self).__init__()
self.ln = nn.LayerNorm(input.size()[1:])
def forward(self, x):
x = self.ln(x)
return x
def get_inputs... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | ZAKAUDD/-GEU-Net | ln | false | 18,201 | [
"MIT"
] | 8 | 5251d329afb80c74328e72fd2fc21ff691ef3353 | https://github.com/ZAKAUDD/-GEU-Net/tree/5251d329afb80c74328e72fd2fc21ff691ef3353 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
"""
Layer Normalization
"""
def __init__(self, input):
super().__init__()
self.ln = nn.LayerNorm(input.size()[1:])
def forward(self, x):
x = self.ln(x)
return x
def get_inputs():
... |
MapReduce | # 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 MapReduce(nn.Module):
"""
Reduce feature maps into a single edge map
"""
def __init__(self, channels):
super(MapReduce, self).__init__()
self.conv = nn.Conv2d(channels, 1, kernel_size=1, padding=0)
nn.init.constant_(self.conv.bias, 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ZitongYu/pidinet | MapReduce | false | 18,202 | [
"MIT"
] | 5 | 15cdf9fb056549934877675bf7571b427f86db55 | https://github.com/ZitongYu/pidinet/tree/15cdf9fb056549934877675bf7571b427f86db55 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Reduce feature maps into a single edge map
"""
def __init__(self, channels):
super().__init__()
self.conv = nn.Conv2d(channels, 1, kernel_size=1, padding=0)
nn.init.constant_(self.conv.bias, 0)
def forward(sel... |
PDCBlock_converted | # 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 PDCBlock_converted(nn.Module):
"""
CPDC, APDC can be converted to vanilla 3x3 convolution
RPDC can be converted to vanilla 5x5 convolution
"""
def __init__(self, pdc, inplane, ouplane, stride=1):
super(PDCBlock_converted, self).__init__()
s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | ZitongYu/pidinet | PDCBlock_converted | false | 18,203 | [
"MIT"
] | 5 | 15cdf9fb056549934877675bf7571b427f86db55 | https://github.com/ZitongYu/pidinet/tree/15cdf9fb056549934877675bf7571b427f86db55 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
CPDC, APDC can be converted to vanilla 3x3 convolution
RPDC can be converted to vanilla 5x5 convolution
"""
def __init__(self, pdc, inplane, ouplane, stride=1):
super().__init__()
self.stride = stride
if self.s... |
Encoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class Encoder(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(Encoder, self).__init__()
self.lin_input_to_hidden = nn.Linear(input_dim, hidden_dim)
self.lin_hidden_to_hidden = nn.Linear(hidden_dim, hidden_dim)
self.lin_hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | abacoelho/variational-poisson-rnn | Encoder | false | 18,204 | [
"MIT"
] | 5 | abf77f79fc64be75ae9102ec8d537f77ed9c5f8f | https://github.com/abacoelho/variational-poisson-rnn/tree/abf77f79fc64be75ae9102ec8d537f77ed9c5f8f | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super().__init__()
self.lin_input_to_hidden = nn.Linear(input_dim, hidden_dim)
self.lin_hidden_to_hidden = nn.Linear(hidden_dim, hidden_dim)
self.lin_hidden_to_loc = nn... |
CDCM | # 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 CDCM(nn.Module):
"""
Compact Dilation Convolution based Module
"""
def __init__(self, in_channels, out_channels):
super(CDCM, self).__init__()
self.relu1 = nn.ReLU()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=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
assert_... | ZitongYu/pidinet | CDCM | false | 18,205 | [
"MIT"
] | 5 | 15cdf9fb056549934877675bf7571b427f86db55 | https://github.com/ZitongYu/pidinet/tree/15cdf9fb056549934877675bf7571b427f86db55 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Compact Dilation Convolution based Module
"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.relu1 = nn.ReLU()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1,
pa... |
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 forward(self, x):
return x.mul_(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
@triton.jit
def triton_poi_fused_mul_sigmoid_0(in_pt... | absallh/A_yolov3 | Swish | false | 18,206 | [
"Apache-2.0"
] | 6 | 550ec41de42b8efe638e887c51a568189947e049 | https://github.com/absallh/A_yolov3/tree/550ec41de42b8efe638e887c51a568189947e049 | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, x):
return x.mul_(torch.sigmoid(x))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
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, eps: 'float'=1e-06):
super(IOULoss, self).__init__()
self.eps = eps
def forward(self, predict, target):
assert predict.shape[0] == target.shape[0
], 'Predict and target must be same shape'
... | 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... | ZiyunClaudeWang/e3d | IOULoss | false | 18,207 | [
"MIT"
] | 9 | 2efd01167350c29423babb6233907fa54156268f | https://github.com/ZiyunClaudeWang/e3d/tree/2efd01167350c29423babb6233907fa54156268f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps: 'float'=1e-06):
super().__init__()
self.eps = eps
def forward(self, predict, target):
assert predict.shape[0] == target.shape[0
], 'Predict and target must be same shape'
dims = tup... |
GenerationProbabilty | # 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
import torch.nn.functional as F
class GenerationProbabilty(nn.Module):
def __init__(self, embedding_size, hidden_size, h_star_size):
"""Calculates `p_gen` as described in Pointer-Generator Networks paper."""
super(GenerationProbabilty, self).__init__... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.a... | abhishek0318/conll-sigmorphon-2018 | GenerationProbabilty | false | 18,208 | [
"MIT"
] | 6 | de4b8da7778947e03e7a35b56e0e53281f65e403 | https://github.com/abhishek0318/conll-sigmorphon-2018/tree/de4b8da7778947e03e7a35b56e0e53281f65e403 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, embedding_size, hidden_size, h_star_size):
"""Calculates `p_gen` as described in Pointer-Generator Networks paper."""
super().__init__()
self.W_h_star = nn.Linear(h_st... |
net_nvidia_featshift_pytorch | # 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 LambdaLayer(nn.Module):
def __init__(self, lambd):
super(LambdaLayer, self).__init__()
self.lambd = lambd
def forward(self, x):
return self.lambd(x)
class net_nvidia_featshift_pytorch(nn.Module):
def __in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | YuShen0118/SAAP_Auto-driving_Platform | net_nvidia_featshift_pytorch | false | 18,209 | [
"MIT"
] | 4 | 785f899fb3b3ad92075318f9fcb69b8e09597202 | https://github.com/YuShen0118/SAAP_Auto-driving_Platform/tree/785f899fb3b3ad92075318f9fcb69b8e09597202 | import torch
import torch.nn as nn
import torch.nn.functional as F
class LambdaLayer(nn.Module):
def __init__(self, lambd):
super().__init__()
self.lambd = lambd
def forward(self, x):
return self.lambd(x)
class Model(nn.Module):
def __init__(self):
super().__init__()
... |
Emitter | # 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 Emitter(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(Emitter, self).__init__()
self.lin_input_to_hidden = nn.Linear(input_dim, hidden_dim)
self.lin_hidden_to_hidden = nn.Linear(hidden_dim, hidden_dim)
self.lin_hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | abacoelho/variational-poisson-rnn | Emitter | false | 18,210 | [
"MIT"
] | 5 | abf77f79fc64be75ae9102ec8d537f77ed9c5f8f | https://github.com/abacoelho/variational-poisson-rnn/tree/abf77f79fc64be75ae9102ec8d537f77ed9c5f8f | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super().__init__()
self.lin_input_to_hidden = nn.Linear(input_dim, hidden_dim)
self.lin_hidden_to_hidden = nn.Linear(hidden_dim, hidden_dim)
self.lin_hidden_to_loc = nn... |
PositionalEncoder | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.nn as nn
class PositionalEncoder(nn.Module):
"""Generate positional encoding for a vector
Args:
length (int): length of the input sentence to be encoded
d_model (int): dimention of the word vector
Returns:
torch.Tensor: positionaly encoded vect... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guar... | abhirajtiwari/QANet | PositionalEncoder | false | 18,211 | [
"MIT"
] | 4 | 85e1db4edf0710169268a091e7d7959e524f1ceb | https://github.com/abhirajtiwari/QANet/tree/85e1db4edf0710169268a091e7d7959e524f1ceb | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""Generate positional encoding for a vector
Args:
length (int): length of the input sentence to be encoded
d_model (int): dimention of the word vector
Returns:
torch.Tensor: positionaly encoded vector
"""
... |
LuongAttention | # 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 LuongAttention(nn.Module):
"""
Luong Attention from Effective Approaches to Attention-based Neural Machine Translation
https://arxiv.org/pdf/1508.04025.pdf
"""
def __init__(self, attention_dim):
super(LuongAttention, ... | 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.... | aditya140/ques_gen | LuongAttention | false | 18,212 | [
"MIT"
] | 3 | 57be43de682a384ee4114adb3fbc75a527f2aaff | https://github.com/aditya140/ques_gen/tree/57be43de682a384ee4114adb3fbc75a527f2aaff | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""
Luong Attention from Effective Approaches to Attention-based Neural Machine Translation
https://arxiv.org/pdf/1508.04025.pdf
"""
def __init__(self, attention_dim):
super().__init__()
self... |
PoseCriterion | # 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 PoseCriterion(nn.Module):
def __init__(self, t_loss_fn=nn.MSELoss(), q_loss_fn=nn.MSELoss(), sax=
0.0, saq=0.0, learn_beta=False):
super(PoseCriterion, self).__init__()
self.t_loss_fn = t_loss_fn
self.q_loss_fn = q_loss_fn
self.sax ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | ZiyunClaudeWang/e3d | PoseCriterion | false | 18,213 | [
"MIT"
] | 9 | 2efd01167350c29423babb6233907fa54156268f | https://github.com/ZiyunClaudeWang/e3d/tree/2efd01167350c29423babb6233907fa54156268f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, t_loss_fn=nn.MSELoss(), q_loss_fn=nn.MSELoss(), sax=
0.0, saq=0.0, learn_beta=False):
super().__init__()
self.t_loss_fn = t_loss_fn
self.q_loss_fn = q_loss_fn
self.sax = nn.Parameter(torch.Tensor... |
RobertaRNNHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class RobertaRNNHead(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config, num_labels):
super(RobertaRNNHead, self).__init__()
self.hidden_size = config.hidden_size
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... | abrinkmann/productCategorization | RobertaRNNHead | false | 18,214 | [
"MIT"
] | 5 | 75732e4b1c9da941a793db80b5fe2245bae45e87 | https://github.com/abrinkmann/productCategorization/tree/75732e4b1c9da941a793db80b5fe2245bae45e87 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class Model(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config, num_labels):
super().__init__()
self.hidden_size = config.hidden_size
self.dropout = nn.Dropout(config... |
Mish | # 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 Mish(nn.Module):
def forward(self, x):
return x.mul_(F.softplus(x).tanh())
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.gu... | absallh/A_yolov3 | Mish | false | 18,215 | [
"Apache-2.0"
] | 6 | 550ec41de42b8efe638e887c51a568189947e049 | https://github.com/absallh/A_yolov3/tree/550ec41de42b8efe638e887c51a568189947e049 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def forward(self, x):
return x.mul_(F.softplus(x).tanh())
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
RobertaHierarchyHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class RobertaHierarchyHead(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config, num_labels):
super(RobertaHierarchyHead, self).__init__()
self.hidden_size = config.hidden_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | abrinkmann/productCategorization | RobertaHierarchyHead | false | 18,216 | [
"MIT"
] | 5 | 75732e4b1c9da941a793db80b5fe2245bae45e87 | https://github.com/abrinkmann/productCategorization/tree/75732e4b1c9da941a793db80b5fe2245bae45e87 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class Model(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config, num_labels):
super().__init__()
self.hidden_size = config.hidden_size
self.num_labels = num_labels
... |
D_GCN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn.functional as F
from torch import nn
class D_GCN(nn.Module):
"""
Neural network block that applies a diffusion graph convolution to sampled location
"""
def __init__(self, in_channels, out_channels, orders, activation='relu'):
"""
:param in_cha... | 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 math
from torch import... | ZhuangDingyi/STZINB | D_GCN | false | 18,217 | [
"MIT"
] | 6 | e290ad05f76030c0c8e86b5dd78346097e1127cb | https://github.com/ZhuangDingyi/STZINB/tree/e290ad05f76030c0c8e86b5dd78346097e1127cb | import math
import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""
Neural network block that applies a diffusion graph convolution to sampled location
"""
def __init__(self, in_channels, out_channels, orders, activation='relu'):
"""
:param in_cha... |
FixedSubnetConv | # 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.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.functional as F
class FixedSubnetConv(nn.Conv2d):
def __init__(self, *args, **kwargs):
super().__init__(*args... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.multiprocessing
import torch.nn as nn
import torch.nn.p... | adityakusupati/LLC-2.0 | FixedSubnetConv | false | 18,218 | [
"MIT"
] | 10 | 38608bbaa425b15dcf5c971000b7a1b08120fb5c | https://github.com/adityakusupati/LLC-2.0/tree/38608bbaa425b15dcf5c971000b7a1b08120fb5c | import math
import torch
import torch.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.functional as F
class Model(nn.Conv2d):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs... |
BinarizeActivations | # 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.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.autograd as autograd
class BinarizeWeight(autograd.Function):
@staticmethod
def forward(ctx, scores):
out = scores.clone... | 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.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.da... | adityakusupati/LLC-2.0 | BinarizeActivations | false | 18,219 | [
"MIT"
] | 10 | 38608bbaa425b15dcf5c971000b7a1b08120fb5c | https://github.com/adityakusupati/LLC-2.0/tree/38608bbaa425b15dcf5c971000b7a1b08120fb5c | import torch
import torch.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.autograd as autograd
class BinarizeWeight(autograd.Function):
@staticmethod
def forward(ctx, scores):
out = scores.clone... |
EmbeddingLearner | # 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 EmbeddingLearner(nn.Module):
def __init__(self):
super(EmbeddingLearner, self).__init__()
def forward(self, h, r, t):
if r.dim() == 1:
r = r.unsqueeze(0)
h = h.view(1, -1, h.shape[-1])
t = t.view(1, -1, t.shape[-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 import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | adonis704/ucas_2021_hc_15 | EmbeddingLearner | false | 18,220 | [
"MIT"
] | 6 | 7308c3b32962ef5430d85ccfcb199ebe40bf4a7f | https://github.com/adonis704/ucas_2021_hc_15/tree/7308c3b32962ef5430d85ccfcb199ebe40bf4a7f | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, h, r, t):
if r.dim() == 1:
r = r.unsqueeze(0)
h = h.view(1, -1, h.shape[-1])
t = t.view(1, -1, t.shape[-1])
r = r.view(r.shape[0], -1, r.shap... |
DummyLoss | # 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 DummyLoss(nn.Module):
"""
Dummy Loss for debugging
"""
def __init__(self):
super(DummyLoss, self).__init__()
def forward(self, inp, target):
delta = inp - target
None
return delta.mean()
def get_inputs():
return [torc... | 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... | adriangrepo/segmentl | DummyLoss | false | 18,221 | [
"MIT"
] | 5 | 9b520bf6cfd005eef9bba3db36ee6b3bb373b085 | https://github.com/adriangrepo/segmentl/tree/9b520bf6cfd005eef9bba3db36ee6b3bb373b085 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Dummy Loss for debugging
"""
def __init__(self):
super().__init__()
def forward(self, inp, target):
delta = inp - target
None
return delta.mean()
def get_inputs():
return [torch.rand([4, 4, 4, 4]... |
OhemSphereLoss | # 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
from torchvision.transforms import *
class OhemSphereLoss(nn.Module):
def __init__(self, in_feats, n_classes, thresh=0.7, scale=14, *args, **
kwargs):
super(OhemSphereLoss, self).__init__(*args, **kwargs)
self.thresh = thresh
... | 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.... | ace19-dev/image-retrieval-pytorch | OhemSphereLoss | false | 18,222 | [
"MIT"
] | 9 | 19bd4ae5efea5b6184c345f693646bcd9a0fc8cf | https://github.com/ace19-dev/image-retrieval-pytorch/tree/19bd4ae5efea5b6184c345f693646bcd9a0fc8cf | import torch
import torch.utils.data
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
def __init__(self, in_feats, n_classes, thresh=0.7, scale=14, *args, **
kwargs):
super().__init__(*args, **kwargs)
self.thresh = thresh
self.scale = scale
... |
SpatialPyramidPooling | # 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 math import sqrt
import torch.nn as nn
class SpatialPyramidPooling(nn.Module):
"""Generate fixed length representation regardless of image dimensions
Based on the paper "Spatial Pyramid Pooling in Deep Convolutional Networks
for Visual Recognition" (https://arxiv.org/pdf/1406.4729.pdf)
... | 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 math import sqrt
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.... | addisonklinke/pytorch-architectures | SpatialPyramidPooling | false | 18,223 | [
"MIT"
] | 6 | a5739b9b90db726db29b02166a9b1a7e52eb1eba | https://github.com/addisonklinke/pytorch-architectures/tree/a5739b9b90db726db29b02166a9b1a7e52eb1eba | import torch
from math import sqrt
import torch.nn as nn
class Model(nn.Module):
"""Generate fixed length representation regardless of image dimensions
Based on the paper "Spatial Pyramid Pooling in Deep Convolutional Networks
for Visual Recognition" (https://arxiv.org/pdf/1406.4729.pdf)
:param [int... |
DiceCoeffLoss | # 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 DiceCoeffLoss(nn.Module):
def __init__(self, eps: 'float'=0.0001):
super(DiceCoeffLoss, self).__init__()
self.eps = eps
def forward(self, predict, target):
assert predict.shape[0] == target.shape[0
], 'Predict and target must be sa... | 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... | ZiyunClaudeWang/e3d | DiceCoeffLoss | false | 18,224 | [
"MIT"
] | 9 | 2efd01167350c29423babb6233907fa54156268f | https://github.com/ZiyunClaudeWang/e3d/tree/2efd01167350c29423babb6233907fa54156268f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps: 'float'=0.0001):
super().__init__()
self.eps = eps
def forward(self, predict, target):
assert predict.shape[0] == target.shape[0
], 'Predict and target must be same shape'
inter = t... |
CnptAttention | # 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 CnptAttention(nn.Module):
def __init__(self, in_dim, out_dim):
super(CnptAttention, self).__init__()
self.softmax = nn.Softmax(dim=-1)
def forward(self, query, key):
"""
query: sent_emb (1, D)
key: [(k, D), (k,D)]
value:... | 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... | adonis704/ucas_2021_hc_15 | CnptAttention | false | 18,225 | [
"MIT"
] | 6 | 7308c3b32962ef5430d85ccfcb199ebe40bf4a7f | https://github.com/adonis704/ucas_2021_hc_15/tree/7308c3b32962ef5430d85ccfcb199ebe40bf4a7f | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_dim, out_dim):
super().__init__()
self.softmax = nn.Softmax(dim=-1)
def forward(self, query, key):
"""
query: sent_emb (1, D)
key: [(k, D), (k,D)]
value: (k, kg_dim, kg_dim)
... |
LSR | # 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 LSR(nn.Module):
def __init__(self, epsilon=0.1, num_classes=162):
super(LSR, self).__init__()
self._epsilon = epsilon
self._num_classes = num_classes
def forward(self, yhat, y):
prior = torch.div(torch.o... | 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
... | aisolab/bertnd | LSR | false | 18,226 | [
"MIT"
] | 6 | 01bb46b0fad9285b34d08e1d741f6b1b620997d2 | https://github.com/aisolab/bertnd/tree/01bb46b0fad9285b34d08e1d741f6b1b620997d2 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, epsilon=0.1, num_classes=162):
super().__init__()
self._epsilon = epsilon
self._num_classes = num_classes
def forward(self, yhat, y):
prior = torch.div(torch.ones_lik... |
OutputLayer | # 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
def masked_softmax(logits, mask, dim=-1, log_softmax=False):
"""Take the softmax of `logits` over given dimension, and set
entries to 0 wherever `mask` is 0.
Args:
logits (torch.Tensor): Inputs to the softmax function.
mas... | 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.... | abhirajtiwari/QANet | OutputLayer | false | 18,227 | [
"MIT"
] | 4 | 85e1db4edf0710169268a091e7d7959e524f1ceb | https://github.com/abhirajtiwari/QANet/tree/85e1db4edf0710169268a091e7d7959e524f1ceb | import torch
import torch.nn as nn
import torch.nn.functional as F
def masked_softmax(logits, mask, dim=-1, log_softmax=False):
"""Take the softmax of `logits` over given dimension, and set
entries to 0 wherever `mask` is 0.
Args:
logits (torch.Tensor): Inputs to the softmax function.
mas... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.optim
import torch.nn as nn
class ResidualBlock(nn.Module):
def __init__(self, in_f, out_f):
super(ResidualBlock, self).__init__()
self.conv = nn.Conv2d(in_f, out_f, 1, 1, padding=0, bias=False)
def forward(self, x):
residual = x
out = self.conv(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.optim
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | ajiljalal/code-cs-fairness | ResidualBlock | false | 18,228 | [
"MIT"
] | 9 | 2025c1c8520444df800a1fc03d91d63d1415db54 | https://github.com/ajiljalal/code-cs-fairness/tree/2025c1c8520444df800a1fc03d91d63d1415db54 | import torch
import torch.optim
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_f, out_f):
super().__init__()
self.conv = nn.Conv2d(in_f, out_f, 1, 1, padding=0, bias=False)
def forward(self, x):
residual = x
out = self.conv(x)
out += residual
... |
Clamp | # 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 Clamp(nn.Module):
"""Clamp energy output"""
def forward(self, x):
x = torch.clamp(x, min=0, max=30)
return x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | abdalazizrashid/idao-21-baseline | Clamp | false | 18,229 | [
"Apache-2.0"
] | 7 | 649c2c70a1754b09fa06bf2264d7e8217b3e10f0 | https://github.com/abdalazizrashid/idao-21-baseline/tree/649c2c70a1754b09fa06bf2264d7e8217b3e10f0 | import torch
from torch import nn
class Model(nn.Module):
"""Clamp energy output"""
def forward(self, x):
x = torch.clamp(x, min=0, max=30)
return x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
Conv2dBlock | # 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.functional as F
from torch import nn
import torch.optim
def l2normalize(v, eps=1e-12):
return v / (v.norm() + eps)
class AdaptiveInstanceNorm2d(nn.Module):
def __init__(self, num_features, eps=1e-05, momentum=0.1):
super().__init__()
self.num_... | 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 numpy as np
import tor... | agermanidis/HiDT | Conv2dBlock | false | 18,230 | [
"BSD-3-Clause"
] | 4 | 69192bb26785fc4e05038c45d05f2f880dd362d0 | https://github.com/agermanidis/HiDT/tree/69192bb26785fc4e05038c45d05f2f880dd362d0 | import torch
import numpy as np
import torch.nn.functional as F
from torch import nn
import torch.optim
def l2normalize(v, eps=1e-12):
return v / (v.norm() + eps)
class AdaptiveInstanceNorm2d(nn.Module):
def __init__(self, num_features, eps=1e-05, momentum=0.1):
super().__init__()
self.num_... |
BasicConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.model_zoo
class BasicConv(nn.Module):
def __init__(self, in_feature, out_feature, kernel_size, stride=1,
padding=0, dilation=1, groups=1, relu=True, bn=False, bias=False):
super(BasicConv, self).__init__()
self.conv = nn.Conv2d(in_feat... | 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 ... | agusgun/EDSR-PyTorch | BasicConv | false | 18,231 | [
"MIT"
] | 6 | 38ff657e2c4e2f148d38b8792bacdf8d81f8bf9f | https://github.com/agusgun/EDSR-PyTorch/tree/38ff657e2c4e2f148d38b8792bacdf8d81f8bf9f | import torch
import torch.nn as nn
import torch.utils.model_zoo
class Model(nn.Module):
def __init__(self, in_feature, out_feature, kernel_size, stride=1,
padding=0, dilation=1, groups=1, relu=True, bn=False, bias=False):
super().__init__()
self.conv = nn.Conv2d(in_feature, out_feature, k... |
NormalizeOutput | # 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
import torch.optim
class NormalizeOutput(nn.Module):
"""
Module that scales the input tensor to the unit norm w.r.t. the specified axis.
Actually, the module analog of `torch.nn.functional.normalize`
"""
def __init__(self, dim=1, p... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
import ... | agermanidis/HiDT | NormalizeOutput | false | 18,232 | [
"BSD-3-Clause"
] | 4 | 69192bb26785fc4e05038c45d05f2f880dd362d0 | https://github.com/agermanidis/HiDT/tree/69192bb26785fc4e05038c45d05f2f880dd362d0 | import torch
import torch.nn.functional as F
from torch import nn
import torch.optim
class Model(nn.Module):
"""
Module that scales the input tensor to the unit norm w.r.t. the specified axis.
Actually, the module analog of `torch.nn.functional.normalize`
"""
def __init__(self, dim=1, p=2, eps=1e... |
CmapPafHead | # 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
import torch.optim
class UpsampleCBR(torch.nn.Sequential):
def __init__(self, input_channels, output_channels, count=1, num_flat=0):
layers = []
for i in range(count):
if i == 0:
inch = input_channels
els... | 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
import torch.optim
assert_size_stride = ... | ajsampathk/trt_pose | CmapPafHead | false | 18,233 | [
"MIT"
] | 7 | 592e038cacaf43b6a502b759a035a4e7cae9db9e | https://github.com/ajsampathk/trt_pose/tree/592e038cacaf43b6a502b759a035a4e7cae9db9e | import torch
import torch.utils.data
import torch.nn
import torch.optim
class UpsampleCBR(torch.nn.Sequential):
def __init__(self, input_channels, output_channels, count=1, num_flat=0):
layers = []
for i in range(count):
if i == 0:
inch = input_channels
els... |
LinearModel | # 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
import torch.optim
class LinearModel(torch.nn.Module):
def __init__(self, _in, out):
super(LinearModel, self).__init__()
self.input = torch.nn.Linear(_in, _in)
self.hidden_1 = torch.nn.Linear(_in, out)
self.hidden_2 = torch.nn.L... | 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
import torch.optim
assert_size_stride = ... | ajsampathk/trt_pose | LinearModel | false | 18,234 | [
"MIT"
] | 7 | 592e038cacaf43b6a502b759a035a4e7cae9db9e | https://github.com/ajsampathk/trt_pose/tree/592e038cacaf43b6a502b759a035a4e7cae9db9e | import torch
import torch.utils.data
import torch.nn
import torch.optim
class Model(torch.nn.Module):
def __init__(self, _in, out):
super().__init__()
self.input = torch.nn.Linear(_in, _in)
self.hidden_1 = torch.nn.Linear(_in, out)
self.hidden_2 = torch.nn.Linear(out, out)
... |
XnorConv | # 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.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.autograd as autograd
import torch.nn.functional as F
class BinarizeWeight(autograd.Function):
@staticmethod
def forward(ctx, sco... | 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.multiprocessing
import torch.nn as nn
import torch.nn.parallel
impo... | adityakusupati/LLC-2.0 | XnorConv | false | 18,235 | [
"MIT"
] | 10 | 38608bbaa425b15dcf5c971000b7a1b08120fb5c | https://github.com/adityakusupati/LLC-2.0/tree/38608bbaa425b15dcf5c971000b7a1b08120fb5c | import torch
import torch.multiprocessing
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.autograd as autograd
import torch.nn.functional as F
class BinarizeWeight(autograd.Function):
@staticmethod
def forward(ctx, sco... |
SphereLoss | # 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
from torchvision.transforms import *
class SphereLoss(nn.Module):
def __init__(self, in_feats, n_classes, scale=14, *args, **kwargs):
super(SphereLoss, self).__init__(*args, **kwargs)
self.scale = scale
self.cross_entropy = nn.Cro... | 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.... | ace19-dev/image-retrieval-pytorch | SphereLoss | false | 18,236 | [
"MIT"
] | 9 | 19bd4ae5efea5b6184c345f693646bcd9a0fc8cf | https://github.com/ace19-dev/image-retrieval-pytorch/tree/19bd4ae5efea5b6184c345f693646bcd9a0fc8cf | import torch
import torch.utils.data
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
def __init__(self, in_feats, n_classes, scale=14, *args, **kwargs):
super().__init__(*args, **kwargs)
self.scale = scale
self.cross_entropy = nn.CrossEntropyLoss()
... |
minibatch_discriminator | # 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 minibatch_discriminator(nn.Module):
def __init__(self, num_channels, B_dim, C_dim):
super(minibatch_discriminator, self).__init__()
self.B_dim = B_dim
self.C_dim = C_dim
self.num_channels = num_channels
T_init = torch.randn(num_chan... | 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.... | aditya30394/Reverse-Image-Captioning | minibatch_discriminator | false | 18,237 | [
"MIT"
] | 5 | a6e427624a64f28d08e5629f48850ff001e48d02 | https://github.com/aditya30394/Reverse-Image-Captioning/tree/a6e427624a64f28d08e5629f48850ff001e48d02 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_channels, B_dim, C_dim):
super().__init__()
self.B_dim = B_dim
self.C_dim = C_dim
self.num_channels = num_channels
T_init = torch.randn(num_channels * 4 * 4, B_dim * C_dim) * 0.1
self... |
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
class DiceLoss(nn.Module):
def __init__(self, smooth=0, eps=1e-07):
super(DiceLoss, self).__init__()
self.smooth = smooth
self.eps = eps
def forward(self, output, target):
return 1 - (2 * torch.sum(output * target) + self.smooth) / (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... | adriangrepo/segmentl | DiceLoss | false | 18,238 | [
"MIT"
] | 5 | 9b520bf6cfd005eef9bba3db36ee6b3bb373b085 | https://github.com/adriangrepo/segmentl/tree/9b520bf6cfd005eef9bba3db36ee6b3bb373b085 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, smooth=0, eps=1e-07):
super().__init__()
self.smooth = smooth
self.eps = eps
def forward(self, output, target):
return 1 - (2 * torch.sum(output * target) + self.smooth) / (torch.
sum(ou... |
Accuracy | # 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 Accuracy(nn.Module):
def __init__(self, threshold=0.5):
super().__init__()
self.threshold = threshold
def forward(self, y_true, y_pred):
preds = (y_pred > self.threshold).int()
return (preds == y_true).sum().float() / len(preds)
def ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | alessandroferrari/defeatcovid19-net-pytorch | Accuracy | false | 18,239 | [
"MIT"
] | 9 | fe9ed82563709bae92524093c3bc0bb887fbdf6d | https://github.com/alessandroferrari/defeatcovid19-net-pytorch/tree/fe9ed82563709bae92524093c3bc0bb887fbdf6d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, threshold=0.5):
super().__init__()
self.threshold = threshold
def forward(self, y_true, y_pred):
preds = (y_pred > self.threshold).int()
return (preds == y_true).sum().float() / len(preds)
def get... |
Hswish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.quantization import QuantStub
from torch.quantization import DeQuantStub
class Hsigmoid(nn.Module):
def __init__(self, inplace=True, add_stub=False):
super().__init__()
self.float_op = nn.quantized.FloatFunctional()
self.relu6 = nn.ReLU6(inpla... | 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
from torch.quantization import QuantStub
from torch.quantization im... | akosik-anyvision/incubator-tvm | Hswish | false | 18,240 | [
"Apache-2.0"
] | 9 | e1b11712ac09c32614483d24a4c7e0245ee4cb4b | https://github.com/akosik-anyvision/incubator-tvm/tree/e1b11712ac09c32614483d24a4c7e0245ee4cb4b | import torch
import torch.nn as nn
from torch.quantization import QuantStub
from torch.quantization import DeQuantStub
class Hsigmoid(nn.Module):
def __init__(self, inplace=True, add_stub=False):
super().__init__()
self.float_op = nn.quantized.FloatFunctional()
self.relu6 = nn.ReLU6(inpla... |
Hsigmoid | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.quantization import QuantStub
from torch.quantization import DeQuantStub
class Hsigmoid(nn.Module):
def __init__(self, inplace=True, add_stub=False):
super().__init__()
self.float_op = nn.quantized.FloatFunctional()
self.relu6 = nn.ReLU6(inpla... | 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
from torch.quantization import QuantStub
from torch.quantization im... | akosik-anyvision/incubator-tvm | Hsigmoid | false | 18,241 | [
"Apache-2.0"
] | 9 | e1b11712ac09c32614483d24a4c7e0245ee4cb4b | https://github.com/akosik-anyvision/incubator-tvm/tree/e1b11712ac09c32614483d24a4c7e0245ee4cb4b | import torch
import torch.nn as nn
from torch.quantization import QuantStub
from torch.quantization import DeQuantStub
class Model(nn.Module):
def __init__(self, inplace=True, add_stub=False):
super().__init__()
self.float_op = nn.quantized.FloatFunctional()
self.relu6 = nn.ReLU6(inplace=... |
RNNModel | # 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 RNNCell(torch.nn.Module):
def __init__(self, input_channels: 'int', hidden_channels: 'int',
non_linearity: 'str'):
"""Manual implementation of a cell of the RNN, necessary when non_linearity is 'sigmoid' since torch.nn.RNNCell
accepts only 'tanh' or 'relu' activations
... | 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
assert_size_stride ... | afermanian/rnn-kernel | RNNModel | false | 18,242 | [
"Apache-2.0"
] | 5 | 8c4400c33e61081bfc162fa26d088827cee1028b | https://github.com/afermanian/rnn-kernel/tree/8c4400c33e61081bfc162fa26d088827cee1028b | import torch
class RNNCell(torch.nn.Module):
def __init__(self, input_channels: 'int', hidden_channels: 'int',
non_linearity: 'str'):
"""Manual implementation of a cell of the RNN, necessary when non_linearity is 'sigmoid' since torch.nn.RNNCell
accepts only 'tanh' or 'relu' activations
... |
BucketingEmbedding | # 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 BucketingEmbedding(nn.Module):
def __init__(self, min_val, max_val, count, dim, use_log_scale=False):
super().__init__()
self.min_val = min_val
self.max_val = max_val
self.count = count
self.dim = dim
self.use_log_scale = us... | 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... | aimagelab/LoCoNav | BucketingEmbedding | false | 18,243 | [
"MIT"
] | 9 | 00faf0d22d68a5ac8a4896381f97f2b472613ace | https://github.com/aimagelab/LoCoNav/tree/00faf0d22d68a5ac8a4896381f97f2b472613ace | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, min_val, max_val, count, dim, use_log_scale=False):
super().__init__()
self.min_val = min_val
self.max_val = max_val
self.count = count
self.dim = dim
self.use_log_scale = use_log_scale
... |
SpatialAttentionLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.model_zoo
class BasicConv(nn.Module):
def __init__(self, in_feature, out_feature, kernel_size, stride=1,
padding=0, dilation=1, groups=1, relu=True, bn=False, bias=False):
super(BasicConv, self).__init__()
self.conv = nn.Conv2d(in_feat... | 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 ... | agusgun/EDSR-PyTorch | SpatialAttentionLayer | false | 18,244 | [
"MIT"
] | 6 | 38ff657e2c4e2f148d38b8792bacdf8d81f8bf9f | https://github.com/agusgun/EDSR-PyTorch/tree/38ff657e2c4e2f148d38b8792bacdf8d81f8bf9f | import torch
import torch.nn as nn
import torch.utils.model_zoo
class BasicConv(nn.Module):
def __init__(self, in_feature, out_feature, kernel_size, stride=1,
padding=0, dilation=1, groups=1, relu=True, bn=False, bias=False):
super().__init__()
self.conv = nn.Conv2d(in_feature, out_featur... |
RewardModel | # 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 functional as F
class RewardModel(nn.Module):
def __init__(self, hidden_size, state_size, node_size, act_fn='relu'):
super().__init__()
self.act_fn = getattr(F, act_fn)
self.fc_1 = nn.Linear(hidden_size + state_size, node_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | alec-tschantz/planet | RewardModel | false | 18,245 | [
"MIT"
] | 7 | bf68722993c93129263bb9606a582d24cb4f2a58 | https://github.com/alec-tschantz/planet/tree/bf68722993c93129263bb9606a582d24cb4f2a58 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, hidden_size, state_size, node_size, act_fn='relu'):
super().__init__()
self.act_fn = getattr(F, act_fn)
self.fc_1 = nn.Linear(hidden_size + state_size, node_size)
sel... |
GLU | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn as nn
import torch
from torchvision.transforms import functional as F
import torch.nn.functional as F
import torch.nn.parallel
class GLU(nn.Module):
def __init__(self):
super(GLU, self).__init__()
def forward(self, x):
nc = x.size(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
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
assert_size_stride = torch._C._dynamo.guards.assert_size... | adymaharana/VLCStoryGan | GLU | false | 18,246 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | import torch
import torch.utils.data
import torch.nn as nn
import torch
from torchvision.transforms import functional as F
import torch.nn.functional as F
import torch.nn.parallel
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
nc = x.size(1)
asse... |
Bridge | # 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 Bridge(nn.Sequential):
def __init__(self, in_channels, out_channels):
super(Bridge, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3,
padding=1)
self.act1 = nn.LeakyReLU(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 import triton_helpers
import torch.nn as nn
import ... | aiarjun/Monocular-Depth-Estimation | Bridge | false | 18,247 | [
"MIT"
] | 6 | 5989673f1b6d865f822a342448172b374968c234 | https://github.com/aiarjun/Monocular-Depth-Estimation/tree/5989673f1b6d865f822a342448172b374968c234 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Sequential):
def __init__(self, in_channels, out_channels):
super().__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3,
padding=1)
self.act1 = nn.LeakyReLU(0.2)
se... |
MinibatchStdDev | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
from typing import List
class MinibatchStdDev(Module):
"""
Minibatch standard deviation layer for the discriminator
Args:
group_size: Size of each group into which the batch is split
num_new_features: number of additional fe... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch.nn import Module
assert_size_stride = torch._C._dynamo.guards.assert... | akanimax/open-styleganv2-pytorch | MinibatchStdDev | false | 18,248 | [
"MIT"
] | 7 | 243f12e335698293a0008d60c8b136d9f80cdacf | https://github.com/akanimax/open-styleganv2-pytorch/tree/243f12e335698293a0008d60c8b136d9f80cdacf | from torch.nn import Module
import torch
from torch import Tensor
from typing import List
class Model(Module):
"""
Minibatch standard deviation layer for the discriminator
Args:
group_size: Size of each group into which the batch is split
num_new_features: number of additional feature maps... |
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.functional as F
from torch import nn
import torch.optim
class Vgg16(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)
... | 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
import t... | agermanidis/HiDT | Vgg16 | false | 18,249 | [
"BSD-3-Clause"
] | 4 | 69192bb26785fc4e05038c45d05f2f880dd362d0 | https://github.com/agermanidis/HiDT/tree/69192bb26785fc4e05038c45d05f2f880dd362d0 | import torch
import torch.nn.functional as F
from torch import nn
import torch.optim
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)
... |
ConvDecoder | # 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 functional as F
class ConvDecoder(nn.Module):
def __init__(self, hidden_size, state_size, embedding_size, act_fn='relu'):
super().__init__()
self.act_fn = getattr(F, act_fn)
self.embedding_size = embedding_size
self.fc_1 = nn... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | alec-tschantz/planet | ConvDecoder | false | 18,250 | [
"MIT"
] | 7 | bf68722993c93129263bb9606a582d24cb4f2a58 | https://github.com/alec-tschantz/planet/tree/bf68722993c93129263bb9606a582d24cb4f2a58 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, hidden_size, state_size, embedding_size, act_fn='relu'):
super().__init__()
self.act_fn = getattr(F, act_fn)
self.embedding_size = embedding_size
self.fc_1 = nn.Linea... |
CSAM | # 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 CSAM(nn.Module):
"""
Compact Spatial Attention Module
"""
def __init__(self, channels):
super(CSAM, self).__init__()
mid_channels = 4
self.relu1 = nn.ReLU()
self.conv1 = nn.Conv2d(channels, mid_channels, kernel_size=1, padding=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 import triton_helpers
import torch.nn as nn
assert_... | ZitongYu/pidinet | CSAM | false | 18,251 | [
"MIT"
] | 5 | 15cdf9fb056549934877675bf7571b427f86db55 | https://github.com/ZitongYu/pidinet/tree/15cdf9fb056549934877675bf7571b427f86db55 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Compact Spatial Attention Module
"""
def __init__(self, channels):
super().__init__()
mid_channels = 4
self.relu1 = nn.ReLU()
self.conv1 = nn.Conv2d(channels, mid_channels, kernel_size=1, padding=0
... |
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
class Policy(nn.Module):
def __init__(self):
super(Policy, self).__init__()
self.conv1 = nn.Conv2d(2, 4, kernel_size=6, stride=2, bias=False)
self.conv2 = nn.Conv2d(4, 16, kernel_size=6, stride=4)
self.size = 9 * 9... | 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_... | aklein1995/Pong_REINFORCE | Policy | false | 18,252 | [
"MIT"
] | 4 | 3b57777fd3ab6e98c8a1191989bd65140e19fc6e | https://github.com/aklein1995/Pong_REINFORCE/tree/3b57777fd3ab6e98c8a1191989bd65140e19fc6e | 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(2, 4, kernel_size=6, stride=2, bias=False)
self.conv2 = nn.Conv2d(4, 16, kernel_size=6, stride=4)
self.size = 9 * 9 * 16
... |
PcamPool | # 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 PcamPool(nn.Module):
def __init__(self):
super(PcamPool, self).__init__()
def forward(self, feat_map, logit_map):
assert logit_map is not None
prob_map = torch.sigmoid(logit_map)
weight_map = prob_map / prob_map.sum(dim=2, keepdim=True)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | alinstein/X_RAY | PcamPool | false | 18,253 | [
"MIT"
] | 4 | 35a39761d3b11ce9e47509025054f25e5f26aab9 | https://github.com/alinstein/X_RAY/tree/35a39761d3b11ce9e47509025054f25e5f26aab9 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, feat_map, logit_map):
assert logit_map is not None
prob_map = torch.sigmoid(logit_map)
weight_map = prob_map / prob_map.sum(dim=2, keepdim=True).sum(dim=3,
... |
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
import torch.nn as 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 = ... | 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.... | agrimsharma20/Deep-Continuous-Networks | ODEfunc | false | 18,254 | [
"MIT"
] | 4 | 6c2b46dea5d0d7f25682d2fb55c4d5386e30997c | https://github.com/agrimsharma20/Deep-Continuous-Networks/tree/6c2b46dea5d0d7f25682d2fb55c4d5386e30997c | import torch
import torch.nn as 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... |
LxmertAttentionOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class LxmertAttentionOutput(nn.Module):
def __init__(self, hidden_size, hidden_dropout_prob):
super().__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.LayerNorm = nn.LayerNorm(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.... | adymaharana/VLCStoryGan | LxmertAttentionOutput | false | 18,255 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, hidden_size, hidden_dropout_prob):
super().__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.LayerNorm = nn.LayerNorm(hidden_size, eps... |
BertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class BertSelfAttention(nn.Module):
def __init__(self, config):
super(BertSelfAttention, self).__init__()
if config.hidden_size % config.num_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.... | adymaharana/VLCStoryGan | BertSelfAttention | false | 18,256 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
ra... |
BertPredictionHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT"s gelu is slightly different (and gives slightly different ... | 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.... | adymaharana/VLCStoryGan | BertPredictionHead | false | 18,257 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT"s gelu is slightly different (and gives slightly different ... |
PreActResPath | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class PreActResPath(nn.Module):
def __init__(self, in_features, config, super_block):
super(PreActResPath, self).__init__()
self.number_layers = config['num_layers']
self.activate_dropout = True if config['ac... | 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_... | ArlindKadra/DeepLearning | PreActResPath | false | 18,258 | [
"Apache-2.0"
] | 4 | 4e9ffe39bbb8722ca658522e6b6d26c6f2291ef6 | https://github.com/ArlindKadra/DeepLearning/tree/4e9ffe39bbb8722ca658522e6b6d26c6f2291ef6 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_features, config, super_block):
super().__init__()
self.number_layers = config['num_layers']
self.activate_dropout = True if config['activate_dropout'
... |
LogSumExpPool | # 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 LogSumExpPool(nn.Module):
def __init__(self, gamma):
super(LogSumExpPool, self).__init__()
self.gamma = gamma
def forward(self, feat_map):
"""
Numerically stable implementation of the operation
Arguments:
feat_map(Te... | 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... | alinstein/X_RAY | LogSumExpPool | false | 18,259 | [
"MIT"
] | 4 | 35a39761d3b11ce9e47509025054f25e5f26aab9 | https://github.com/alinstein/X_RAY/tree/35a39761d3b11ce9e47509025054f25e5f26aab9 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, gamma):
super().__init__()
self.gamma = gamma
def forward(self, feat_map):
"""
Numerically stable implementation of the operation
Arguments:
feat_map(Tensor): tensor with shape (N... |
BertPredictionHeadTransform | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT"s gelu is slightly different (and gives slightly different ... | 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 ... | adymaharana/VLCStoryGan | BertPredictionHeadTransform | false | 18,260 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT"s gelu is slightly different (and gives slightly different ... |
NumPredictor | # 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 NumPredictor(nn.Module):
def __init__(self, latent_dim):
self.latent_dim = latent_dim
super(NumPredictor, self).__init__()
self.reg_1 = nn.Linear(self.latent_dim, 1)
def forward(self, x):
x = F.relu(self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | alibaba/FederatedScope | NumPredictor | false | 18,261 | [
"Apache-2.0"
] | 9 | fcf6d237624769ea094cfd68803901622f14fc23 | https://github.com/alibaba/FederatedScope/tree/fcf6d237624769ea094cfd68803901622f14fc23 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, latent_dim):
self.latent_dim = latent_dim
super().__init__()
self.reg_1 = nn.Linear(self.latent_dim, 1)
def forward(self, x):
x = F.relu(self.reg_1(x))
return... |
CAModule | # 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 CAModule(nn.Module):
"""
Re-implementation of Squeeze-and-Excitation (SE) block described in:
*Hu et al., Squeeze-and-Excitation Networks, arXiv:1709.01507*
code reference:
https://github.com/kobiso/CBAM-keras/blob/master/models/attention_module.py
"""
... | 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... | alinstein/X_RAY | CAModule | false | 18,262 | [
"MIT"
] | 4 | 35a39761d3b11ce9e47509025054f25e5f26aab9 | https://github.com/alinstein/X_RAY/tree/35a39761d3b11ce9e47509025054f25e5f26aab9 | import torch
from torch import nn
class Model(nn.Module):
"""
Re-implementation of Squeeze-and-Excitation (SE) block described in:
*Hu et al., Squeeze-and-Excitation Networks, arXiv:1709.01507*
code reference:
https://github.com/kobiso/CBAM-keras/blob/master/models/attention_module.py
"""
... |
CmapPafHeadAttention | # 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
import torch.optim
class UpsampleCBR(torch.nn.Sequential):
def __init__(self, input_channels, output_channels, count=1, num_flat=0):
layers = []
for i in range(count):
if i == 0:
inch = input_channels
els... | 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.... | ajsampathk/trt_pose | CmapPafHeadAttention | false | 18,263 | [
"MIT"
] | 7 | 592e038cacaf43b6a502b759a035a4e7cae9db9e | https://github.com/ajsampathk/trt_pose/tree/592e038cacaf43b6a502b759a035a4e7cae9db9e | import torch
import torch.utils.data
import torch.nn
import torch.optim
class UpsampleCBR(torch.nn.Sequential):
def __init__(self, input_channels, output_channels, count=1, num_flat=0):
layers = []
for i in range(count):
if i == 0:
inch = input_channels
els... |
AveragedHausdorffLoss | # 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 cdist(x, y):
"""
Input: x is a Nxd Tensor
y is a Mxd Tensor
Output: dist is a NxM matrix where dist[i,j] is the norm
between x[i,:] and y[j,:]
i.e. dist[i,j] = ||x[i,:]-y[j,:]||
"""
differences = x.unsqueeze(1) - y.unsqueeze(0)
d... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | adriangrepo/segmentl | AveragedHausdorffLoss | false | 18,264 | [
"MIT"
] | 5 | 9b520bf6cfd005eef9bba3db36ee6b3bb373b085 | https://github.com/adriangrepo/segmentl/tree/9b520bf6cfd005eef9bba3db36ee6b3bb373b085 | import torch
import torch.nn as nn
def cdist(x, y):
"""
Input: x is a Nxd Tensor
y is a Mxd Tensor
Output: dist is a NxM matrix where dist[i,j] is the norm
between x[i,:] and y[j,:]
i.e. dist[i,j] = ||x[i,:]-y[j,:]||
"""
differences = x.unsqueeze(1) - y.unsqueeze(0)
d... |
GCN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
from torch.nn import functional as F
class GraphConvLayer(nn.Module):
""" A Graph Convolution Layer as per https://arxiv.org/pdf/1609.02907.pdf with Glorot initialisation """
def __init__(self, in_features: 'int', out_filters: 'int',
dropout_ratio: 'floa... | 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 math
import torch.nn a... | alecokas/swahili-text-gcn | GCN | false | 18,265 | [
"MIT"
] | 4 | 14b8196b30baac2a05c869a1f6c17a912d1adcea | https://github.com/alecokas/swahili-text-gcn/tree/14b8196b30baac2a05c869a1f6c17a912d1adcea | import math
import torch
import torch.nn as nn
from torch.nn import functional as F
class GraphConvLayer(nn.Module):
""" A Graph Convolution Layer as per https://arxiv.org/pdf/1609.02907.pdf with Glorot initialisation """
def __init__(self, in_features: 'int', out_filters: 'int',
dropout_ratio: 'floa... |
ConvLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn.functional as F
import torch.nn as nn
class ConvLayer(nn.Module):
"""Conv layer for qa output"""
def __init__(self, config):
"""
Args:
config (ModelArguments): ModelArguments
"""
super().__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._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Amber-Chaeeunk/Open-Domain-Question-Answering | ConvLayer | false | 18,266 | [
"MIT"
] | 5 | 725e369a4409c54bf11bcfb9db53865d8fc1f935 | https://github.com/Amber-Chaeeunk/Open-Domain-Question-Answering/tree/725e369a4409c54bf11bcfb9db53865d8fc1f935 | from _paritybench_helpers import _mock_config
import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""Conv layer for qa output"""
def __init__(self, config):
"""
Args:
config (ModelArguments): ModelArguments
"""
super().__init_... |
PatchEmbedding | # 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 Tensor
from torch import nn
class PatchEmbedding(nn.Module):
"""Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, embed_dim=768):
super().__init__()
assert img_size % patch_size == 0, 'Image size must be divisible by patch size'
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | alhamami/Object-Detection-And-Tracking | PatchEmbedding | false | 18,267 | [
"MIT"
] | 5 | a211a1dc103e812c539cd0ee16a2da4251943bed | https://github.com/alhamami/Object-Detection-And-Tracking/tree/a211a1dc103e812c539cd0ee16a2da4251943bed | import torch
from torch import Tensor
from torch import nn
class Model(nn.Module):
"""Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, embed_dim=768):
super().__init__()
assert img_size % patch_size == 0, 'Image size must be divisible by patch size'
img... |
BertPooler | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class BertPooler(nn.Module):
def __init__(self, config):
super(BertPooler, self).__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
def forward(self, hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | Ahren09/FinerFact | BertPooler | false | 18,268 | [
"MIT"
] | 9 | 68df3799fbfadd56fa69b019ca6fba0c482f21d3 | https://github.com/Ahren09/FinerFact/tree/68df3799fbfadd56fa69b019ca6fba0c482f21d3 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
def forward(self, hidden_states):
... |
BertSelfOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
... | 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.... | adymaharana/VLCStoryGan | BertSelfOutput | false | 18,269 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | from _paritybench_helpers import _mock_config
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
... |
ClassAttention | # 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 Tensor
from torch import nn
class ClassAttention(nn.Module):
"""ClassAttention as in CaiT
"""
def __init__(self, dim: 'int', heads: 'int'):
super().__init__()
self.num_heads = heads
self.scale = (dim // heads) ** -0.5
self.qkv = nn.Linear(dim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | alhamami/Object-Detection-And-Tracking | ClassAttention | false | 18,270 | [
"MIT"
] | 5 | a211a1dc103e812c539cd0ee16a2da4251943bed | https://github.com/alhamami/Object-Detection-And-Tracking/tree/a211a1dc103e812c539cd0ee16a2da4251943bed | import torch
from torch import Tensor
from torch import nn
class Model(nn.Module):
"""ClassAttention as in CaiT
"""
def __init__(self, dim: 'int', heads: 'int'):
super().__init__()
self.num_heads = heads
self.scale = (dim // heads) ** -0.5
self.qkv = nn.Linear(dim, dim * 3... |
IdentityMappingZero | # 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 IdentityMappingZero(nn.Module):
def __init__(self, out_channels: 'int', stride: 'int') ->None:
super(IdentityMappingZero, self).__init__()
self.out_channels = out_channels
self.stride = stride
pad_value = self.out_channels // 4
self... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | alvarobartt/understanding-resnet | IdentityMappingZero | false | 18,271 | [
"MIT"
] | 6 | 1e95aba607bf3fead740affb9ceafb7fde3ee0c6 | https://github.com/alvarobartt/understanding-resnet/tree/1e95aba607bf3fead740affb9ceafb7fde3ee0c6 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, out_channels: 'int', stride: 'int') ->None:
super().__init__()
self.out_channels = out_channels
self.stride = stride
pad_value = self.out_channels // 4
self.zeropad = nn.ZeroPad2d(padding=(0, 0, ... |
Neumann | # 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 Neumann(nn.Module):
def __init__(self, n_features, depth, residual_connection, mlp_depth,
init_type):
super().__init__()
self.depth = depth
self.n_features = n_features
self.residual_connection = residual_connection
... | 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 math
import torch.nn a... | alexprz/NeuMiss | Neumann | false | 18,272 | [
"BSD-3-Clause"
] | 9 | bf4f68ba4dd29b51ec3de9d6eef85deecebfa68d | https://github.com/alexprz/NeuMiss/tree/bf4f68ba4dd29b51ec3de9d6eef85deecebfa68d | import math
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_features, depth, residual_connection, mlp_depth,
init_type):
super().__init__()
self.depth = depth
self.n_features = n_features
self.residual_connection = residual_connection
... |
PositionwiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class PositionwiseFeedForward(nn.Module):
""" Two-layer position-wise feed-forward neural network. """
def __init__(self, d_in, d_hid, dropout=0.1, normalize_before=True):
super().__init__()
self.normalize_before = normalize_b... | 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 ... | alipay/Pyraformer | PositionwiseFeedForward | false | 18,273 | [
"Apache-2.0"
] | 7 | 84af4dbd93b7b96975b5034f0dde412005260123 | https://github.com/alipay/Pyraformer/tree/84af4dbd93b7b96975b5034f0dde412005260123 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
""" Two-layer position-wise feed-forward neural network. """
def __init__(self, d_in, d_hid, dropout=0.1, normalize_before=True):
super().__init__()
self.normalize_before = normalize_before
self... |
XCA | # 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 Tensor
import torch.nn.functional as F
from torch import nn
class XCA(nn.Module):
""" Cross-Covariance Attention (XCA) operation where the channels are updated using a weighted
sum. The weights are obtained from the (softmax normalized) Cross-covariance
matrix (Q^T K \\in 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
from torch._inductor.runtime.... | alhamami/Object-Detection-And-Tracking | XCA | false | 18,274 | [
"MIT"
] | 5 | a211a1dc103e812c539cd0ee16a2da4251943bed | https://github.com/alhamami/Object-Detection-And-Tracking/tree/a211a1dc103e812c539cd0ee16a2da4251943bed | import torch
from torch import Tensor
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
""" Cross-Covariance Attention (XCA) operation where the channels are updated using a weighted
sum. The weights are obtained from the (softmax normalized) Cross-covariance
matrix (Q^T K \\in... |
BackwardsNet | # 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 BackwardsNet(nn.Module):
def __init__(self, h, ydim):
super().__init__()
self.loss = torch.nn.CrossEntropyLoss()
self.fc1 = torch.nn.Linear(2 * h, h)
self.fc2 = torch.nn.Linear(h, ydim)
def forward(self, phiPrev, phi, atn):
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
from torch._inductor.runtime.... | alexandonian/neural-mmo | BackwardsNet | false | 18,275 | [
"MIT"
] | 4 | a4879c3399971ede81b64f507ee81706ba0d3366 | https://github.com/alexandonian/neural-mmo/tree/a4879c3399971ede81b64f507ee81706ba0d3366 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, h, ydim):
super().__init__()
self.loss = torch.nn.CrossEntropyLoss()
self.fc1 = torch.nn.Linear(2 * h, h)
self.fc2 = torch.nn.Linear(h, ydim)
def forward(self, phiPrev, phi, atn):
x = torch.c... |
QuadraticModel | # 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 QuadraticModel(torch.nn.Module):
def __init__(self, in_channels, class_num):
super(QuadraticModel, self).__init__()
x = torch.ones((in_channels, 1))
self.x = torch.nn.parameter.Parameter(x.uniform_(-10.0, 10.0).float())
def forward(self, A):
return torch.su... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cu... | alibaba/FederatedScope | QuadraticModel | false | 18,276 | [
"Apache-2.0"
] | 9 | fcf6d237624769ea094cfd68803901622f14fc23 | https://github.com/alibaba/FederatedScope/tree/fcf6d237624769ea094cfd68803901622f14fc23 | import torch
class Model(torch.nn.Module):
def __init__(self, in_channels, class_num):
super().__init__()
x = torch.ones((in_channels, 1))
self.x = torch.nn.parameter.Parameter(x.uniform_(-10.0, 10.0).float())
def forward(self, A):
return torch.sum(self.x * torch.matmul(A, se... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 3, kernel_size=7, stride=1, bias=False,
padding=3)
self.conv2 = nn.Conv2d(3, 3, kernel_size=7, stride=1, bias=False,
padding=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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | alirezadavoudi/tensorflow-vs-pytorch | Net | false | 18,277 | [
"MIT"
] | 4 | 1c0ccda8004591f3f29d4787d7b3bbfbc397523f | https://github.com/alirezadavoudi/tensorflow-vs-pytorch/tree/1c0ccda8004591f3f29d4787d7b3bbfbc397523f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 3, kernel_size=7, stride=1, bias=False,
padding=3)
self.conv2 = nn.Conv2d(3, 3, kernel_size=7, stride=1, bias=False,
padding=3)
self.... |
BlurPool2d | # 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.nn import *
import torch.nn as nn
class BlurPool2d(nn.Sequential):
"""Blur Pooling Layer (MaxPool2d replacement)
See: https://richzhang.github.io/antialiased-cnns/
Paper: https://arxiv.org/abs/1904.11486
"""
__constants__ = ['in_features']
_blur_kernel = torch.tensor([[... | 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.nn import *
import... | aktgpt/brevis | BlurPool2d | false | 18,278 | [
"MIT"
] | 8 | 0c3dcabd241ea50cafbc2012250804e1ecb7555e | https://github.com/aktgpt/brevis/tree/0c3dcabd241ea50cafbc2012250804e1ecb7555e | import torch
from torch.nn import *
import torch.nn as nn
class Model(nn.Sequential):
"""Blur Pooling Layer (MaxPool2d replacement)
See: https://richzhang.github.io/antialiased-cnns/
Paper: https://arxiv.org/abs/1904.11486
"""
__constants__ = ['in_features']
_blur_kernel = torch.tensor([[1 / 1... |
ResNetModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from typing import Dict
from abc import abstractmethod
from torch import nn
import torch.nn.functional as F
class DetectionModel(nn.Module):
"""
Base class describing any single object detection model
"""
def __init__(self, params: '{}'):
self._params = params
assert para... | 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 typing import Dict
from ... | aethersis/VisualEyeTracker | ResNetModel | false | 18,279 | [
"MIT"
] | 7 | 53723bd68972954249b53d6ba0ac1cbe93b8844f | https://github.com/aethersis/VisualEyeTracker/tree/53723bd68972954249b53d6ba0ac1cbe93b8844f | import torch
from typing import Dict
from abc import abstractmethod
from torch import nn
import torch.nn.functional as F
class DetectionModel(nn.Module):
"""
Base class describing any single object detection model
"""
def __init__(self, params: '{}'):
self._params = params
assert para... |
TopkMSELoss | # 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 TopkMSELoss(torch.nn.Module):
def __init__(self, topk) ->None:
super().__init__()
self.topk = topk
self.criterion = torch.nn.MSELoss(reduction='none')
def forward(self, output, label):
losses = self.criterion(output, label).mean(2).mean(1)
losses = ... | 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... | alipay/Pyraformer | TopkMSELoss | false | 18,280 | [
"Apache-2.0"
] | 7 | 84af4dbd93b7b96975b5034f0dde412005260123 | https://github.com/alipay/Pyraformer/tree/84af4dbd93b7b96975b5034f0dde412005260123 | import torch
class Model(torch.nn.Module):
def __init__(self, topk) ->None:
super().__init__()
self.topk = topk
self.criterion = torch.nn.MSELoss(reduction='none')
def forward(self, output, label):
losses = self.criterion(output, label).mean(2).mean(1)
losses = torch.... |
MMTensorNorm | # 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 MMTensorNorm(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, x):
mean = torch.mean(x, dim=self.dim).unsqueeze(self.dim)
std = torch.std(x, dim=self.dim).unsqueeze(self.dim)
return (x - m... | 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_... | amaankhan02/ChaLearn-2021-LAP | MMTensorNorm | false | 18,281 | [
"Apache-2.0",
"MIT"
] | 5 | 73227d642ebd69c3bde4065f22c6ad99b0cbe9f4 | https://github.com/amaankhan02/ChaLearn-2021-LAP/tree/73227d642ebd69c3bde4065f22c6ad99b0cbe9f4 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, x):
mean = torch.mean(x, dim=self.dim).unsqueeze(self.dim)
std = torch.std(x, dim=self.dim).unsqueeze(self.dim)
return (x - mean) / ... |
CPNLoss | # 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 CPNLoss(nn.Module):
"""This is the loss function used for Cascaded Pyramid Net. Note that the
original paper (arXiv:1711.07319) uses L2 loss. However the author (Shiyu)
who participated in the FashionAI Keypoints competition found tha... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn.functi... | alwc/fashionAI-keypoints-detection-pytorch | CPNLoss | false | 18,282 | [
"Apache-2.0"
] | 7 | 92061f66d89283e62093990dcb2dbdb03b8fa676 | https://github.com/alwc/fashionAI-keypoints-detection-pytorch/tree/92061f66d89283e62093990dcb2dbdb03b8fa676 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""This is the loss function used for Cascaded Pyramid Net. Note that the
original paper (arXiv:1711.07319) uses L2 loss. However the author (Shiyu)
who participated in the FashionAI Keypoints competition found that ... |
GeneratorLoss | # 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 GeneratorLoss(nn.Module):
"""
Generator (BCE) loss function
Args:
alpha (default: int=1): Coefficient by which map loss will be multiplied
beta (default: int=1): Coefficient by which point loss will be multiplied
"""
def __init__(self, alph... | 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
from torch ... | akanametov/pathgan | GeneratorLoss | false | 18,283 | [
"MIT"
] | 8 | d93464a9c2490532afdf7bbc0f60decdf2d0767d | https://github.com/akanametov/pathgan/tree/d93464a9c2490532afdf7bbc0f60decdf2d0767d | import torch
from torch import nn
class Model(nn.Module):
"""
Generator (BCE) loss function
Args:
alpha (default: int=1): Coefficient by which map loss will be multiplied
beta (default: int=1): Coefficient by which point loss will be multiplied
"""
def __init__(self, alpha=1, bet... |
ConvEncoder | # 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 functional as F
class ConvEncoder(nn.Module):
def __init__(self, embedding_size, act_fn='relu'):
super().__init__()
self.act_fn = getattr(F, act_fn)
self.embedding_size = embedding_size
self.conv_1 = nn.Conv2d(3, 32, 4, 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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | alec-tschantz/planet | ConvEncoder | false | 18,284 | [
"MIT"
] | 7 | bf68722993c93129263bb9606a582d24cb4f2a58 | https://github.com/alec-tschantz/planet/tree/bf68722993c93129263bb9606a582d24cb4f2a58 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, embedding_size, act_fn='relu'):
super().__init__()
self.act_fn = getattr(F, act_fn)
self.embedding_size = embedding_size
self.conv_1 = nn.Conv2d(3, 32, 4, stride=2)
... |
PositionwiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class LayerNormalization(nn.Module):
""" Layer normalization module """
def __init__(self, d_hid, eps=0.001):
super(LayerNormalization, self).__init__()
self.eps = eps
self.a_2 = nn.Parameter(torch.ones(d_hid), requires_grad=True)
self.b_2 = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | amaankhan02/ChaLearn-2021-LAP | PositionwiseFeedForward | false | 18,285 | [
"Apache-2.0",
"MIT"
] | 5 | 73227d642ebd69c3bde4065f22c6ad99b0cbe9f4 | https://github.com/amaankhan02/ChaLearn-2021-LAP/tree/73227d642ebd69c3bde4065f22c6ad99b0cbe9f4 | import torch
import torch.nn as nn
class LayerNormalization(nn.Module):
""" Layer normalization module """
def __init__(self, d_hid, eps=0.001):
super().__init__()
self.eps = eps
self.a_2 = nn.Parameter(torch.ones(d_hid), requires_grad=True)
self.b_2 = nn.Parameter(torch.zeros... |
MemoryUpdater | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class BertSelfAttention(nn.Module):
def __init__(self, config):
super(BertSelfAttention, self).__init__()
if config.hidden_size % config.num_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.... | adymaharana/VLCStoryGan | MemoryUpdater | false | 18,286 | [
"MIT"
] | 10 | 74112404689e8144c2ed2d375e1e5a1cde09debb | https://github.com/adymaharana/VLCStoryGan/tree/74112404689e8144c2ed2d375e1e5a1cde09debb | from _paritybench_helpers import _mock_config
import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class BertSelfAttention(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
... |
GaussianKullbackLeiblerLoss | # 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 Loss(nn.Module):
"""Base loss class."""
def __init__(self):
super(Loss, self).__init__()
class GaussianKullbackLeiblerLoss(Loss):
"""Gaussian empirical KL divergence class."""
def __init__(self) ->None:
super(GaussianKullbackLeiblerLoss, sel... | 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... | aloctavodia/kulprit | GaussianKullbackLeiblerLoss | false | 18,287 | [
"MIT"
] | 4 | ab017074f7428154b8834515512db259c5f635e8 | https://github.com/aloctavodia/kulprit/tree/ab017074f7428154b8834515512db259c5f635e8 | import torch
import torch.nn as nn
class Loss(nn.Module):
"""Base loss class."""
def __init__(self):
super().__init__()
class Model(Loss):
"""Gaussian empirical KL divergence class."""
def __init__(self) ->None:
super().__init__()
def forward(self, P: 'torch.tensor', Q: 'torch... |
STLayer | # 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 StraightThrough(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
return torch.sign(x)
@staticmethod
def backward(ctx, grad):
return grad.clamp(-1.0, 1.0)
class STLayer(torch.nn.Module):
def __init__(self):
super(STLayer, 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... | alper111/affordance-learning | STLayer | false | 18,288 | [
"MIT"
] | 3 | 21b70f689a8299c6af7cd4ed763fc3133cf1681f | https://github.com/alper111/affordance-learning/tree/21b70f689a8299c6af7cd4ed763fc3133cf1681f | import torch
class StraightThrough(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
return torch.sign(x)
@staticmethod
def backward(ctx, grad):
return grad.clamp(-1.0, 1.0)
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
self.fu... |
AdaptiveGeneratorLoss | # 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 AdaptiveGeneratorLoss(nn.Module):
"""
Adaptive Generator (BCE) loss function (depends on losses of Discriminators)
Args:
alpha (default: int=3): Coefficient for map and point losses
"""
def __init__(self, alpha=3):
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 libdevice, math as tl_math
from torch ... | akanametov/pathgan | AdaptiveGeneratorLoss | false | 18,289 | [
"MIT"
] | 8 | d93464a9c2490532afdf7bbc0f60decdf2d0767d | https://github.com/akanametov/pathgan/tree/d93464a9c2490532afdf7bbc0f60decdf2d0767d | import torch
from torch import nn
class Model(nn.Module):
"""
Adaptive Generator (BCE) loss function (depends on losses of Discriminators)
Args:
alpha (default: int=3): Coefficient for map and point losses
"""
def __init__(self, alpha=3):
super().__init__()
self.adv_crite... |
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.2):
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.... | alipay/Pyraformer | MultiHeadAttention | false | 18,290 | [
"Apache-2.0"
] | 7 | 84af4dbd93b7b96975b5034f0dde412005260123 | https://github.com/alipay/Pyraformer/tree/84af4dbd93b7b96975b5034f0dde412005260123 | 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.2):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.