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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn import Parameter
from torch.nn.parameter import Parameter
from torch.nn.modules.normalization import LayerNorm
from torch.optim.lr_scheduler import *
class LayerNorm(nn.Module):
def __init__(self, hidden_size, eps=0.0001):
super(LayerNorm, 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
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
from torch.nn import Parameter
from torch.nn.parameter im... | chunhuililili/mt_dnn | LayerNorm | false | 10,192 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn as nn
from torch.nn import Parameter
from torch.nn.parameter import Parameter
from torch.nn.modules.normalization import LayerNorm
from torch.optim.lr_scheduler import *
class Model(nn.Module):
def __init__(self, hidden_size, eps=0.0001):
super().__init__()
self.alpha... |
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.parameter import Parameter
class GraphConvolution(nn.Module):
def __init__(self, in_features, out_features):
super(GraphConvolution, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.w... | 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
from torch.nn.parameter import Parameter
asser... | iDMG-dynamicGCN/DatasetCollection | GCN | false | 10,193 | [
"MIT"
] | 0 | ad761b38bc86af1dd3aee6c72e819d6f00252164 | https://github.com/iDMG-dynamicGCN/DatasetCollection/tree/ad761b38bc86af1dd3aee6c72e819d6f00252164 | import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class GraphConvolution(nn.Module):
def __init__(self, in_features, out_features):
super().__init__()
self.in_features = in_features
self.out_features = out_features
self.weight = Parameter(torc... |
TorchLogCosh | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as _torch
class TorchLogCosh(_torch.nn.Module):
"""
Log(cosh) activation function for PyTorch modules
"""
def __init__(self):
"""
Init method.
"""
super().__init__()
def forward(self, input):
"""
Forward pass of the functi... | 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 as _torch
assert_size_stride = torch._C._dynamo.g... | inailuig/netket | TorchLogCosh | false | 10,194 | [
"Apache-2.0"
] | 0 | ab57a6fb019edb9ac298969950724781f2ae2b22 | https://github.com/inailuig/netket/tree/ab57a6fb019edb9ac298969950724781f2ae2b22 | import torch
import torch as _torch
class Model(_torch.nn.Module):
"""
Log(cosh) activation function for PyTorch modules
"""
def __init__(self):
"""
Init method.
"""
super().__init__()
def forward(self, input):
"""
Forward pass of the function.
... |
AutoEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class AutoEncoder(nn.Module):
def __init__(self):
super(AutoEncoder, self).__init__()
self.encoder1 = nn.Conv2d(3, 16, 3, padding=1)
self.encoder2 = nn.Conv2d(16, 8, 3, padding=1)
self.encoder3 =... | 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 ... | gjustin40/Pytorch-Cookbook | AutoEncoder | false | 10,195 | [
"MIT"
] | 0 | 069514d05b00d07521e1a1a028d0746b65099586 | https://github.com/gjustin40/Pytorch-Cookbook/tree/069514d05b00d07521e1a1a028d0746b65099586 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
def __init__(self):
super().__init__()
self.encoder1 = nn.Conv2d(3, 16, 3, padding=1)
self.encoder2 = nn.Conv2d(16, 8, 3, padding=1)
self.encoder3 = nn.Conv2d(8, 4, 3, pad... |
DQN | # 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 DQN(nn.Module):
"""DQN network, three full connection layers
"""
def __init__(self):
super(DQN, self).__init__()
self.fc1 = nn.Linear(4, 16)
self.fc1.weight.data.normal_(0, 0.1)
self.fc2 = nn.Linear(16... | 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... | ivanwhaf/RL | DQN | false | 10,196 | [
"MIT"
] | 0 | 1610b3684269b1d60543c60460e9ee65309594ee | https://github.com/ivanwhaf/RL/tree/1610b3684269b1d60543c60460e9ee65309594ee | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""DQN network, three full connection layers
"""
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(4, 16)
self.fc1.weight.data.normal_(0, 0.1)
self.fc2 = nn.Linear(16, 2)
... |
GeLU | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class GeLU(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return 0.5 * x * (1 + F.tanh(0.7978845608 * (x + 0.044715 * x * x * x))
)
def get_inputs():
return [torch.rand([4, 4, 4, 4]... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | irustandi/sentiment-discovery | GeLU | false | 10,197 | [
"BSD-3-Clause"
] | 0 | a2e074f33bbac94ec9dba111a91da026633dad67 | https://github.com/irustandi/sentiment-discovery/tree/a2e074f33bbac94ec9dba111a91da026633dad67 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return 0.5 * x * (1 + F.tanh(0.7978845608 * (x + 0.044715 * x * x * x))
)
def get_inputs():
return [torch.rand([4, 4, 4, 4... |
Generator | # 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 Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.relu = nn.ReLU(inplace=True)
self.e_conv1 = nn.Conv2d(3, 3, 1, 1, 0, bias=True)
self.e_conv2 = nn.Conv2d(3, 3, 3, 1, 1, bias=True)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
import t... | goldenbili/SRGAN_Test | Generator | false | 10,198 | [
"MIT"
] | 0 | 06705c92abd5b7084ae878a4746060760bcff5c3 | https://github.com/goldenbili/SRGAN_Test/tree/06705c92abd5b7084ae878a4746060760bcff5c3 | import torch
from torch import nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
self.relu = nn.ReLU(inplace=True)
self.e_conv1 = nn.Conv2d(3, 3, 1, 1, 0, bias=True)
self.e_conv2 = nn.Conv2d(3, 3, 3, 1, 1, bias=True)
self.e_conv3 = n... |
HLCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.... | chunhuililili/mt_dnn | HLCriterion | false | 10,199 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
Cosine | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from _paritybench_helpers import _mock_config
import torch
from torch.optim.lr_scheduler import *
class Cosine(torch.nn.Module):
def __init__(self, config):
super().__init__()
def forward(self, src, tgt):
src = src.float()
tgt = tgt.float()
return (torch.matmul(src, tgt.trans... | 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.optim.lr... | chunhuililili/mt_dnn | Cosine | false | 10,200 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | from _paritybench_helpers import _mock_config
import torch
from torch.optim.lr_scheduler import *
class Model(torch.nn.Module):
def __init__(self, config):
super().__init__()
def forward(self, src, tgt):
src = src.float()
tgt = tgt.float()
return (torch.matmul(src, tgt.transp... |
BiLinearSim | # 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.optim.lr_scheduler import *
class BiLinearSim(torch.nn.Module):
def __init__(self, config):
super().__init__()
self.linear = torch.nn.Linear(config.hidden_size, config.
hidden_size, bias=False)
def forward(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.optim.lr_scheduler import *
assert_size_stride = torch._C._dynamo.gua... | chunhuililili/mt_dnn | BiLinearSim | false | 10,201 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | from _paritybench_helpers import _mock_config
import torch
from torch.optim.lr_scheduler import *
class Model(torch.nn.Module):
def __init__(self, config):
super().__init__()
self.linear = torch.nn.Linear(config.hidden_size, config.
hidden_size, bias=False)
def forward(self, src,... |
JSCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.... | chunhuililili/mt_dnn | JSCriterion | false | 10,202 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
KlCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.... | chunhuililili/mt_dnn | KlCriterion | false | 10,203 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
Mnist_CNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.quantization
import torch.onnx
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Mnist_CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | hongsam123/PyTorch-tutorials-kr | Mnist_CNN | false | 10,204 | [
"BSD-3-Clause"
] | 0 | e48bbbc7088bf6b9da66abb8862b8d0539662bd5 | https://github.com/hongsam123/PyTorch-tutorials-kr/tree/e48bbbc7088bf6b9da66abb8862b8d0539662bd5 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.quantization
import torch.onnx
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__()
self.conv1 = nn.Con... |
Pooler | # 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
from torch.optim.lr_scheduler import *
def linear(x):
return x
def activation(func_a):
"""Activation function wrapper
"""
try:
f = eval(func_a)
except:
f = linear
return f
class DropoutWrapper(nn.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
import torch.nn.functional as F
import torch.nn as nn
from torch.optim.lr_schedu... | chunhuililili/mt_dnn | Pooler | false | 10,205 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.optim.lr_scheduler import *
def linear(x):
return x
def activation(func_a):
"""Activation function wrapper
"""
try:
f = eval(func_a)
except:
f = linear
return f
class DropoutWrapper(nn.Module):
... |
NsKlCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
def stable_kl(logit, target, epsilon=1e-06, reduce=True):
logit = logit.view(-1, logit.size(-1)).float()
target = target.view(-1, target.size(-1)).float()
bs = logit.size(0)
p = ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn.functi... | chunhuililili/mt_dnn | NsKlCriterion | false | 10,206 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
def stable_kl(logit, target, epsilon=1e-06, reduce=True):
logit = logit.view(-1, logit.size(-1)).float()
target = target.view(-1, target.size(-1)).float()
bs = logit.size(0)
p = ... |
CeCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.nn.modules.... | chunhuililili/mt_dnn | CeCriterion | false | 10,207 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
MseCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
assert_siz... | chunhuililili/mt_dnn | MseCriterion | false | 10,208 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
MultiheadAttentionWrapper | # 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
import torch.nn as nn
from torch.nn.utils import weight_norm
from torch.optim.lr_scheduler import *
def linear(x):
return x
def activation(func_a):
"""Activation function wrapper
"""
try:
f = eval(func_a)
except:
f = linear
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.functional as F
import torch.nn as nn
from torch.nn.utils import weight_norm
from torch.optim.lr_scheduler import *
assert_s... | chunhuililili/mt_dnn | MultiheadAttentionWrapper | false | 10,209 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn.utils import weight_norm
from torch.optim.lr_scheduler import *
def linear(x):
return x
def activation(func_a):
"""Activation function wrapper
"""
try:
f = eval(func_a)
except:
f = linear
return ... |
Network | # 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 Network(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 10 * 10, 120)
... | 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_... | ibrahimalmakky/py4ai | Network | false | 10,210 | [
"MIT"
] | 0 | 224f54086523314ff9c7133680f119c62f6ea249 | https://github.com/ibrahimalmakky/py4ai/tree/224f54086523314ff9c7133680f119c62f6ea249 | 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(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 10 * 10, 120)
... |
ComplexConv | # 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 ComplexConv(nn.Module):
def __init__(self, in_channel, out_channel, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=True):
super(ComplexConv, self).__init__()
self.device = torch.device('cuda' if torch.cuda.is_available() else
... | 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... | iseeklin/Electromagnetic-Signal-Recognition-Using-Deep-Learning | ComplexConv | false | 10,211 | [
"Apache-2.0"
] | 0 | be78a2d966f33fd90567b21295cda1c1d472e14a | https://github.com/iseeklin/Electromagnetic-Signal-Recognition-Using-Deep-Learning/tree/be78a2d966f33fd90567b21295cda1c1d472e14a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channel, out_channel, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=True):
super().__init__()
self.device = torch.device('cuda' if torch.cuda.is_available() else
'cpu')
self... |
NsSymKlCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
def stable_kl(logit, target, epsilon=1e-06, reduce=True):
logit = logit.view(-1, logit.size(-1)).float()
target = target.view(-1, target.size(-1)).float()
bs = logit.size(0)
p = ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn.functi... | chunhuililili/mt_dnn | NsSymKlCriterion | false | 10,212 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
def stable_kl(logit, target, epsilon=1e-06, reduce=True):
logit = logit.view(-1, logit.size(-1)).float()
target = target.view(-1, target.size(-1)).float()
bs = logit.size(0)
p = ... |
Pooling | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Pooling(nn.Module):
def __init__(self, pooling_type=['GAP']):
super(Pooling, self).__init__()
self.pooling = []
... | 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 as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils... | heebinYoo/proxy-synthesis-confidence-control-new | Pooling | false | 10,213 | [
"Apache-2.0"
] | 0 | c591cdffc30cf933bd242ba5646d2436a42a3181 | https://github.com/heebinYoo/proxy-synthesis-confidence-control-new/tree/c591cdffc30cf933bd242ba5646d2436a42a3181 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, pooling_type=['GAP']):
super().__init__()
self.pooling = []
for method in p... |
SymKlCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.... | chunhuililili/mt_dnn | SymKlCriterion | false | 10,214 | [
"MIT"
] | 0 | 4c6efaf21724c7b8103a05e46b5b44d7b246225e | https://github.com/chunhuililili/mt_dnn/tree/4c6efaf21724c7b8103a05e46b5b44d7b246225e | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
Feedforward | # 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 Feedforward(torch.nn.Module):
def __init__(self, input_size, hidden_size=100):
super(Feedforward, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.fc1 = torch.nn.Linear(self.input_size, self.hidden_size)
self.relu = torch... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C... | jacob-parnell-rozetta/longformer_coverage | Feedforward | false | 10,215 | [
"Apache-2.0"
] | 0 | 59268bc7ae7eeb962c43080e524eaf1e62100b6c | https://github.com/jacob-parnell-rozetta/longformer_coverage/tree/59268bc7ae7eeb962c43080e524eaf1e62100b6c | import torch
class Model(torch.nn.Module):
def __init__(self, input_size, hidden_size=100):
super().__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.fc1 = torch.nn.Linear(self.input_size, self.hidden_size)
self.relu = torch.nn.ReLU()
self... |
ToMono | # 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 ToMono(nn.Module):
def forward(self, waveform: 'torch.Tensor') ->torch.Tensor:
return torch.mean(waveform, dim=0, keepdim=True)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | icyda17/very-deep-CNNs | ToMono | false | 10,216 | [
"Apache-2.0"
] | 0 | c275ef222d50dae90e508345ec3be5adfa5e33ce | https://github.com/icyda17/very-deep-CNNs/tree/c275ef222d50dae90e508345ec3be5adfa5e33ce | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, waveform: 'torch.Tensor') ->torch.Tensor:
return torch.mean(waveform, dim=0, keepdim=True)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
VAE_genes | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
from torch import nn
from torch.nn import functional as F
class VAE_genes(nn.Module):
def __init__(self):
super(VAE_genes, self).__init__()
self.input_linear = nn.Linear(907, 500)
self.enc_middle = nn.Linear(500, 100)
self.enc_1 = nn.Linear(100... | import torch
from torch import device
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... | helenaandres/adversarial-generation-of-gene-expression-data | VAE_genes | false | 10,217 | [
"MIT"
] | 0 | 9a10f0c364b7daa789ae75ab5b51ed5c7cbcbeb1 | https://github.com/helenaandres/adversarial-generation-of-gene-expression-data/tree/9a10f0c364b7daa789ae75ab5b51ed5c7cbcbeb1 | import torch
import torch.utils.data
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.input_linear = nn.Linear(907, 500)
self.enc_middle = nn.Linear(500, 100)
self.enc_1 = nn.Linear(100, 5)
self.e... |
Normalize | # 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 Normalize(nn.Module):
def forward(self, waveform: 'torch.Tensor') ->torch.Tensor:
return (waveform - waveform.mean()) / waveform.std()
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._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | icyda17/very-deep-CNNs | Normalize | false | 10,218 | [
"Apache-2.0"
] | 0 | c275ef222d50dae90e508345ec3be5adfa5e33ce | https://github.com/icyda17/very-deep-CNNs/tree/c275ef222d50dae90e508345ec3be5adfa5e33ce | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, waveform: 'torch.Tensor') ->torch.Tensor:
return (waveform - waveform.mean()) / waveform.std()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
Pad | # 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 Pad(nn.Module):
def __init__(self, value: 'float', size: 'int'):
super().__init__()
self.value = value
self.size = size
def forward(self, waveform: 'torch.Tensor') ->torch.Tensor:
return F.pad(waveform, ... | 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... | icyda17/very-deep-CNNs | Pad | false | 10,219 | [
"Apache-2.0"
] | 0 | c275ef222d50dae90e508345ec3be5adfa5e33ce | https://github.com/icyda17/very-deep-CNNs/tree/c275ef222d50dae90e508345ec3be5adfa5e33ce | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, value: 'float', size: 'int'):
super().__init__()
self.value = value
self.size = size
def forward(self, waveform: 'torch.Tensor') ->torch.Tensor:
return F.pad(waveform... |
SeeInDark | # 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 SeeInDark(nn.Module):
def __init__(self, num_classes=10):
super(SeeInDark, self).__init__()
self.conv1_1 = nn.Conv2d(4, 32, kernel_size=3, stride=1, padding=1)
self.conv1_2 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1)
self.pool1 ... | 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_... | hyeokjae-choi/pytorch-Learning-to-See-in-the-Dark | SeeInDark | false | 10,220 | [
"MIT"
] | 0 | b32bf991072decb3aea348d8cd59acbf34d5da2c | https://github.com/hyeokjae-choi/pytorch-Learning-to-See-in-the-Dark/tree/b32bf991072decb3aea348d8cd59acbf34d5da2c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.conv1_1 = nn.Conv2d(4, 32, kernel_size=3, stride=1, padding=1)
self.conv1_2 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1)
self.pool1 = nn.MaxPool2d(kern... |
HardtanhBoundToPOTNet | # 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.nn import Conv2d
from torch.nn import Hardtanh
from torch.nn.functional import relu
from torch.nn.functional import hardtanh
import torch.nn.functional
class HardtanhBoundToPOTNet(torch.nn.Module):
def __init__(self):
super(HardtanhBoundToPOTNet, self).__init__()
self.conv... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn import Conv2d
f... | isabella232/model_optimization | HardtanhBoundToPOTNet | false | 10,221 | [
"Apache-2.0"
] | 0 | 074d1dfd8b4d18e57c6186c0ec5e49eb17a0fc7a | https://github.com/isabella232/model_optimization/tree/074d1dfd8b4d18e57c6186c0ec5e49eb17a0fc7a | import torch
from torch.nn import Conv2d
from torch.nn import Hardtanh
from torch.nn.functional import relu
from torch.nn.functional import hardtanh
import torch.nn.functional
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = Conv2d(3, 3, kernel_size=1, stride=1)
... |
Unet | # 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 crop(image, new_shape):
plus_h, plus_w = 0, 0
if new_shape[2] % 2 != 0:
plus_h = 1
if new_shape[3] % 2 != 0:
plus_w = 1
middle_height = image.shape[2] // 2
middle_weight = image.shape[3] // 2
go_height = new_shape[2] // 2
go_weight = n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | furkannturkmen/pytorch-CNN-architecture | Unet | false | 10,222 | [
"MIT"
] | 0 | 6a864811f51409c1526224c288fe608010e0c888 | https://github.com/furkannturkmen/pytorch-CNN-architecture/tree/6a864811f51409c1526224c288fe608010e0c888 | import torch
import torch.nn as nn
def crop(image, new_shape):
plus_h, plus_w = 0, 0
if new_shape[2] % 2 != 0:
plus_h = 1
if new_shape[3] % 2 != 0:
plus_w = 1
middle_height = image.shape[2] // 2
middle_weight = image.shape[3] // 2
go_height = new_shape[2] // 2
go_weight = n... |
Fusion | # 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 Fusion(nn.Module):
def __init__(self, input_dim, hidden_dim):
super(Fusion, self).__init__()
self.linear = nn.Linear(input_dim * 4, hidden_dim, bias=True)
self.tanh = nn.Tanh()
def forward(self, x, y):
z = torch.cat([x, y, x * y, x - y... | 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 ... | hgrhgy/NumSeq2SQL | Fusion | false | 10,223 | [
"MIT"
] | 0 | 6f22fdf108736f979afa2dbd3af14aa9ad4718aa | https://github.com/hgrhgy/NumSeq2SQL/tree/6f22fdf108736f979afa2dbd3af14aa9ad4718aa | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim, hidden_dim):
super().__init__()
self.linear = nn.Linear(input_dim * 4, hidden_dim, bias=True)
self.tanh = nn.Tanh()
def forward(self, x, y):
z = torch.cat([x, y, x * y, x - y], dim=2)
... |
CRF | # 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 CRF(nn.Module):
"""
Implements Conditional Random Fields that can be trained via
backpropagation.
"""
def __init__(self, num_tags):
super(CRF, self).__init__()
self.num_tags = num_tags
self.transitions = nn.Parameter(torch.Tensor(n... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | jbogensperger/DRUG_CROSSNER | CRF | false | 10,224 | [
"MIT"
] | 0 | c82fc4ce6fd6229b48d28bafffe38f5ea3dcd6aa | https://github.com/jbogensperger/DRUG_CROSSNER/tree/c82fc4ce6fd6229b48d28bafffe38f5ea3dcd6aa | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Implements Conditional Random Fields that can be trained via
backpropagation.
"""
def __init__(self, num_tags):
super().__init__()
self.num_tags = num_tags
self.transitions = nn.Parameter(torch.Tensor(num_tags... |
BertLastCLSModule | # 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 BertLastCLSModule(nn.Module):
def __init__(self, dropout_prob=0.0):
super().__init__()
self.dropout = nn.Dropout(dropout_prob)
def forward(self, input):
last_hidden = input[-1][:, 0, :]
out = self.dropout(last_hidden)
return out... | 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... | jdunnmon/emmental-tutorials | BertLastCLSModule | false | 10,225 | [
"MIT"
] | 0 | 2aa6c86e2e74943fbf75f4df1e70c5b8614c6c49 | https://github.com/jdunnmon/emmental-tutorials/tree/2aa6c86e2e74943fbf75f4df1e70c5b8614c6c49 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, dropout_prob=0.0):
super().__init__()
self.dropout = nn.Dropout(dropout_prob)
def forward(self, input):
last_hidden = input[-1][:, 0, :]
out = self.dropout(last_hidden)
return out
def get_i... |
SelfGating | # 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 as th
import torch.nn as nn
class SelfGating(nn.Module):
def __init__(self, input_dim):
super(SelfGating, self).__init__()
self.fc = nn.Linear(input_dim, input_dim)
def forward(self, input_tensor):
"""Feature gating as used in S3D-G.
"""
spatio... | 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... | inbalcroitoru/Information-retrieval-Audio-retrieval-with-text-queries | SelfGating | false | 10,226 | [
"Apache-2.0"
] | 0 | d98ee159c61a8a9a1c433f0bfed14e7005215d5f | https://github.com/inbalcroitoru/Information-retrieval-Audio-retrieval-with-text-queries/tree/d98ee159c61a8a9a1c433f0bfed14e7005215d5f | import torch
import torch as th
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.fc = nn.Linear(input_dim, input_dim)
def forward(self, input_tensor):
"""Feature gating as used in S3D-G.
"""
spatiotemporal_average = th... |
QLinear | # 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 as nn
import torch.nn.functional as F
import torch.autograd as A
from torch.autograd.function import once_differentiable
from torch.nn.parameter import Parameter
import torch.nn.parallel
import torch.optim
import torch.utils.data
class WeightQuantization(A.Functio... | 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 Tensor
import torch.nn as nn
import torch.autograd as A
from t... | i207M/pytorch-cifar | QLinear | false | 10,227 | [
"MIT"
] | 0 | df4417b6d0a25515ac82b5aa6151ae2135b2cd5c | https://github.com/i207M/pytorch-cifar/tree/df4417b6d0a25515ac82b5aa6151ae2135b2cd5c | import torch
from torch import Tensor
import torch.nn as nn
import torch.nn.functional as F
import torch.autograd as A
from torch.autograd.function import once_differentiable
from torch.nn.parameter import Parameter
import torch.nn.parallel
import torch.optim
import torch.utils.data
class WeightQuantization(A.Functio... |
FusionLayer | # 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 FusionLayer(nn.Module):
"""
vector based fusion
m(x, y) = W([x, y, x * y, x - y]) + b
g(x, y) = w([x, y, x * y, x - y]) + b
:returns g(x, y) * m(x, y) + (1 - g(x, y)) * x
"""
def __init__(self, input_dim):
super(FusionLayer, self).__init__(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | hgrhgy/NumSeq2SQL | FusionLayer | false | 10,228 | [
"MIT"
] | 0 | 6f22fdf108736f979afa2dbd3af14aa9ad4718aa | https://github.com/hgrhgy/NumSeq2SQL/tree/6f22fdf108736f979afa2dbd3af14aa9ad4718aa | import torch
import torch.nn as nn
class Model(nn.Module):
"""
vector based fusion
m(x, y) = W([x, y, x * y, x - y]) + b
g(x, y) = w([x, y, x * y, x - y]) + b
:returns g(x, y) * m(x, y) + (1 - g(x, y)) * x
"""
def __init__(self, input_dim):
super().__init__()
self.linear_f... |
QConv2d | # 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 as nn
import torch.autograd as A
from torch.autograd.function import once_differentiable
from torch.nn.parameter import Parameter
import torch.nn.parallel
import torch.optim
import torch.utils.data
class WeightQuantization(A.Function):
@staticmethod
def f... | 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 Tensor
import torch.nn as nn
import torch.autograd as A
from t... | i207M/pytorch-cifar | QConv2d | false | 10,229 | [
"MIT"
] | 0 | df4417b6d0a25515ac82b5aa6151ae2135b2cd5c | https://github.com/i207M/pytorch-cifar/tree/df4417b6d0a25515ac82b5aa6151ae2135b2cd5c | import torch
from torch import Tensor
import torch.nn as nn
import torch.autograd as A
from torch.autograd.function import once_differentiable
from torch.nn.parameter import Parameter
import torch.nn.parallel
import torch.optim
import torch.utils.data
class WeightQuantization(A.Function):
@staticmethod
def f... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
class Attention(nn.Module):
"""A generic attention module for a decoder in seq2seq"""
def __init__(self, dim, use_tanh=False, C=10):
super(Attention, self).__init__()
self.use_tanh = use_tanh
self.project_query = nn.Linear(dim, 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.triton_helpers import libdevice
import math
from to... | iamstevepaul/MRTA-Attention | Attention | false | 10,230 | [
"MIT"
] | 0 | fc177440f7354212c41ad02ef76fdda43cc0aa57 | https://github.com/iamstevepaul/MRTA-Attention/tree/fc177440f7354212c41ad02ef76fdda43cc0aa57 | import math
import torch
from torch import nn
class Model(nn.Module):
"""A generic attention module for a decoder in seq2seq"""
def __init__(self, dim, use_tanh=False, C=10):
super().__init__()
self.use_tanh = use_tanh
self.project_query = nn.Linear(dim, dim)
self.project_ref ... |
AugCNN | # 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 apply_init_(modules):
"""
Initialize NN modules
"""
for m in modules:
if isinstance(m, nn.Conv2d):
nn.init.xavier_uniform_(m.weight)
if m.bias is not None:
nn.init.constant_(m.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
import torch.nn.functional as F
assert_size_stride = torch... | jajajag/auto-drac | AugCNN | false | 10,231 | [
"MIT"
] | 0 | 2241f9f5f10a4d863a8b9d198da1d39e5feb59a0 | https://github.com/jajajag/auto-drac/tree/2241f9f5f10a4d863a8b9d198da1d39e5feb59a0 | import torch
import torch.nn as nn
import torch.nn.functional as F
def apply_init_(modules):
"""
Initialize NN modules
"""
for m in modules:
if isinstance(m, nn.Conv2d):
nn.init.xavier_uniform_(m.weight)
if m.bias is not None:
nn.init.constant_(m.bias, 0... |
MeanAct | # 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 MeanAct(nn.Module):
def __init__(self):
super(MeanAct, self).__init__()
def forward(self, x):
return torch.clamp(torch.exp(x), min=1e-05, max=1000000.0)
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._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | jdasam/scDCC | MeanAct | false | 10,232 | [
"Apache-2.0"
] | 0 | 8ebaed766db5ad56021983ebc13e9a60b6c7b453 | https://github.com/jdasam/scDCC/tree/8ebaed766db5ad56021983ebc13e9a60b6c7b453 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.clamp(torch.exp(x), min=1e-05, max=1000000.0)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
BatchDense | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class BatchDense(nn.Module):
def __init__(self, batch, in_features, out_features, bias_init=None):
super(BatchDense, self).__init__()
self.batch = batch
self.in_features = in_features
self.out_... | 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
from torch.nn.parameter import Parameter
asser... | iloncka/neurotrees | BatchDense | false | 10,233 | [
"MIT"
] | 0 | ddb52dc0e7ac1cf67a426b401ba06149807e03ec | https://github.com/iloncka/neurotrees/tree/ddb52dc0e7ac1cf67a426b401ba06149807e03ec | import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, batch, in_features, out_features, bias_init=None):
super().__init__()
self.batch = batch
self.in_features = in_features
self.out_features = out_featur... |
VAE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
from torch import nn
from torch.nn import functional as F
class VAE(nn.Module):
def __init__(self):
super(VAE, self).__init__()
self.input_linear = nn.Linear(4297, 2000)
self.enc_middle = nn.Linear(2000, 100)
self.enc_1 = nn.Linear(100, 5)
... | import torch
from torch import device
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... | helenaandres/adversarial-generation-of-gene-expression-data | VAE | false | 10,234 | [
"MIT"
] | 0 | 9a10f0c364b7daa789ae75ab5b51ed5c7cbcbeb1 | https://github.com/helenaandres/adversarial-generation-of-gene-expression-data/tree/9a10f0c364b7daa789ae75ab5b51ed5c7cbcbeb1 | import torch
import torch.utils.data
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.input_linear = nn.Linear(4297, 2000)
self.enc_middle = nn.Linear(2000, 100)
self.enc_1 = nn.Linear(100, 5)
sel... |
DispAct | # 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 DispAct(nn.Module):
def __init__(self):
super(DispAct, self).__init__()
def forward(self, x):
return torch.clamp(F.softplus(x), min=0.0001, max=10000.0)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def ge... | 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... | jdasam/scDCC | DispAct | false | 10,235 | [
"Apache-2.0"
] | 0 | 8ebaed766db5ad56021983ebc13e9a60b6c7b453 | https://github.com/jdasam/scDCC/tree/8ebaed766db5ad56021983ebc13e9a60b6c7b453 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.clamp(F.softplus(x), min=0.0001, max=10000.0)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs()... |
KLDLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class KLDLoss(nn.Module):
def forward(self, mu, logvar):
return -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
def get_inputs():
return [torch.rand([4, 4, 4, 4]), 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._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | izhorvath/MetGAN | KLDLoss | false | 10,236 | [
"BSD-3-Clause"
] | 0 | aca85fb3306d2515a65c8d525cd78e1147ba7e1b | https://github.com/izhorvath/MetGAN/tree/aca85fb3306d2515a65c8d525cd78e1147ba7e1b | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def forward(self, mu, logvar):
return -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
PerturbationModule | # 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 PerturbationModule(nn.Module):
def __init__(self, T):
super(PerturbationModule, self).__init__()
self.T = T
self.training = False
self.conv_block = None
def forward(self, x):
if not self.tra... | 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... | jeffkinnison/pytorch-CycleGAN-and-pix2pix | PerturbationModule | false | 10,237 | [
"BSD-3-Clause"
] | 0 | e47041fa4ffa80ad5948d2d1125ec94c34c5947d | https://github.com/jeffkinnison/pytorch-CycleGAN-and-pix2pix/tree/e47041fa4ffa80ad5948d2d1125ec94c34c5947d | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, T):
super().__init__()
self.T = T
self.training = False
self.conv_block = None
def forward(self, x):
if not self.training:
x = x + self.T * t... |
CIoU | # 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 CIoU(nn.Module):
def __init__(self):
super(CIoU, self).__init__()
def forward(self, inputs, targets):
size = len(inputs)
uL_truth = targets[:, 0:2]
lR_truth = targets[:, 2:4]
uL_pred = inputs[:, 0:2]
lR_pred = inputs[:, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_... | jcscheufele/CS545_Final | CIoU | false | 10,238 | [
"MIT"
] | 0 | d86858408a9a0aab82b5d2b7e12847023d939e2e | https://github.com/jcscheufele/CS545_Final/tree/d86858408a9a0aab82b5d2b7e12847023d939e2e | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, inputs, targets):
size = len(inputs)
uL_truth = targets[:, 0:2]
lR_truth = targets[:, 2:4]
uL_pred = inputs[:, 0:2]
lR_pred = inputs[:, 2:4]
... |
BiaffineScorer | # 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 BiaffineScorer(nn.Module):
def __init__(self, input1_size, input2_size, output_size):
super().__init__()
self.W_bilin = nn.Bilinear(input1_size + 1, input2_size + 1,
output_size)
self.W_bilin.weight.data.zero_()
self.W_bilin.bia... | 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... | giorgianb/stanza | BiaffineScorer | false | 10,239 | [
"Apache-2.0"
] | 0 | e1ff1ab73c228739fea3ef5c012a9f1042bef2e3 | https://github.com/giorgianb/stanza/tree/e1ff1ab73c228739fea3ef5c012a9f1042bef2e3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input1_size, input2_size, output_size):
super().__init__()
self.W_bilin = nn.Bilinear(input1_size + 1, input2_size + 1,
output_size)
self.W_bilin.weight.data.zero_()
self.W_bilin.bias.data.ze... |
Actor | # 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 Actor(nn.Module):
"""
Policy Network (state --> action)
"""
def __init__(self, state_size: 'int', action_size: 'int', hidden_size:
'int'=256):
super().__init__()
self.fc1 = nn.Linear(state_size, hidden_siz... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jadenvc/puppersim | Actor | false | 10,240 | [
"Apache-2.0"
] | 0 | 1b3f3e3fc0515d5d6101622e0d729c779debfd32 | https://github.com/jadenvc/puppersim/tree/1b3f3e3fc0515d5d6101622e0d729c779debfd32 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""
Policy Network (state --> action)
"""
def __init__(self, state_size: 'int', action_size: 'int', hidden_size:
'int'=256):
super().__init__()
self.fc1 = nn.Linear(state_size, hidden_siz... |
BboxHead | # 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 itertools import product as product
class BboxHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super(BboxHead, self).__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 4, kernel_size=(
1, 1), stride=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
import torch.nn as nn
from itertools import product as product
assert_size_strid... | huigs/retinaface-pytorch | BboxHead | false | 10,241 | [
"MIT"
] | 0 | 0d7551d5863d172c2122bdd8d2d58be36e1b10fd | https://github.com/huigs/retinaface-pytorch/tree/0d7551d5863d172c2122bdd8d2d58be36e1b10fd | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super().__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 4, kernel_size=(
1, 1), stride=1, padding=0)
def forward(se... |
SDFNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
def get_embedder(multires, input_dims=3):
embed_kwargs = {'include_input': True, 'input_dims': input_dims,
'max_freq_log2': multires - 1, 'num_freqs': multires,
'log_sampling': True, 'periodic_fns': [torch.sin, torch.cos]}
embedder_obj = Em... | 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, math as tl_math
im... | hzwangjl/NeuS | SDFNetwork | false | 10,242 | [
"MIT"
] | 0 | f1b89176ec18e19b3848d787416dab9a1ce5300b | https://github.com/hzwangjl/NeuS/tree/f1b89176ec18e19b3848d787416dab9a1ce5300b | import torch
import numpy as np
import torch.nn as nn
def get_embedder(multires, input_dims=3):
embed_kwargs = {'include_input': True, 'input_dims': input_dims,
'max_freq_log2': multires - 1, 'num_freqs': multires,
'log_sampling': True, 'periodic_fns': [torch.sin, torch.cos]}
embedder_obj = Em... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
from torch import nn
class Critic(nn.Module):
"""
Value Network (state + action --> value)
"""
def __init__(self, state_size: 'int', action_size: 'int', hidden_size:
'int'=256):
super().__init__()
self.fc1 = nn.Linear(state_size + 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 import nn
assert_s... | jadenvc/puppersim | Critic | false | 10,243 | [
"Apache-2.0"
] | 0 | 1b3f3e3fc0515d5d6101622e0d729c779debfd32 | https://github.com/jadenvc/puppersim/tree/1b3f3e3fc0515d5d6101622e0d729c779debfd32 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""
Value Network (state + action --> value)
"""
def __init__(self, state_size: 'int', action_size: 'int', hidden_size:
'int'=256):
super().__init__()
self.fc1 = nn.Linear(state_size + ac... |
LandmarkHead | # 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 itertools import product as product
class LandmarkHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super(LandmarkHead, self).__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=
(1, 1), stride=1, padd... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from itertools import product as product
assert_size_strid... | huigs/retinaface-pytorch | LandmarkHead | false | 10,244 | [
"MIT"
] | 0 | 0d7551d5863d172c2122bdd8d2d58be36e1b10fd | https://github.com/huigs/retinaface-pytorch/tree/0d7551d5863d172c2122bdd8d2d58be36e1b10fd | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super().__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=
(1, 1), stride=1, padding=0)
def forward(s... |
SpatialSELayer1d | # 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 SpatialSELayer1d(nn.Module):
def __init__(self, num_channels):
"""
:param num_channels: No of input channels
"""
super(SpatialSELayer1d, self).__init__()
self.conv = nn.Conv1d(num_channels, 1, 1)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ioanvl/1d_squeeze_excitation | SpatialSELayer1d | false | 10,245 | [
"MIT"
] | 0 | f422dc4b8e7de6239a6fb7d1688048db5053e733 | https://github.com/ioanvl/1d_squeeze_excitation/tree/f422dc4b8e7de6239a6fb7d1688048db5053e733 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_channels):
"""
:param num_channels: No of input channels
"""
super().__init__()
self.conv = nn.Conv1d(num_channels, 1, 1)
self.sigmoid = nn.Sigmoid()
... |
ClassHead | # 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 itertools import product as product
class ClassHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super(ClassHead, self).__init__()
self.num_anchors = num_anchors
self.conv1x1 = nn.Conv2d(inchannels, self.num_anchors * 2,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from itertools import product as product
assert_size_strid... | huigs/retinaface-pytorch | ClassHead | false | 10,246 | [
"MIT"
] | 0 | 0d7551d5863d172c2122bdd8d2d58be36e1b10fd | https://github.com/huigs/retinaface-pytorch/tree/0d7551d5863d172c2122bdd8d2d58be36e1b10fd | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super().__init__()
self.num_anchors = num_anchors
self.conv1x1 = nn.Conv2d(inchannels, self.num_anchors * 2,
kernel_size=(1, 1... |
CNormalized_Linear | # 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 as th
class CNormalized_Linear(th.nn.Module):
"""Linear layer with column-wise normalized input matrix."""
def __init__(self, in_features, out_features, bias=False):
"""Initialize the layer."""
super(CNormalized_Linear, self).__init__()
self.in_fe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
import ... | edgarvardanyan/CausalDiscoveryToolbox | CNormalized_Linear | false | 10,247 | [
"MIT"
] | 0 | 5497a400440b49a3af14a0c7512bcdd307c9285d | https://github.com/edgarvardanyan/CausalDiscoveryToolbox/tree/5497a400440b49a3af14a0c7512bcdd307c9285d | import math
import torch
import torch as th
class Model(th.nn.Module):
"""Linear layer with column-wise normalized input matrix."""
def __init__(self, in_features, out_features, bias=False):
"""Initialize the layer."""
super().__init__()
self.in_features = in_features
self.out... |
ChannelSELayer1d | # 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 ChannelSELayer1d(nn.Module):
def __init__(self, num_channels, reduction_ratio=4):
"""
:param num_channels: No of input channels
:param reduction_ratio: By how much should the num_channels should be reduced
"""
super(ChannelSELayer1... | 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_... | ioanvl/1d_squeeze_excitation | ChannelSELayer1d | false | 10,248 | [
"MIT"
] | 0 | f422dc4b8e7de6239a6fb7d1688048db5053e733 | https://github.com/ioanvl/1d_squeeze_excitation/tree/f422dc4b8e7de6239a6fb7d1688048db5053e733 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_channels, reduction_ratio=4):
"""
:param num_channels: No of input channels
:param reduction_ratio: By how much should the num_channels should be reduced
"""
super().__init__()
num_c... |
Linear3D | # 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 as th
from torch.nn import Parameter
def functional_linear3d(input, weight, bias=None):
"""
Apply a linear transformation to the incoming data: :math:`y = xA^T + b`.
Shape:
- Input: :math:`(N, *, in\\_features)` where `*` means any number of
additio... | 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 as th
from torch.nn import Parameter
assert_size_stride... | edgarvardanyan/CausalDiscoveryToolbox | Linear3D | false | 10,249 | [
"MIT"
] | 0 | 5497a400440b49a3af14a0c7512bcdd307c9285d | https://github.com/edgarvardanyan/CausalDiscoveryToolbox/tree/5497a400440b49a3af14a0c7512bcdd307c9285d | import math
import torch
import torch as th
from torch.nn import Parameter
def functional_linear3d(input, weight, bias=None):
"""
Apply a linear transformation to the incoming data: :math:`y = xA^T + b`.
Shape:
- Input: :math:`(N, *, in\\_features)` where `*` means any number of
additio... |
GCNLayer | # 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 GCNLayer(nn.Module):
def __init__(self, in_ft, out_ft, bias=True):
super(GCNLayer, self).__init__()
self.fc = nn.Linear(in_ft, out_ft, bias=False)
self.act = nn.PReLU()
if bias:
self.bias = nn.Parameter(torch.FloatTensor(out_ft)... | 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... | jaynee156/GNN-thesis | GCNLayer | false | 10,250 | [
"MIT"
] | 0 | fe8a731698dedb6cf76f7130658a646664a79b09 | https://github.com/jaynee156/GNN-thesis/tree/fe8a731698dedb6cf76f7130658a646664a79b09 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_ft, out_ft, bias=True):
super().__init__()
self.fc = nn.Linear(in_ft, out_ft, bias=False)
self.act = nn.PReLU()
if bias:
self.bias = nn.Parameter(torch.FloatTensor(out_ft))
sel... |
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.utils.data
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
... | 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.... | iquintero/sagemaker-pytorch-container | Net | false | 10,251 | [
"Apache-2.0"
] | 0 | 70f64c87e549ae833d7f2ef2f15f01542ff5678e | https://github.com/iquintero/sagemaker-pytorch-container/tree/70f64c87e549ae833d7f2ef2f15f01542ff5678e | import torch
import torch.utils.data
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
... |
ValueFunction | # 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 ValueFunction(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim):
super(ValueFunction, self).__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.fc2 = nn.Linear(200, 200)
... | 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... | himanshusahni/task-biased-url | ValueFunction | false | 10,252 | [
"MIT"
] | 0 | 28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | https://github.com/himanshusahni/task-biased-url/tree/28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim):
super().__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.fc2 = nn.Linear(200, 200)
self.out = nn.Linear(200... |
CrossAttention | # 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 MultiHeadAttention(nn.Module):
"""
Multi head attention for Perceiver https://arxiv.org/pdf/2103.03206.pdf.
Args:
num_q_channels (`int`):
Number of q channels.
num_kv_channels (`int`):
Number of k or v channels. k has the same... | 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.... | jennyli-z/towhee | CrossAttention | false | 10,253 | [
"Apache-2.0"
] | 0 | 55c55fd961229575b75eae269b55090c839f8dcd | https://github.com/jennyli-z/towhee/tree/55c55fd961229575b75eae269b55090c839f8dcd | import torch
from torch import nn
class MultiHeadAttention(nn.Module):
"""
Multi head attention for Perceiver https://arxiv.org/pdf/2103.03206.pdf.
Args:
num_q_channels (`int`):
Number of q channels.
num_kv_channels (`int`):
Number of k or v channels. k has the same... |
DenseBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super(CausalConv1d, self).__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channe... | 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... | heyitsmine/FewRel | DenseBlock | false | 10,254 | [
"MIT"
] | 0 | 2a2b8ae471298d9eb3557796a085c23b21982fb2 | https://github.com/heyitsmine/FewRel/tree/2a2b8ae471298d9eb3557796a085c23b21982fb2 | import torch
from torch import nn
from torch.nn import functional as F
class CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super().__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channels, kernel_size,
... |
CausalConv1d | # 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 CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super(CausalConv1d, self).__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channels, kernel_size,
padding=... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | heyitsmine/FewRel | CausalConv1d | false | 10,255 | [
"MIT"
] | 0 | 2a2b8ae471298d9eb3557796a085c23b21982fb2 | https://github.com/heyitsmine/FewRel/tree/2a2b8ae471298d9eb3557796a085c23b21982fb2 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super().__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channels, kernel_size,
padding=self.padding, dilation=di... |
QValueFunction | # 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 QValueFunction(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim, action_dim):
super(QValueFunction, self).__init__()
self.fc1 = nn.Linear(state_dim + action_dim, 200)
self.fc2 ... | 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... | himanshusahni/task-biased-url | QValueFunction | false | 10,256 | [
"MIT"
] | 0 | 28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | https://github.com/himanshusahni/task-biased-url/tree/28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim, action_dim):
super().__init__()
self.fc1 = nn.Linear(state_dim + action_dim, 200)
self.fc2 = nn.Linear(200, 200)
... |
Gate | # 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 Gate(nn.Module):
def __init__(self, input_dim):
super(Gate, self).__init__()
self.linear = nn.Linear(input_dim * 4, 1, bias=True)
self.sigmoid = nn.Sigmoid()
def forward(self, x, y):
z = torch.cat([x, y, x * y, x - y], dim=2)
r... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | hgrhgy/NumSeq2SQL | Gate | false | 10,257 | [
"MIT"
] | 0 | 6f22fdf108736f979afa2dbd3af14aa9ad4718aa | https://github.com/hgrhgy/NumSeq2SQL/tree/6f22fdf108736f979afa2dbd3af14aa9ad4718aa | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.linear = nn.Linear(input_dim * 4, 1, bias=True)
self.sigmoid = nn.Sigmoid()
def forward(self, x, y):
z = torch.cat([x, y, x * y, x - y], dim=2)
return sel... |
ChannelSpatialSELayer1d | # 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 ChannelSELayer1d(nn.Module):
def __init__(self, num_channels, reduction_ratio=4):
"""
:param num_channels: No of input channels
:param reduction_ratio: By how much should the num_channels should be reduced
"... | 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 ... | ioanvl/1d_squeeze_excitation | ChannelSpatialSELayer1d | false | 10,258 | [
"MIT"
] | 0 | f422dc4b8e7de6239a6fb7d1688048db5053e733 | https://github.com/ioanvl/1d_squeeze_excitation/tree/f422dc4b8e7de6239a6fb7d1688048db5053e733 | import torch
import torch.nn as nn
import torch.nn.functional as F
class ChannelSELayer1d(nn.Module):
def __init__(self, num_channels, reduction_ratio=4):
"""
:param num_channels: No of input channels
:param reduction_ratio: By how much should the num_channels should be reduced
"... |
GaussianPolicyFunction | # 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 GaussianPolicyFunction(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim, action_dim):
super(GaussianPolicyFunction, self).__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.f... | 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, math as tl_math
im... | himanshusahni/task-biased-url | GaussianPolicyFunction | false | 10,259 | [
"MIT"
] | 0 | 28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | https://github.com/himanshusahni/task-biased-url/tree/28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim, action_dim):
super().__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.fc2 = nn.Linear(200, 200)
self.mu_out ... |
SkillDiscriminator | # 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 SkillDiscriminator(nn.Module):
"""fully connected 200x200 layers for inferring q(z|s)"""
def __init__(self, state_dim, nb_skills):
super(SkillDiscriminator, self).__init__()
self.fc1 = nn.Linear(state_dim, 200)
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
from torch._inductor.runtime.... | himanshusahni/task-biased-url | SkillDiscriminator | false | 10,260 | [
"MIT"
] | 0 | 28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | https://github.com/himanshusahni/task-biased-url/tree/28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""fully connected 200x200 layers for inferring q(z|s)"""
def __init__(self, state_dim, nb_skills):
super().__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.fc2 = nn.Linear(200, 200)
... |
OutConv | # 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 OutConv(nn.Module):
def __init__(self, inChannels, outChannels):
super(OutConv, self).__init__()
self.conv = nn.Conv2d(inChannels, outChannels, kernel_size=1)
self.tanh = nn.Tanh()
def forward(self, input_):
return self.tanh(self.conv(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | iabd/Dereverbify | OutConv | false | 10,261 | [
"MIT"
] | 0 | e0c2e40c6813cf5528c3e0a1d697085444fb23b2 | https://github.com/iabd/Dereverbify/tree/e0c2e40c6813cf5528c3e0a1d697085444fb23b2 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inChannels, outChannels):
super().__init__()
self.conv = nn.Conv2d(inChannels, outChannels, kernel_size=1)
self.tanh = nn.Tanh()
def forward(self, input_):
return self.tanh(self.conv(input_))
def ... |
DiscretePolicyFunction | # 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 DiscretePolicyFunction(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim, action_dim):
super(DiscretePolicyFunction, self).__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.f... | 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.... | himanshusahni/task-biased-url | DiscretePolicyFunction | false | 10,263 | [
"MIT"
] | 0 | 28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | https://github.com/himanshusahni/task-biased-url/tree/28e4ec318d46d84065b6e197fa9f4100bd4a4c34 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""fully connected 200x200 hidden layers"""
def __init__(self, state_dim, action_dim):
super().__init__()
self.fc1 = nn.Linear(state_dim, 200)
self.fc2 = nn.Linear(200, 200)
self.out = n... |
AttentionPool2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
import torch.nn as nn
import torch as th
def count_flops_attn(model, _x, y):
"""
A counter for the `thop` package to count the operations in an
attention operation.
Meant to be used like:
macs, params = thop.profile(
model,
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.... | jasperhu13/deit | AttentionPool2d | false | 10,265 | [
"Apache-2.0"
] | 0 | 97b09b1c131a7ee8d01ee0ce27a936ff33cf62fc | https://github.com/jasperhu13/deit/tree/97b09b1c131a7ee8d01ee0ce27a936ff33cf62fc | import math
import torch
import numpy as np
import torch.nn as nn
import torch as th
def count_flops_attn(model, _x, y):
"""
A counter for the `thop` package to count the operations in an
attention operation.
Meant to be used like:
macs, params = thop.profile(
model,
in... |
PatchEmbed | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class PatchEmbed(nn.Module):
"""
PatchEmbed.
"""
def __init__(self, dim_in=3, dim_out=768, kernel=(1, 16, 16), stride=(1,
4, 4), padding=(1, 7, 7), conv_2d=False):
super().__init__()
if conv_2d:
conv = nn.Conv2d
else:
... | 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... | jasperhu13/deit | PatchEmbed | false | 10,266 | [
"Apache-2.0"
] | 0 | 97b09b1c131a7ee8d01ee0ce27a936ff33cf62fc | https://github.com/jasperhu13/deit/tree/97b09b1c131a7ee8d01ee0ce27a936ff33cf62fc | import torch
import torch.nn as nn
class Model(nn.Module):
"""
PatchEmbed.
"""
def __init__(self, dim_in=3, dim_out=768, kernel=(1, 16, 16), stride=(1,
4, 4), padding=(1, 7, 7), conv_2d=False):
super().__init__()
if conv_2d:
conv = nn.Conv2d
else:
... |
SiglogModule | # 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 siglog(v):
return v.sign() * torch.log(1 + v.abs())
class SiglogModule(nn.Module):
def forward(self, v):
return siglog(v)
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 math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | finalgruntgit/diautils | SiglogModule | false | 10,267 | [
"MIT"
] | 0 | b9d7666ed5023700db01a4295430c52721acfc25 | https://github.com/finalgruntgit/diautils/tree/b9d7666ed5023700db01a4295430c52721acfc25 | import torch
import torch.nn as nn
def siglog(v):
return v.sign() * torch.log(1 + v.abs())
class Model(nn.Module):
def forward(self, v):
return siglog(v)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
MeanModule | # 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 MeanModule(nn.Module):
def __init__(self, *axis, keepdim=False):
super().__init__()
self.axis = axis
self.keepdim = keepdim
def forward(self, v):
mean = v.mean(self.axis)
if self.keepdim:
dims = list(v.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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | finalgruntgit/diautils | MeanModule | false | 10,268 | [
"MIT"
] | 0 | b9d7666ed5023700db01a4295430c52721acfc25 | https://github.com/finalgruntgit/diautils/tree/b9d7666ed5023700db01a4295430c52721acfc25 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, *axis, keepdim=False):
super().__init__()
self.axis = axis
self.keepdim = keepdim
def forward(self, v):
mean = v.mean(self.axis)
if self.keepdim:
dims = list(v.shape)
... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class Attention(nn.Module):
def __init__(self, feature_dim, K, bias=True, **kwargs):
super(Attention, self).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.K = K
weight = torch.z... | 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, math as tl_math
fr... | heyitsmine/FewRel | Attention | false | 10,269 | [
"MIT"
] | 0 | 2a2b8ae471298d9eb3557796a085c23b21982fb2 | https://github.com/heyitsmine/FewRel/tree/2a2b8ae471298d9eb3557796a085c23b21982fb2 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, feature_dim, K, bias=True, **kwargs):
super().__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.K = K
weight = torch.zeros(feature_dim, 1... |
SumModule | # 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 SumModule(nn.Module):
def __init__(self, *axis, keepdim=False):
super().__init__()
self.axis = axis
self.keepdim = keepdim
def forward(self, v):
sum = v.sum(self.axis)
if self.keepdim:
dims = list(v.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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | finalgruntgit/diautils | SumModule | false | 10,271 | [
"MIT"
] | 0 | b9d7666ed5023700db01a4295430c52721acfc25 | https://github.com/finalgruntgit/diautils/tree/b9d7666ed5023700db01a4295430c52721acfc25 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, *axis, keepdim=False):
super().__init__()
self.axis = axis
self.keepdim = keepdim
def forward(self, v):
sum = v.sum(self.axis)
if self.keepdim:
dims = list(v.shape)
i... |
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
from torch import nn
from torch.nn import Parameter
import torch.nn.functional as F
class MultiheadAttention(nn.Module):
"""Multi-headed attention.
See "Attention Is All You Need" for more details.
"""
def __init__(self, embed_dim, num_heads, attn_dropout=0.0, bias=True,
add_bias... | 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.... | jiahuanluo/multi_media | MultiheadAttention | false | 10,272 | [
"MIT"
] | 0 | ac5ac59dba87d0368ca656e600a85bfd9a1da28e | https://github.com/jiahuanluo/multi_media/tree/ac5ac59dba87d0368ca656e600a85bfd9a1da28e | import torch
from torch import nn
from torch.nn import Parameter
import torch.nn.functional as F
class Model(nn.Module):
"""Multi-headed attention.
See "Attention Is All You Need" for more details.
"""
def __init__(self, embed_dim, num_heads, attn_dropout=0.0, bias=True,
add_bias_kv=False, ad... |
SigsqrtModule | # 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 sigsqrt(v):
return v / torch.sqrt(1 + v.abs())
class SigsqrtModule(nn.Module):
def forward(self, v):
return sigsqrt(v)
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... | finalgruntgit/diautils | SigsqrtModule | false | 10,273 | [
"MIT"
] | 0 | b9d7666ed5023700db01a4295430c52721acfc25 | https://github.com/finalgruntgit/diautils/tree/b9d7666ed5023700db01a4295430c52721acfc25 | import torch
import torch.nn as nn
def sigsqrt(v):
return v / torch.sqrt(1 + v.abs())
class Model(nn.Module):
def forward(self, v):
return sigsqrt(v)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
LearnedPositionalEncoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.optim
class LearnedPositionalEncoding(nn.Module):
def __init__(self, max_position_embeddings, embedding_dim, seq_length):
super(LearnedPositionalEncoding, self).__init__()
self.position_embeddings = nn.Parameter(torch.zeros(1, 3200, 512))
def f... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dyna... | felixquinton1/TransBTS | LearnedPositionalEncoding | false | 10,274 | [
"Apache-2.0"
] | 0 | 6992c902413ba15f40ebfe9f6d5d0e3594051033 | https://github.com/felixquinton1/TransBTS/tree/6992c902413ba15f40ebfe9f6d5d0e3594051033 | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
def __init__(self, max_position_embeddings, embedding_dim, seq_length):
super().__init__()
self.position_embeddings = nn.Parameter(torch.zeros(1, 3200, 512))
def forward(self, x, position_ids=None):
positio... |
VAELoss | # 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 VAELoss(nn.Module):
def __init__(self):
super(VAELoss, self).__init__()
self.bce = nn.BCELoss(reduction='sum')
def forward(self, recon_x, x, mu, logvar):
BCE = self.bce(recon_x, x)
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar... | 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... | jlrussin/RL_project | VAELoss | false | 10,275 | [
"Apache-2.0"
] | 0 | a8562b4797afdf5944dba768a88d779056e8506a | https://github.com/jlrussin/RL_project/tree/a8562b4797afdf5944dba768a88d779056e8506a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.bce = nn.BCELoss(reduction='sum')
def forward(self, recon_x, x, mu, logvar):
BCE = self.bce(recon_x, x)
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
... |
SoftmaxModule | # 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 SoftmaxModule(nn.Module):
def __init__(self, axis):
super().__init__()
self.axis = axis
def forward(self, v):
return v.softmax(self.axis)
def get_inputs():
return [torch.rand([4, 4, 4, 4, 4])]
def get_init_inputs():
return [[], {'a... | 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
... | finalgruntgit/diautils | SoftmaxModule | false | 10,276 | [
"MIT"
] | 0 | b9d7666ed5023700db01a4295430c52721acfc25 | https://github.com/finalgruntgit/diautils/tree/b9d7666ed5023700db01a4295430c52721acfc25 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, axis):
super().__init__()
self.axis = axis
def forward(self, v):
return v.softmax(self.axis)
def get_inputs():
return [torch.rand([4, 4, 4, 4, 4])]
def get_init_inputs():
return [4]
|
MultipleRegression | # 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 MultipleRegression(nn.Module):
def __init__(self, num_features):
super(MultipleRegression, self).__init__()
self.fc1 = nn.Linear(num_features, 64)
self.fc2 = nn.Linear(64, 128)
self.output = nn.Linear(128, 1)
self.act = nn.Sigmoid()... | 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... | jiruifu-jerry0219/UpperLimbEstimator | MultipleRegression | false | 10,277 | [
"Apache-2.0"
] | 0 | d62deef93419934dcb33e43707dd0634a235fb9a | https://github.com/jiruifu-jerry0219/UpperLimbEstimator/tree/d62deef93419934dcb33e43707dd0634a235fb9a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_features):
super().__init__()
self.fc1 = nn.Linear(num_features, 64)
self.fc2 = nn.Linear(64, 128)
self.output = nn.Linear(128, 1)
self.act = nn.Sigmoid()
def forward(self, inputs):
... |
SegmentationNet | # 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 SegmentationNet(nn.Module):
def __init__(self, feature, hidden1, hidden2, output):
""" Initialize a class NeuralNet.
:param batch_size: int
:param hidden: int
"""
super(SegmentationNet, self).__init_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jinyu-hou/medium-blog-scripts | SegmentationNet | false | 10,278 | [
"MIT"
] | 0 | a645d544a4bd1c937e4ff99dca0d6e98b3abb7f9 | https://github.com/jinyu-hou/medium-blog-scripts/tree/a645d544a4bd1c937e4ff99dca0d6e98b3abb7f9 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, feature, hidden1, hidden2, output):
""" Initialize a class NeuralNet.
:param batch_size: int
:param hidden: int
"""
super().__init__()
self.layer1 = nn.Li... |
LinearWithChannel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
class LinearWithChannel(nn.Module):
def __init__(self, input_size, output_size, channel_size):
super(LinearWithChannel, self).__init__()
self.channel_size = channel_size
self.weight = torch.nn.Parameter(torch.zeros(channel_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
import numpy as np
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | jilanglois-su/cobs10-dengai | LinearWithChannel | false | 10,279 | [
"MIT"
] | 0 | 101d3434db6330e9794b2e266b02c93793abfb82 | https://github.com/jilanglois-su/cobs10-dengai/tree/101d3434db6330e9794b2e266b02c93793abfb82 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, output_size, channel_size):
super().__init__()
self.channel_size = channel_size
self.weight = torch.nn.Parameter(torch.zeros(channel_size,
input_size, output_size))
... |
MultiHeadedAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
def same_tensor(tensor, *args):
""" Do the input tensors all point to the same underlying data """
for other in args:
if not torch.is_tensor(other):
return False
if tensor.device != other.device:
ret... | 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.... | jinga-lala/stupidNMT | MultiHeadedAttention | false | 10,280 | [
"BSD-3-Clause"
] | 0 | 2a41c072c2bc622c7edd8556f552f38556d70dae | https://github.com/jinga-lala/stupidNMT/tree/2a41c072c2bc622c7edd8556f552f38556d70dae | import torch
from torch import nn
from torch.nn import functional as F
def same_tensor(tensor, *args):
""" Do the input tensors all point to the same underlying data """
for other in args:
if not torch.is_tensor(other):
return False
if tensor.device != other.device:
ret... |
MLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
from torch.nn.parameter import Parameter
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class Conv1D(nn.Module):
def __init__(self, nf, nx):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | jamessheenworks/GPT2sQA | MLP | false | 10,281 | [
"Apache-2.0"
] | 0 | 14866cb21d229281e8f8b8f88aac9195bca45cd7 | https://github.com/jamessheenworks/GPT2sQA/tree/14866cb21d229281e8f8b8f88aac9195bca45cd7 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
from torch.nn.parameter import Parameter
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class Conv1D(nn.Module):
def __init__(self, nf, nx):
... |
Classify | # 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 autopad(k, p=None):
if p is None:
p = k // 2 if isinstance(k, int) else [(x // 2) for x in k]
return p
class Flatten(nn.Module):
@staticmethod
def forward(x):
return x.view(x.size(0), -1)
class Classify(nn.Module):
def __init__(self, c1,... | 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... | hyperparameters/Towards-Realtime-MOT | Classify | false | 10,282 | [
"MIT"
] | 0 | eb956a3bd5991f4895178566cb0173769977f88d | https://github.com/hyperparameters/Towards-Realtime-MOT/tree/eb956a3bd5991f4895178566cb0173769977f88d | import torch
import torch.nn as nn
def autopad(k, p=None):
if p is None:
p = k // 2 if isinstance(k, int) else [(x // 2) for x in k]
return p
class Flatten(nn.Module):
@staticmethod
def forward(x):
return x.view(x.size(0), -1)
class Model(nn.Module):
def __init__(self, c1, c2... |
NeuralNerwork | # 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 NeuralNerwork(nn.Module):
""" Construct a ReLU-activated NN, set Bias to False
Four hidden layers with sizes [1000, 1000, 500, 200]
Features = 784, Targets = 10 classes
"""
def __init__(self, features, targets):
... | 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_... | jf20541/Pruning-DeepNeuralNetwork | NeuralNerwork | false | 10,283 | [
"MIT"
] | 0 | a78a88616c19aa0f1449eb562b7dd8d7c4f47252 | https://github.com/jf20541/Pruning-DeepNeuralNetwork/tree/a78a88616c19aa0f1449eb562b7dd8d7c4f47252 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
""" Construct a ReLU-activated NN, set Bias to False
Four hidden layers with sizes [1000, 1000, 500, 200]
Features = 784, Targets = 10 classes
"""
def __init__(self, features, targets):
supe... |
SELayer | # 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 SELayer(nn.Module):
def __init__(self, in_channels, reduction):
super().__init__()
mid_channels = in_channels // reduction
self.fc1 = nn.Linear(in_channels, mid_channels)
self.fc2 = nn.Linear(mid_channels, 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
import torch.nn as nn
assert_... | implus/pytorch_image_classification | SELayer | false | 10,284 | [
"MIT"
] | 0 | cac490ed518ad09b0429fc01af060457fb050e68 | https://github.com/implus/pytorch_image_classification/tree/cac490ed518ad09b0429fc01af060457fb050e68 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, reduction):
super().__init__()
mid_channels = in_channels // reduction
self.fc1 = nn.Linear(in_channels, mid_channels)
self.fc2 = nn.Linear(mid_channels, in_c... |
WeightedMultilabel | # 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 WeightedMultilabel(nn.Module):
def __init__(self, weights: 'torch.Tensor'):
super(WeightedMultilabel, self).__init__()
self.cerition = nn.BCEWithLogitsLoss(reduction='none')
self.weights = weights
def forward(self, outputs, targets):
l... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | jiawenxiao/physionet2020_0823 | WeightedMultilabel | false | 10,285 | [
"BSD-2-Clause"
] | 0 | 99dd54a3f7b8cef83ff37a46223f4f979edd2e74 | https://github.com/jiawenxiao/physionet2020_0823/tree/99dd54a3f7b8cef83ff37a46223f4f979edd2e74 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, weights: 'torch.Tensor'):
super().__init__()
self.cerition = nn.BCEWithLogitsLoss(reduction='none')
self.weights = weights
def forward(self, outputs, targets):
loss = self.cerition(outputs, targets)... |
BertLayerNormNoVar | # 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 BertLayerNormNoVar(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
super(BertLayerNormNoVar, self).__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.bias = nn.Parameter(torch.zeros(hidden_size))
self.variance_epsil... | 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... | jiachens/auto_LiRPA | BertLayerNormNoVar | false | 10,286 | [
"BSD-3-Clause"
] | 0 | cc1ff18e8fbc938953b20ae6a030a25761cb0b78 | https://github.com/jiachens/auto_LiRPA/tree/cc1ff18e8fbc938953b20ae6a030a25761cb0b78 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
super().__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.bias = nn.Parameter(torch.zeros(hidden_size))
self.variance_epsilon = eps
def forward(self, x):
... |
RobNet | # 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.nn.functional as F
class RobNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=2, dilation=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2)
self.conv3 = nn.Conv2d(32, 6... | 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... | hongrui16/rotated_detection | RobNet | false | 10,287 | [
"MIT"
] | 0 | 0b0a061b0753950c20d1e52c8ae8fc59e1ceb21d | https://github.com/hongrui16/rotated_detection/tree/0b0a061b0753950c20d1e52c8ae8fc59e1ceb21d | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=2, dilation=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2)
self.conv3 = nn.Conv2d(32, 64... |
Conv2 | # 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 Conv2(nn.Module):
""" A convolution layer with the stride of 2.
Input:
x: (N, 2L+2, in_channels) numeric tensor
global_cond: (N, global_cond_channels) numeric tensor
Output:
y: (N, L, out_channels) numeric te... | 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 ... | jonojace/WaveRNN | Conv2 | false | 10,288 | [
"MIT"
] | 0 | 5ac72d5ed10262132f016f8e523bc663faa991da | https://github.com/jonojace/WaveRNN/tree/5ac72d5ed10262132f016f8e523bc663faa991da | import math
import torch
import torch.nn as nn
class Model(nn.Module):
""" A convolution layer with the stride of 2.
Input:
x: (N, 2L+2, in_channels) numeric tensor
global_cond: (N, global_cond_channels) numeric tensor
Output:
y: (N, L, out_channels) numeric te... |
CatKLLoss | # 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.modules.loss import _Loss
class CatKLLoss(_Loss):
def __init__(self, reduction='none'):
super(CatKLLoss, self).__init__()
assert reduction in ['none', 'sum', 'mean']
self.reduction = reduction
def forward(self, log_qy, log_py):
"""
KL(qy|py)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch.nn.modules.loss import _Loss
assert_size_stride = torch._C._dy... | imguozhen/proactive-chat | CatKLLoss | false | 10,289 | [
"Apache-2.0"
] | 0 | 80d13e28cb93c26a65ace0a028c53fd0bafcdbf9 | https://github.com/imguozhen/proactive-chat/tree/80d13e28cb93c26a65ace0a028c53fd0bafcdbf9 | import torch
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def __init__(self, reduction='none'):
super().__init__()
assert reduction in ['none', 'sum', 'mean']
self.reduction = reduction
def forward(self, log_qy, log_py):
"""
KL(qy|py) = Eq[qy * log(q(y)... |
PCN1 | # 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 PCN1(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=2, dilation=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2)
self.conv3 = nn.Conv2d(32, 64... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jisheng047/blinsert | PCN1 | false | 10,290 | [
"BSD-2-Clause"
] | 0 | 923d2ea2af3f2f257c817fa8de02c7db8ec9bcc9 | https://github.com/jisheng047/blinsert/tree/923d2ea2af3f2f257c817fa8de02c7db8ec9bcc9 | 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(3, 16, kernel_size=3, stride=2, dilation=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2)
self.conv3 = nn.Conv2d(32, 6... |
MaskBCELoss | # 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.nn.modules.loss import _Loss
class MaskBCELoss(_Loss):
def __init__(self, reduction='mean'):
super(MaskBCELoss, self).__init__()
assert reduction in ['none', 'sum', 'mean']
self.reduction = reduction
def forward(self, input, tar... | 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.... | imguozhen/proactive-chat | MaskBCELoss | false | 10,291 | [
"Apache-2.0"
] | 0 | 80d13e28cb93c26a65ace0a028c53fd0bafcdbf9 | https://github.com/imguozhen/proactive-chat/tree/80d13e28cb93c26a65ace0a028c53fd0bafcdbf9 | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def __init__(self, reduction='mean'):
super().__init__()
assert reduction in ['none', 'sum', 'mean']
self.reduction = reduction
def forward(self, input, target, mask=None):
... |
NormalKLLoss | # 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 distributions
from torch.nn.modules.loss import _Loss
class NormalKLLoss(_Loss):
def __init__(self, reduction='mean'):
super(NormalKLLoss, self).__init__()
assert reduction in ['none', 'sum', 'mean']
self.reduction = reduction
def forward(self, q_mu, q_... | 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
from torch.nn.modules.loss import _Loss
assert_size_stride = t... | imguozhen/proactive-chat | NormalKLLoss | false | 10,292 | [
"Apache-2.0"
] | 0 | 80d13e28cb93c26a65ace0a028c53fd0bafcdbf9 | https://github.com/imguozhen/proactive-chat/tree/80d13e28cb93c26a65ace0a028c53fd0bafcdbf9 | import torch
from torch import distributions
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def __init__(self, reduction='mean'):
super().__init__()
assert reduction in ['none', 'sum', 'mean']
self.reduction = reduction
def forward(self, q_mu, q_logvar, p_mu=None, p_logv... |
Gather | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.onnx
class Gather(nn.Module):
def __init__(self, dim=0):
self.dim = dim
self.selection = [slice(None) for _ in range(dim)]
super().__init__()
def forward(self, input: 'torch.Tensor', indices: 'torch.Tensor'):
selection = self.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 import nn
import torch.onnx
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo... | jiuntian/onnx2pytorch | Gather | false | 10,293 | [
"Apache-2.0"
] | 0 | fadca10a6045f4373293c9c0854607fb51a47c12 | https://github.com/jiuntian/onnx2pytorch/tree/fadca10a6045f4373293c9c0854607fb51a47c12 | import torch
from torch import nn
import torch.onnx
class Model(nn.Module):
def __init__(self, dim=0):
self.dim = dim
self.selection = [slice(None) for _ in range(dim)]
super().__init__()
def forward(self, input: 'torch.Tensor', indices: 'torch.Tensor'):
selection = self.sele... |
GlobalAveragePool | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.onnx
class GlobalAveragePool(nn.Module):
def forward(self, input: 'torch.Tensor'):
spatial_shape = input.ndimension() - 2
dim = tuple(range(spatial_shape, spatial_shape + 2))
return torch.mean(input, dim=dim, keepdim=True)
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 import nn
import torch.onnx
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo... | jiuntian/onnx2pytorch | GlobalAveragePool | false | 10,294 | [
"Apache-2.0"
] | 0 | fadca10a6045f4373293c9c0854607fb51a47c12 | https://github.com/jiuntian/onnx2pytorch/tree/fadca10a6045f4373293c9c0854607fb51a47c12 | import torch
from torch import nn
import torch.onnx
class Model(nn.Module):
def forward(self, input: 'torch.Tensor'):
spatial_shape = input.ndimension() - 2
dim = tuple(range(spatial_shape, spatial_shape + 2))
return torch.mean(input, dim=dim, keepdim=True)
def get_inputs():
return ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.