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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
FCDiscriminator_low | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FCDiscriminator_low(nn.Module):
def __init__(self, inplanes, planes=64):
super(FCDiscriminator_low, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=2,
padding=1)
self.conv2 = nn.Conv2d(planes, planes * 2, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | seabearlmx/PA-DAN | FCDiscriminator_low | false | 4,298 | [
"MIT"
] | 0 | bdd1200396d102e68acdd265db9d22ddb83b6404 | https://github.com/seabearlmx/PA-DAN/tree/bdd1200396d102e68acdd265db9d22ddb83b6404 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, inplanes, planes=64):
super().__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=2,
padding=1)
self.conv2 = nn.Conv2d(planes, planes * 2, kernel_size=3, stride=2,
pa... |
ParallelPolarizedSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ParallelPolarizedSelfAttention(nn.Module):
def __init__(self, channel=512):
super().__init__()
self.ch_wv = nn.Conv2d(channel, channel // 2, kernel_size=(1, 1))
self.ch_wq = nn.Conv2d(channel, 1, kernel_size=(1, 1))
self.softmax_channel = nn... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | rushirajsherlocked/External-Attention-pytorch | ParallelPolarizedSelfAttention | false | 4,299 | [
"MIT"
] | 0 | 7d6814b2d90909adf81c62f3f8a89e30a59d6481 | https://github.com/rushirajsherlocked/External-Attention-pytorch/tree/7d6814b2d90909adf81c62f3f8a89e30a59d6481 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, channel=512):
super().__init__()
self.ch_wv = nn.Conv2d(channel, channel // 2, kernel_size=(1, 1))
self.ch_wq = nn.Conv2d(channel, 1, kernel_size=(1, 1))
self.softmax_channel = nn.Softmax(1)
self.... |
BertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.functional as F
class BertSelfAttention(nn.Module):
def __init__(self, config):
super(BertSe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | sermolin/amazon-sagemaker-examples | BertSelfAttention | false | 4,300 | [
"Apache-2.0"
] | 0 | 3e6083d1b53cb718893a04c46513a9482a17bd6b | https://github.com/sermolin/amazon-sagemaker-examples/tree/3e6083d1b53cb718893a04c46513a9482a17bd6b | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, config):
super().__init__()
... |
BaselineNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BaselineNN(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(4, 32)
self.fc2 = nn.Linear(32, 32)
self.fc3 = nn.Linear(32, 32)
self.fc4 = nn.Linear(32, 32)
self.fc5 = nn.Li... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | severilov/master-thesis | BaselineNN | false | 4,301 | [
"MIT"
] | 0 | 145382d5d551761fcdbd2b77d7b96fabcc8f78ec | https://github.com/severilov/master-thesis/tree/145382d5d551761fcdbd2b77d7b96fabcc8f78ec | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(4, 32)
self.fc2 = nn.Linear(32, 32)
self.fc3 = nn.Linear(32, 32)
self.fc4 = nn.Linear(32, 32)
self.fc5 = nn.Linear(... |
Maxout | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Maxout(nn.Module):
def __init__(self, in_features, out_features):
super(Maxout, self).__init__()
self.layer1 = nn.Linear(in_features, out_features)
self.layer2 = nn.Linear(in_features, out_features)
def forward(self, x):
output1 = self.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | shadow2496/KAIST_2019_Deep-Learning_HW4 | Maxout | false | 4,302 | [
"MIT"
] | 0 | f837ee23816c7486952733925b1f338b54d7086f | https://github.com/shadow2496/KAIST_2019_Deep-Learning_HW4/tree/f837ee23816c7486952733925b1f338b54d7086f | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_features, out_features):
super().__init__()
self.layer1 = nn.Linear(in_features, out_features)
self.layer2 = nn.Linear(in_features, out_features)
def forward(self, x):
output1 = self.layer1(x)
... |
ResidualAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResidualAttention(nn.Module):
def __init__(self, channel=512, num_class=1000, la=0.2):
super().__init__()
self.la = la
self.fc = nn.Conv2d(in_channels=channel, out_channels=num_class,
kernel_size=1, stride=1, bias=False)
def forward... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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... | rushirajsherlocked/External-Attention-pytorch | ResidualAttention | false | 4,303 | [
"MIT"
] | 0 | 7d6814b2d90909adf81c62f3f8a89e30a59d6481 | https://github.com/rushirajsherlocked/External-Attention-pytorch/tree/7d6814b2d90909adf81c62f3f8a89e30a59d6481 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, channel=512, num_class=1000, la=0.2):
super().__init__()
self.la = la
self.fc = nn.Conv2d(in_channels=channel, out_channels=num_class,
kernel_size=1, stride=1, bias=False)
def forward(self, x):
... |
LipSwish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class LipSwish(torch.nn.Module):
def forward(self, x):
return 0.909 * torch.nn.functional.silu(x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | shi27feng/torchsde | LipSwish | false | 4,304 | [
"Apache-2.0"
] | 0 | 58105bb6b839766c1d27b73c4fe3f949869d7394 | https://github.com/shi27feng/torchsde/tree/58105bb6b839766c1d27b73c4fe3f949869d7394 | import torch
class Model(torch.nn.Module):
def forward(self, x):
return 0.909 * torch.nn.functional.silu(x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
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... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Actor(nn.Module):
def __init__(self, num_inputs, num_outputs, args):
super(Actor, self).__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | sgrimbly/lets-do-irl | Actor | false | 4,305 | [
"MIT"
] | 0 | 4233e238342394feef6a7bd495cc6b700d435b00 | https://github.com/sgrimbly/lets-do-irl/tree/4233e238342394feef6a7bd495cc6b700d435b00 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs, args):
super().__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_size)
... |
Encoder1 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.init as init
import torch.nn.functional as F
def kaiming_init(m):
if isinstance(m, (nn.Linear, nn.Conv2d)):
init.kaiming_normal_(m.weight)
if m.bias is not None:
m.bias.data.fill_(0)
elif isinstance(m, (nn.BatchNorm1d, nn.BatchNorm... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | seqam-lab/rfvae | Encoder1 | false | 4,306 | [
"MIT"
] | 0 | 07089e2cca6d51f305731750c2c67b83a42df12a | https://github.com/seqam-lab/rfvae/tree/07089e2cca6d51f305731750c2c67b83a42df12a | import torch
import torch.nn as nn
import torch.nn.init as init
import torch.nn.functional as F
def kaiming_init(m):
if isinstance(m, (nn.Linear, nn.Conv2d)):
init.kaiming_normal_(m.weight)
if m.bias is not None:
m.bias.data.fill_(0)
elif isinstance(m, (nn.BatchNorm1d, nn.BatchNorm... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn import functional as F
class SelfAttention(nn.Module):
"""
Implementation of the attention block
"""
def __init__(self, input_size, hidden_size, output_size):
super(SelfAttention, self).__init__()
self.layer1 = nn.Linear(input_size, hidden_si... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | shahrukhx01/model_serve_pytorch | SelfAttention | false | 4,307 | [
"MIT"
] | 0 | c97ab45264b41ce349828e8b230ed85a51d6b213 | https://github.com/shahrukhx01/model_serve_pytorch/tree/c97ab45264b41ce349828e8b230ed85a51d6b213 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
"""
Implementation of the attention block
"""
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.layer1 = nn.Linear(input_size, hidden_size, bias=False)
sel... |
Discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Discriminator(nn.Module):
def __init__(self, num_inputs, args):
super(Discriminator, self).__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidde... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | sgrimbly/lets-do-irl | Discriminator | false | 4,308 | [
"MIT"
] | 0 | 4233e238342394feef6a7bd495cc6b700d435b00 | https://github.com/sgrimbly/lets-do-irl/tree/4233e238342394feef6a7bd495cc6b700d435b00 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, args):
super().__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_size)
self.fc3 = ... |
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... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import *
class Attention(nn.Module):
def __init__(self, opt):
super(Attention, self).__init__()
self.rnn_size = opt.rnn_size
self.att_hid_size = opt.att_hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Romero027/ImageCaptioning.pytorch | Attention | false | 4,309 | [
"MIT"
] | 0 | 069c95f5d343fb126afa8b10ec18e472f30b7b35 | https://github.com/Romero027/ImageCaptioning.pytorch/tree/069c95f5d343fb126afa8b10ec18e472f30b7b35 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import *
class Model(nn.Module):
def __init__(self, opt):
super().__init__()
self.rnn_size = opt.rnn_size
self.att_hid_size = opt.att_hid_size
self.... |
DeltaGFit | # 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 scipy import constants
import torch.nn as nn
import torch as t
class DeltaGFit(nn.Module):
def __init__(self, deltaG):
super(DeltaGFit, self).__init__()
self.deltaG = deltaG
def forward(self, temperature, X, k_int, timepoints):
"""
# inputs, list of:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | sajetan/PyHDX | DeltaGFit | false | 4,310 | [
"MIT"
] | 0 | f764849e33b2dd1bcae5824795a38c64ef01e13c | https://github.com/sajetan/PyHDX/tree/f764849e33b2dd1bcae5824795a38c64ef01e13c | import torch
from scipy import constants
import torch.nn as nn
import torch as t
class Model(nn.Module):
def __init__(self, deltaG):
super().__init__()
self.deltaG = deltaG
def forward(self, temperature, X, k_int, timepoints):
"""
# inputs, list of:
temperatures: ... |
SequentialPolarizedSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SequentialPolarizedSelfAttention(nn.Module):
def __init__(self, channel=512):
super().__init__()
self.ch_wv = nn.Conv2d(channel, channel // 2, kernel_size=(1, 1))
self.ch_wq = nn.Conv2d(channel, 1, kernel_size=(1, 1))
self.softmax_channel = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | rushirajsherlocked/External-Attention-pytorch | SequentialPolarizedSelfAttention | false | 4,311 | [
"MIT"
] | 0 | 7d6814b2d90909adf81c62f3f8a89e30a59d6481 | https://github.com/rushirajsherlocked/External-Attention-pytorch/tree/7d6814b2d90909adf81c62f3f8a89e30a59d6481 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, channel=512):
super().__init__()
self.ch_wv = nn.Conv2d(channel, channel // 2, kernel_size=(1, 1))
self.ch_wq = nn.Conv2d(channel, 1, kernel_size=(1, 1))
self.softmax_channel = nn.Softmax(1)
self.... |
SimulatorReward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class SimulatorReward(torch.nn.Module):
def __init__(self):
super(SimulatorReward, self).__init__()
self.conv1 = torch.nn.Conv2d(4, 8, kernel_size=3, padding=1)
self.conv2 = torch.nn.Conv2d(8, 16, kernel_size=3, padding=1)
self.conv3 = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | seulbinHwang/DeepReinforcementLearningInAction | SimulatorReward | false | 4,312 | [
"MIT"
] | 0 | c9039fd6951c46c8902cda04580c69159d172c82 | https://github.com/seulbinHwang/DeepReinforcementLearningInAction/tree/c9039fd6951c46c8902cda04580c69159d172c82 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(4, 8, kernel_size=3, padding=1)
self.conv2 = torch.nn.Conv2d(8, 16, kernel_size=3, padding=1)
self.conv3 = torch.nn.Conv2d(16, 32, kernel_... |
VNLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
import torch
import torch.nn.parallel
class VNLinear(nn.Module):
def __init__(self, in_channels, out_channels):
super(VNLinear, self).__init__()
self.map_to_feat = nn.Linear(in_channels, out_channels, bias=False)
def forward(self, x)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
import torch
import torch.nn.paral... | shiyani21/vnn | VNLinear | false | 4,313 | [
"MIT"
] | 0 | 921be51d6651ff32bff895f4da99ef83d50900da | https://github.com/shiyani21/vnn/tree/921be51d6651ff32bff895f4da99ef83d50900da | import torch
import torch.nn as nn
import torch.utils.data
import torch
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.map_to_feat = nn.Linear(in_channels, out_channels, bias=False)
def forward(self, x):
"""
... |
ConvAutoencoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConvAutoencoder(nn.Module):
"""Simple convolutional autoencoder
...
Methods
-------
forward(x)
Forward pass of x
"""
def __init__(self):
super(ConvAutoencoder, 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
import torch.nn as nn
assert_... | shankal17/Autoencoders | ConvAutoencoder | false | 4,314 | [
"MIT"
] | 0 | 17aa9f1fe573008fa84694e30e9d395127684191 | https://github.com/shankal17/Autoencoders/tree/17aa9f1fe573008fa84694e30e9d395127684191 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Simple convolutional autoencoder
...
Methods
-------
forward(x)
Forward pass of x
"""
def __init__(self):
super().__init__()
self.conv_1 = nn.Conv2d(1, 16, 3, padding... |
GatedLinearUnit | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GatedLinearUnit(nn.Module):
def __init__(self, input_size, hidden_layer_size, dropout_rate,
activation=None):
super(GatedLinearUnit, self).__init__()
self.input_size = input_size
self.hidden_layer_size = hidden_layer_size
self.dropo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | sherpahu/AutoX | GatedLinearUnit | false | 4,315 | [
"Apache-2.0"
] | 0 | 37aca6bb848ecfdde6868b9f8eb869563fece3eb | https://github.com/sherpahu/AutoX/tree/37aca6bb848ecfdde6868b9f8eb869563fece3eb | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, hidden_layer_size, dropout_rate,
activation=None):
super().__init__()
self.input_size = input_size
self.hidden_layer_size = hidden_layer_size
self.dropout_rate = dropout_rate
... |
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... | import torch
from torch import nn
from torch.nn import functional as F
class MLP(torch.nn.Module):
"""MLP for patch segmentation."""
def __init__(self, n_classes, input_dim):
super().__init__()
self.layer_1 = nn.Linear(input_dim, 200)
self.layer_2 = nn.Linear(200, 100)
self.la... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | sachaMorin/dino | MLP | false | 4,316 | [
"Apache-2.0"
] | 0 | b5c42ecffb535a8e6735c63ddc314118927cfd52 | https://github.com/sachaMorin/dino/tree/b5c42ecffb535a8e6735c63ddc314118927cfd52 | import torch
from torch import nn
from torch.nn import functional as F
class Model(torch.nn.Module):
"""MLP for patch segmentation."""
def __init__(self, n_classes, input_dim):
super().__init__()
self.layer_1 = nn.Linear(input_dim, 200)
self.layer_2 = nn.Linear(200, 100)
self.... |
ContinuousLoss_L2 | # 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 ContinuousLoss_L2(nn.Module):
""" Class to measure loss between continuous emotion dimension predictions and labels. Using l2 loss as base. """
def __init__(self, margin=1):
super(ContinuousLoss_L2, self).__init__()
self.margin = margin
def forwar... | 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
... | shrookehab/Body-Language-and-Emotion-Recognition | ContinuousLoss_L2 | false | 4,317 | [
"MIT"
] | 0 | a13068be1f8599fa2df6db925a98ac64fd2adf42 | https://github.com/shrookehab/Body-Language-and-Emotion-Recognition/tree/a13068be1f8599fa2df6db925a98ac64fd2adf42 | import torch
import torch.nn as nn
class Model(nn.Module):
""" Class to measure loss between continuous emotion dimension predictions and labels. Using l2 loss as base. """
def __init__(self, margin=1):
super().__init__()
self.margin = margin
def forward(self, pred, target):
labs... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
"""policy-value network module"""
def __init__(self, board_width, board_height):
super(Net, self).__init__()
self.board_width = board_width
self.board_height = board_height
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
from torch._inductor.runtime.... | sewon0918/pj4 | Net | false | 4,318 | [
"MIT"
] | 0 | 144996e7f99e7639f1fffb34770ab9713307428d | https://github.com/sewon0918/pj4/tree/144996e7f99e7639f1fffb34770ab9713307428d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""policy-value network module"""
def __init__(self, board_width, board_height):
super().__init__()
self.board_width = board_width
self.board_height = board_height
self.conv1 = nn.Conv2d... |
MyBatchNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MyBatchNorm(nn.Module):
def __init__(self, size, epsilon=1e-05):
super(MyBatchNorm, self).__init__()
self.gamma = nn.Parameter(torch.ones(size))
self.beta = nn.Parameter(torch.zeros(size))
self.epsilon = epsilon
def forward(self, x):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | shohamda/deep-learning | MyBatchNorm | false | 4,319 | [
"MIT"
] | 0 | 160296c403cefd5351ffe5161e07789c22637284 | https://github.com/shohamda/deep-learning/tree/160296c403cefd5351ffe5161e07789c22637284 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, size, epsilon=1e-05):
super().__init__()
self.gamma = nn.Parameter(torch.ones(size))
self.beta = nn.Parameter(torch.zeros(size))
self.epsilon = epsilon
def forward(self, x):
var, meu = torch... |
MSELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
assert_size_stride = to... | shuaizzZ/mmsegmentation | MSELoss | false | 4,320 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... |
GCN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
"""
def __in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | shovalf/OGRE-1 | GCN | false | 4,321 | [
"MIT"
] | 0 | 08efad50fac27e8c9621897838e122a2e8fdae1c | https://github.com/shovalf/OGRE-1/tree/08efad50fac27e8c9621897838e122a2e8fdae1c | from torch.nn import Module
import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
"""
def __in... |
ECA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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._C
import torch.serialization
from torch import nn
from typing import *
def int_size(x):
size = tuple(int(s) for s in x.size())
return size
class ECA(nn.Module):
"""Constructs a ECA module.
Args:
channel: Number of channels of the input feature map
k_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
import torch._C
import torch.serialization
from torch import nn
from typing impo... | shuaizzZ/mmsegmentation | ECA | false | 4,322 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
from typing import *
def int_size(x):
size = tuple(int(s) for s in x.size())
return size
class Model(nn.Module):
"""Constructs a ECA module.
Args:
channel: Number of channels of the input feature map
k_size:... |
Mix2Pooling | # 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._C
import torch.serialization
from torch import nn
from typing import *
class Mix2Pooling(nn.Module):
def __init__(self, size):
super(Mix2Pooling, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(size)
self.max_pool = nn.AdaptiveMaxPool2d(size)
def forw... | 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._C
import torch.serialization
from torch import nn
from typing import *
assert_size_stride = torch._C._dynamo.guards.assert_siz... | shuaizzZ/mmsegmentation | Mix2Pooling | false | 4,323 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
from typing import *
class Model(nn.Module):
def __init__(self, size):
super().__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(size)
self.max_pool = nn.AdaptiveMaxPool2d(size)
def forward(self, x):
s... |
CDiceLoss | # 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._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch._C
import... | shuaizzZ/mmsegmentation | CDiceLoss | false | 4,324 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... |
SpatialAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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._C
import torch.serialization
from torch import nn
from typing import *
class SpatialAttention(nn.Module):
def __init__(self, kernel_size=7):
super(SpatialAttention, self).__init__()
assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
padding = 3 if kernel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch._C
import torch.... | shuaizzZ/mmsegmentation | SpatialAttention | false | 4,325 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
from typing import *
class Model(nn.Module):
def __init__(self, kernel_size=7):
super().__init__()
assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
padding = 3 if kernel_size == 7 else 1
self.co... |
RecallLoss | # 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._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch._C
import... | shuaizzZ/mmsegmentation | RecallLoss | false | 4,326 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn import functional as F
class ContrastiveLoss(nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=5.0):
super(ContrastiveLoss, 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 import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_... | shuuchen/siamese_network | ContrastiveLoss | false | 4,327 | [
"Apache-2.0"
] | 0 | 54a952d320800c6bb5618cb40386e4c25bdde6fb | https://github.com/shuuchen/siamese_network/tree/54a952d320800c6bb5618cb40386e4c25bdde6fb | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=5.0):
super().__init__()
self.margin = margin
... |
TripletLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn.modules.distance import PairwiseDistance
class TripletLoss(nn.Module):
def __init__(self, margin=5.0):
super(TripletLoss, self).__init__()
self.margin = margin
self.pdist = PairwiseDistance(2)
def forward(self, anchor, negative, positiv... | 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
from to... | shuuchen/siamese_network | TripletLoss | false | 4,328 | [
"Apache-2.0"
] | 0 | 54a952d320800c6bb5618cb40386e4c25bdde6fb | https://github.com/shuuchen/siamese_network/tree/54a952d320800c6bb5618cb40386e4c25bdde6fb | import torch
from torch import nn
from torch.nn.modules.distance import PairwiseDistance
class Model(nn.Module):
def __init__(self, margin=5.0):
super().__init__()
self.margin = margin
self.pdist = PairwiseDistance(2)
def forward(self, anchor, negative, positive):
pos_dist = ... |
BinaryFocalLossWithLogits | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import warnings
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def binary_focal_loss_with_logits(input: 'torch.Tensor', target:
'torch.Tensor', alpha: 'float'=0.25, gamma: 'float'=2.0, reduction:
'str'='none', eps: 'Optional[float]'=None)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import warn... | shubham-gupta-iitr/mmmlX | BinaryFocalLossWithLogits | false | 4,329 | [
"Apache-2.0"
] | 0 | 3485e6191e0e45bf1c8168e4e928a36ab9264d22 | https://github.com/shubham-gupta-iitr/mmmlX/tree/3485e6191e0e45bf1c8168e4e928a36ab9264d22 | import torch
import warnings
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def binary_focal_loss_with_logits(input: 'torch.Tensor', target:
'torch.Tensor', alpha: 'float'=0.25, gamma: 'float'=2.0, reduction:
'str'='none', eps: 'Optional[float]'=None)... |
FCDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class FCDiscriminator(nn.Module):
"""
inplanes, planes. Patch-gan
"""
def __init__(self, inplanes, planes=64):
super(FCDiscriminator, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=2,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | shiyutang/ProDA | FCDiscriminator | false | 4,330 | [
"MIT"
] | 0 | 38209ced03c6044743273bb60e07cd915ac2ae12 | https://github.com/shiyutang/ProDA/tree/38209ced03c6044743273bb60e07cd915ac2ae12 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
inplanes, planes. Patch-gan
"""
def __init__(self, inplanes, planes=64):
super().__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=2,
padding=1)
self.conv... |
F1Loss | # 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._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
assert_size_stride = to... | shuaizzZ/mmsegmentation | F1Loss | false | 4,331 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
from typing import *
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".... |
NonLocal | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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._C
import torch.serialization
from torch import nn
from typing import *
def int_size(x):
size = tuple(int(s) for s in x.size())
return size
class NonLocal(nn.Module):
def __init__(self, in_channels):
super(NonLocal, self).__init__()
self.inter_channel = in_chan... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | shuaizzZ/mmsegmentation | NonLocal | false | 4,332 | [
"Apache-2.0"
] | 0 | a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | https://github.com/shuaizzZ/mmsegmentation/tree/a6c6b348dbf8c4a0a39ffbdb832a1e82309c533c | import torch
import torch._C
import torch.serialization
from torch import nn
from typing import *
def int_size(x):
size = tuple(int(s) for s in x.size())
return size
class Model(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.inter_channel = in_channels // 2
... |
BertOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.utils.data
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root)."""
super(BertLayerNorm, self).__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.triton_helpers import libdevice
import torch.nn as ... | shubham-gupta-iitr/mmmlX | BertOutput | false | 4,333 | [
"Apache-2.0"
] | 0 | 3485e6191e0e45bf1c8168e4e928a36ab9264d22 | https://github.com/shubham-gupta-iitr/mmmlX/tree/3485e6191e0e45bf1c8168e4e928a36ab9264d22 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.utils.data
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root)."""
super().__init__()
self... |
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 math
import torch
from torch import nn
class GELU(nn.Module):
def __init__(self):
super(GELU, self).__init__()
def forward(self, tensor):
geluPow = tensor + 0.044715 * torch.pow(tensor, 3)
geluTanh = torch.tanh(math.sqrt(2 / math.pi) * geluPow)
geluResult = 1 + geluTan... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | simonepreite/QABERT | GELU | false | 4,334 | [
"MIT"
] | 0 | ed3e49f6619f3ff660068291231909693cb8f5d5 | https://github.com/simonepreite/QABERT/tree/ed3e49f6619f3ff660068291231909693cb8f5d5 | import math
import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, tensor):
geluPow = tensor + 0.044715 * torch.pow(tensor, 3)
geluTanh = torch.tanh(math.sqrt(2 / math.pi) * geluPow)
geluResult = 1 + geluTanh
... |
RefModel1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class RefModel1d(torch.nn.Module):
"""The 3D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv1d(2, 2, 1, bias=True)
self.l2 = torch.nn.InstanceNorm1d(2, affine=True)
self.l3 = torch.nn.ReLU()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | shuohan/pytorch-layers | RefModel1d | false | 4,335 | [
"MIT"
] | 0 | 020846fd02d501cf477552179c19ba4b5e9a0695 | https://github.com/shuohan/pytorch-layers/tree/020846fd02d501cf477552179c19ba4b5e9a0695 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""The 3D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv1d(2, 2, 1, bias=True)
self.l2 = torch.nn.InstanceNorm1d(2, affine=True)
self.l3 = torch.nn.ReLU()
sel... |
ScaledDotProduct | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
from torch import nn
class ScaledDotProduct(nn.Module):
def __init__(self, attentionHeadSize, dropOutProb=0.1):
super(ScaledDotProduct, self).__init__()
self.attentionHeadSize = attentionHeadSize
self.dropout = nn.Dropout(dropOutProb)
def forward(self, Q, K, ... | 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... | simonepreite/QABERT | ScaledDotProduct | false | 4,336 | [
"MIT"
] | 0 | ed3e49f6619f3ff660068291231909693cb8f5d5 | https://github.com/simonepreite/QABERT/tree/ed3e49f6619f3ff660068291231909693cb8f5d5 | import math
import torch
from torch import nn
class Model(nn.Module):
def __init__(self, attentionHeadSize, dropOutProb=0.1):
super().__init__()
self.attentionHeadSize = attentionHeadSize
self.dropout = nn.Dropout(dropOutProb)
def forward(self, Q, K, V, attentionMask):
aScore... |
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 math
import torch
from torch import nn
class GELU(nn.Module):
def __init__(self):
super(GELU, self).__init__()
def forward(self, tensor):
geluPow = tensor + 0.044715 * torch.pow(tensor, 3)
geluTanh = torch.tanh(math.sqrt(2 / math.pi) * geluPow)
geluResult = 1 + geluTan... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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... | simonepreite/QABERT | FeedForward | false | 4,337 | [
"MIT"
] | 0 | ed3e49f6619f3ff660068291231909693cb8f5d5 | https://github.com/simonepreite/QABERT/tree/ed3e49f6619f3ff660068291231909693cb8f5d5 | import math
import torch
from torch import nn
class GELU(nn.Module):
def __init__(self):
super().__init__()
def forward(self, tensor):
geluPow = tensor + 0.044715 * torch.pow(tensor, 3)
geluTanh = torch.tanh(math.sqrt(2 / math.pi) * geluPow)
geluResult = 1 + geluTanh
... |
RenormSoftmax | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
class RenormSoftmax(nn.Module):
def __init__(self, dim=-1, norm=np.pi / 40):
super().__init__()
self.softmax = nn.Softmax(dim=dim)
self.dim = dim
self.norm = norm
def forward(self, x):
N = x.shape[self.dim]
... | 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 numpy as np
imp... | simonverret/deep_continuation | RenormSoftmax | false | 4,338 | [
"MIT"
] | 0 | 986bfba7f6806dc4869a023ff1fc1d0d18324b25 | https://github.com/simonverret/deep_continuation/tree/986bfba7f6806dc4869a023ff1fc1d0d18324b25 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim=-1, norm=np.pi / 40):
super().__init__()
self.softmax = nn.Softmax(dim=dim)
self.dim = dim
self.norm = norm
def forward(self, x):
N = x.shape[self.dim]
return ... |
BertAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
import torch.utils.data
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root)."""
super(BertLayerNorm... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | shubham-gupta-iitr/mmmlX | BertAttention | false | 4,339 | [
"Apache-2.0"
] | 0 | 3485e6191e0e45bf1c8168e4e928a36ab9264d22 | https://github.com/shubham-gupta-iitr/mmmlX/tree/3485e6191e0e45bf1c8168e4e928a36ab9264d22 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
import torch.utils.data
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root)."""
super().__init__()
... |
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... | import torch
from torch import Tensor
from torch import nn
class GELU(nn.Module):
"""Quick GELU"""
def forward(self, x: 'Tensor') ->Tensor:
return x * torch.sigmoid(1.702 * x)
class MLP(nn.Module):
def __init__(self, c1, ch, c2=None):
super().__init__()
self.c_fc = nn.Linear(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
from torch import Tensor
from torch import nn
assert_size_stride = torch._C._dyn... | sithu31296/multimodal | MLP | false | 4,340 | [
"MIT"
] | 0 | 78f57956cc84273579eb9e2e2be2a58fa1f38814 | https://github.com/sithu31296/multimodal/tree/78f57956cc84273579eb9e2e2be2a58fa1f38814 | import torch
from torch import Tensor
from torch import nn
class GELU(nn.Module):
"""Quick GELU"""
def forward(self, x: 'Tensor') ->Tensor:
return x * torch.sigmoid(1.702 * x)
class Model(nn.Module):
def __init__(self, c1, ch, c2=None):
super().__init__()
self.c_fc = nn.Linear(... |
RefModel2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class RefModel2d(torch.nn.Module):
"""The 2D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv2d(2, 2, 3, stride=2, bias=False, padding=1,
padding_mode='reflect')
self.l2 = torch.nn.BatchNorm2d(2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | shuohan/pytorch-layers | RefModel2d | false | 4,341 | [
"MIT"
] | 0 | 020846fd02d501cf477552179c19ba4b5e9a0695 | https://github.com/shuohan/pytorch-layers/tree/020846fd02d501cf477552179c19ba4b5e9a0695 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""The 2D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv2d(2, 2, 3, stride=2, bias=False, padding=1,
padding_mode='reflect')
self.l2 = torch.nn.BatchNorm2d(2, tra... |
TripletLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
from torch import nn
from torch.nn import functional as F
def euclidean_dist(x: 'Tensor', y: 'Tensor') ->Tensor:
xx, yy = torch.meshgrid((x ** 2).sum(1), (y ** 2).sum(1))
return xx + yy - 2 * (x @ y.t())
class TripletLoss(nn.Module):
"""
Modified from Tong Xiao'... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 Tensor
from... | sithu31296/re_identification | TripletLoss | false | 4,342 | [
"MIT"
] | 0 | 28c2cf32c6c8c9d79330e1419a7156fe10d8ac95 | https://github.com/sithu31296/re_identification/tree/28c2cf32c6c8c9d79330e1419a7156fe10d8ac95 | import torch
from torch import Tensor
from torch import nn
from torch.nn import functional as F
def euclidean_dist(x: 'Tensor', y: 'Tensor') ->Tensor:
xx, yy = torch.meshgrid((x ** 2).sum(1), (y ** 2).sum(1))
return xx + yy - 2 * (x @ y.t())
class Model(nn.Module):
"""
Modified from Tong Xiao's open... |
RefModel2d2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class RefModel2d2(torch.nn.Module):
"""The 2D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv2d(2, 2, 3, padding=1, stride=2,
padding_mode='circular', bias=False)
self.l2 = torch.nn.Identity()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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... | shuohan/pytorch-layers | RefModel2d2 | false | 4,343 | [
"MIT"
] | 0 | 020846fd02d501cf477552179c19ba4b5e9a0695 | https://github.com/shuohan/pytorch-layers/tree/020846fd02d501cf477552179c19ba4b5e9a0695 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""The 2D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv2d(2, 2, 3, padding=1, stride=2,
padding_mode='circular', bias=False)
self.l2 = torch.nn.Identity()
... |
PositionAttentionModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch import nn
from torch.nn import init
class ScaledDotProductAttention(nn.Module):
"""
Scaled dot-product attention
"""
def __init__(self, d_model, d_k, d_v, h, dropout=0.1):
"""
:param d_model: Output dimensionality of the model
:param ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | rushirajsherlocked/External-Attention-pytorch | PositionAttentionModule | false | 4,344 | [
"MIT"
] | 0 | 7d6814b2d90909adf81c62f3f8a89e30a59d6481 | https://github.com/rushirajsherlocked/External-Attention-pytorch/tree/7d6814b2d90909adf81c62f3f8a89e30a59d6481 | import torch
import numpy as np
from torch import nn
from torch.nn import init
class ScaledDotProductAttention(nn.Module):
"""
Scaled dot-product attention
"""
def __init__(self, d_model, d_k, d_v, h, dropout=0.1):
"""
:param d_model: Output dimensionality of the model
:param ... |
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
import torch.nn as nn
class Actor(nn.Module):
def __init__(self, state_dim, action_dim, max_action, nhid):
super(Actor, self).__init__()
self.l1 = nn.Linear(state_dim, nhid)
self.l2 = nn.Linear(nhid, nhid)
self.l3 = nn.Linear(nhid, acti... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | simondlevy/pytorch-drl | Actor | false | 4,345 | [
"MIT"
] | 0 | b197bb93c2cc698971f98095d4e0180811c52042 | https://github.com/simondlevy/pytorch-drl/tree/b197bb93c2cc698971f98095d4e0180811c52042 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, state_dim, action_dim, max_action, nhid):
super().__init__()
self.l1 = nn.Linear(state_dim, nhid)
self.l2 = nn.Linear(nhid, nhid)
self.l3 = nn.Linear(nhid, action_dim)
... |
DeepContinuor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DeepContinuor(nn.Module):
def __init__(self, x_dim, h_dim, y_dim):
super().__init__()
self.layer1 = nn.Linear(x_dim, h_dim)
self.layer2 = nn.Linear(h_dim, h_dim)
self.layer3 = nn.Linear(h_dim, h_dim)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | simonverret/deep_continuation | DeepContinuor | false | 4,346 | [
"MIT"
] | 0 | 986bfba7f6806dc4869a023ff1fc1d0d18324b25 | https://github.com/simonverret/deep_continuation/tree/986bfba7f6806dc4869a023ff1fc1d0d18324b25 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, x_dim, h_dim, y_dim):
super().__init__()
self.layer1 = nn.Linear(x_dim, h_dim)
self.layer2 = nn.Linear(h_dim, h_dim)
self.layer3 = nn.Linear(h_dim, h_dim)
self.lay... |
Normalizer | # 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 Normalizer(nn.Module):
def __init__(self, dim=-1, norm=1.0):
super().__init__()
self.dim = dim
self.norm = norm
self.softplus = nn.Softplus()
def forward(self, x):
out = self.softplus(x)
return out / torch.abs(out.detac... | 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... | simonverret/deep_continuation | Normalizer | false | 4,347 | [
"MIT"
] | 0 | 986bfba7f6806dc4869a023ff1fc1d0d18324b25 | https://github.com/simonverret/deep_continuation/tree/986bfba7f6806dc4869a023ff1fc1d0d18324b25 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim=-1, norm=1.0):
super().__init__()
self.dim = dim
self.norm = norm
self.softplus = nn.Softplus()
def forward(self, x):
out = self.softplus(x)
return out / torch.abs(out.detach()).... |
BasicModel_MaxPool_ReLU | # 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 BasicModel_MaxPool_ReLU(nn.Module):
def __init__(self, inplace=False) ->None:
super().__init__()
self.maxpool = nn.MaxPool1d(3)
self.relu = nn.ReLU(inplace=inplace)
def forward(self, x):
return self.relu(self.maxpool(x)).sum(dim=1)
d... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | sagnik/captum | BasicModel_MaxPool_ReLU | false | 4,348 | [
"BSD-3-Clause"
] | 0 | d6b663745ee6c01f072a4358233dec381324c283 | https://github.com/sagnik/captum/tree/d6b663745ee6c01f072a4358233dec381324c283 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inplace=False) ->None:
super().__init__()
self.maxpool = nn.MaxPool1d(3)
self.relu = nn.ReLU(inplace=inplace)
def forward(self, x):
return self.relu(self.maxpool(x)).sum(dim=1)
def get_inputs():
... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
class ScaledDotProduct(nn.Module):
def __init__(self, attentionHeadSize, dropOutProb=0.1):
super(ScaledDotProduct, self).__init__()
self.attentionHeadSize = attentionHeadSize
self.dropout = nn.Dropout(dropOutProb)
def forward(self, Q, K, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | simonepreite/QABERT | MultiHeadAttention | false | 4,349 | [
"MIT"
] | 0 | ed3e49f6619f3ff660068291231909693cb8f5d5 | https://github.com/simonepreite/QABERT/tree/ed3e49f6619f3ff660068291231909693cb8f5d5 | import math
import torch
from torch import nn
class ScaledDotProduct(nn.Module):
def __init__(self, attentionHeadSize, dropOutProb=0.1):
super().__init__()
self.attentionHeadSize = attentionHeadSize
self.dropout = nn.Dropout(dropOutProb)
def forward(self, Q, K, V, attentionMask):
... |
NormLayer | # 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 NormLayer(nn.Module):
def __init__(self, mean, std, n=None, eps=1e-08) ->None:
super().__init__()
self.mean = mean
self.std = std
self.eps = eps
def forward(self, x):
return (x - self.mean) / (self.std + self.eps)
def get_inp... | 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... | sagnik/captum | NormLayer | false | 4,350 | [
"BSD-3-Clause"
] | 0 | d6b663745ee6c01f072a4358233dec381324c283 | https://github.com/sagnik/captum/tree/d6b663745ee6c01f072a4358233dec381324c283 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, mean, std, n=None, eps=1e-08) ->None:
super().__init__()
self.mean = mean
self.std = std
self.eps = eps
def forward(self, x):
return (x - self.mean) / (self.std + self.eps)
def get_inputs(... |
LinearMaxPoolLinearModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LinearMaxPoolLinearModel(nn.Module):
def __init__(self) ->None:
super().__init__()
self.lin1 = nn.Linear(4, 4, bias=False)
self.lin1.weight = nn.Parameter(torch.eye(4, 4))
self.pool1 = nn.MaxPool1d(4)
self.lin2 = nn.Linear(1, 1, bia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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_... | sagnik/captum | LinearMaxPoolLinearModel | false | 4,351 | [
"BSD-3-Clause"
] | 0 | d6b663745ee6c01f072a4358233dec381324c283 | https://github.com/sagnik/captum/tree/d6b663745ee6c01f072a4358233dec381324c283 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self) ->None:
super().__init__()
self.lin1 = nn.Linear(4, 4, bias=False)
self.lin1.weight = nn.Parameter(torch.eye(4, 4))
self.pool1 = nn.MaxPool1d(4)
self.lin2 = nn.Linear(1, 1, bias=False)
se... |
BasicLinearReLULinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BasicLinearReLULinear(nn.Module):
def __init__(self, in_features, out_features=5, bias=False):
super().__init__()
self.fc1 = nn.Linear(in_features, out_features, bias=bias)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(out_features, 1, bias=b... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | sagnik/captum | BasicLinearReLULinear | false | 4,352 | [
"BSD-3-Clause"
] | 0 | d6b663745ee6c01f072a4358233dec381324c283 | https://github.com/sagnik/captum/tree/d6b663745ee6c01f072a4358233dec381324c283 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_features, out_features=5, bias=False):
super().__init__()
self.fc1 = nn.Linear(in_features, out_features, bias=bias)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(out_features, 1, bias=bias)
def fo... |
ConcatPositionalEncoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConcatPositionalEncoding(nn.Module):
def __init__(self, d_model=256, max_len=512):
super().__init__()
self.timing_table = nn.Parameter(torch.FloatTensor(max_len, d_model //
2))
nn.init.normal_(self.timing_table)
self.norm = nn.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
import torch.nn as nn
assert... | skulick/self-attentive-parser | ConcatPositionalEncoding | false | 4,353 | [
"MIT"
] | 0 | 04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | https://github.com/skulick/self-attentive-parser/tree/04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d_model=256, max_len=512):
super().__init__()
self.timing_table = nn.Parameter(torch.FloatTensor(max_len, d_model //
2))
nn.init.normal_(self.timing_table)
self.norm = nn.LayerNorm(d_model)
... |
PartitionedReLU | # 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 PartitionedReLU(nn.ReLU):
def forward(self, x):
if isinstance(x, tuple):
x_c, x_p = x
else:
x_c, x_p = torch.chunk(x, 2, dim=-1)
return super().forward(x_c), super().forward(x_p)
def get_inputs():
return [torch.rand([4... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | skulick/self-attentive-parser | PartitionedReLU | false | 4,354 | [
"MIT"
] | 0 | 04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | https://github.com/skulick/self-attentive-parser/tree/04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | import torch
import torch.nn as nn
class Model(nn.ReLU):
def forward(self, x):
if isinstance(x, tuple):
x_c, x_p = x
else:
x_c, x_p = torch.chunk(x, 2, dim=-1)
return super().forward(x_c), super().forward(x_p)
def get_inputs():
return [torch.rand([4, 4, 4, 4]... |
LogLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch.nn import MSELoss
class LogLoss(MSELoss):
def __init__(self):
super(LogLoss, self).__init__()
self.loss = torch.nn.MSELoss()
self.loss2 = torch.nn.MSELoss()
def forward(self, input, target):
tgt = torch.atan(target)
inp = torch.atan(input)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch.nn import MSELoss... | slaveuser/testRepo20181123 | LogLoss | false | 4,355 | [
"MIT"
] | 0 | 0651de19b3b7d02f8c9094b8b24346ccc2e30480 | https://github.com/slaveuser/testRepo20181123/tree/0651de19b3b7d02f8c9094b8b24346ccc2e30480 | import torch
from torch.nn import MSELoss
class Model(MSELoss):
def __init__(self):
super().__init__()
self.loss = torch.nn.MSELoss()
self.loss2 = torch.nn.MSELoss()
def forward(self, input, target):
tgt = torch.atan(target)
inp = torch.atan(input)
loss = torc... |
GlobalLayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GlobalLayerNorm(nn.Module):
def __init__(self, channel_size):
super(GlobalLayerNorm, self).__init__()
self.gamma = nn.Parameter(torch.Tensor(1, channel_size, 1))
self.beta = nn.Parameter(torch.Tensor(1, chan... | 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 itertools import product as product
assert_size_stri... | slapshin/TalkNet_ASD | GlobalLayerNorm | false | 4,356 | [
"MIT"
] | 0 | 343fac5c8d2bef2b98244e3acf20ac322711a4c7 | https://github.com/slapshin/TalkNet_ASD/tree/343fac5c8d2bef2b98244e3acf20ac322711a4c7 | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, channel_size):
super().__init__()
self.gamma = nn.Parameter(torch.Tensor(1, channel_size, 1))
self.beta = nn.Parameter(torch.Tensor(1, channel_size, 1))
self.rese... |
PartitionedLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PartitionedLinear(nn.Module):
def __init__(self, in_features, out_features, bias=True):
super().__init__()
self.linear_c = nn.Linear(in_features // 2, out_features // 2, bias)
self.linear_p = nn.Linear(in_features // 2, out_features // 2, 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | skulick/self-attentive-parser | PartitionedLinear | false | 4,357 | [
"MIT"
] | 0 | 04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | https://github.com/skulick/self-attentive-parser/tree/04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_features, out_features, bias=True):
super().__init__()
self.linear_c = nn.Linear(in_features // 2, out_features // 2, bias)
self.linear_p = nn.Linear(in_features // 2, out_features // 2, bias)
def forwar... |
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 __init__(self):
super(Normalize, self).__init__()
def forward(self, bottom):
qn = torch.norm(bottom, p=2, dim=1).unsqueeze(dim=1) + 1e-12
top = bottom.div(qn)
return top
def get_inputs():
return [torch.r... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | slyviacassell/Multi-taks-UNITE | Normalize | false | 4,358 | [
"MIT"
] | 0 | a010a92c94c0ee0f1ffed27df6d89da58d6d34c5 | https://github.com/slyviacassell/Multi-taks-UNITE/tree/a010a92c94c0ee0f1ffed27df6d89da58d6d34c5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, bottom):
qn = torch.norm(bottom, p=2, dim=1).unsqueeze(dim=1) + 1e-12
top = bottom.div(qn)
return top
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
... |
GlobalAveragePool2d | # 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 GlobalAveragePool2d(nn.Module):
def __init__(self):
super(GlobalAveragePool2d, self).__init__()
def forward(self, x: 'torch.Tensor'):
assert len(x.size()) >= 2
x_size = x.size()
out = x.view(*x_size[:-2], -1)
out = out.mean(dim... | 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... | slyviacassell/Multi-taks-UNITE | GlobalAveragePool2d | false | 4,359 | [
"MIT"
] | 0 | a010a92c94c0ee0f1ffed27df6d89da58d6d34c5 | https://github.com/slyviacassell/Multi-taks-UNITE/tree/a010a92c94c0ee0f1ffed27df6d89da58d6d34c5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x: 'torch.Tensor'):
assert len(x.size()) >= 2
x_size = x.size()
out = x.view(*x_size[:-2], -1)
out = out.mean(dim=-1)
out = out.view(*x_size[:-3... |
PointwiseConvolutionLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PointwiseConvolutionLayer(torch.nn.Module):
def __init__(self, N, F, F_prime):
super().__init__()
self.f1 = torch.nn.Linear(F, 128)
self.f2 = torch.nn.Linear(128, F_prime)
def forward(self, f_bar_batch):
output = torch.nn.functional.softplus(self.f1(f_bar_b... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
as... | slgao/FU-DeepLearningCourse | PointwiseConvolutionLayer | false | 4,360 | [
"MIT"
] | 0 | 2300e8bdaa2afb4c73535d5de80874f6103af6f2 | https://github.com/slgao/FU-DeepLearningCourse/tree/2300e8bdaa2afb4c73535d5de80874f6103af6f2 | import torch
class Model(torch.nn.Module):
def __init__(self, N, F, F_prime):
super().__init__()
self.f1 = torch.nn.Linear(F, 128)
self.f2 = torch.nn.Linear(128, F_prime)
def forward(self, f_bar_batch):
output = torch.nn.functional.softplus(self.f1(f_bar_batch))
retur... |
ArcFaceLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
import torch.distributed
import torch.nn.functional as F
class ArcFaceLinear(Module):
def __init__(self, embedding_size, num_classes):
super(ArcFaceLinear, self).__init__()
self.weight = torch.nn.Parameter(data=torch.FloatTensor(num_classes,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | smivv/kaggle-bengali | ArcFaceLinear | false | 4,361 | [
"Apache-2.0"
] | 0 | ab6a2153b657b4f4210551f7f4a674920d66a272 | https://github.com/smivv/kaggle-bengali/tree/ab6a2153b657b4f4210551f7f4a674920d66a272 | from torch.nn import Module
import math
import torch
import torch.distributed
import torch.nn.functional as F
class Model(Module):
def __init__(self, embedding_size, num_classes):
super().__init__()
self.weight = torch.nn.Parameter(data=torch.FloatTensor(num_classes,
embedding_size), ... |
Encoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
class NormLayer(nn.Module):
"""
Implementation of Layer Normalization (https://arxiv.org/abs/1607.06450)
It consists of Batch Normalization Transform to speed up learning with mean and std computed according to the above paper
normWeights:
weights for this n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | simonepreite/QABERT | Encoder | false | 4,362 | [
"MIT"
] | 0 | ed3e49f6619f3ff660068291231909693cb8f5d5 | https://github.com/simonepreite/QABERT/tree/ed3e49f6619f3ff660068291231909693cb8f5d5 | import math
import torch
from torch import nn
class NormLayer(nn.Module):
"""
Implementation of Layer Normalization (https://arxiv.org/abs/1607.06450)
It consists of Batch Normalization Transform to speed up learning with mean and std computed according to the above paper
normWeights:
weights for this n... |
InnerProductDecoder | # 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
import torch.nn.modules.loss
import torch.nn.functional as F
import torch.nn as nn
class InnerProductDecoder(nn.Module):
"""Decoder for using inner product for prediction."""
def __init__(self, dropout, act=torch.sigmoid):
super(InnerProductDecoder, self).__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn
import torch.nn.modules.loss
import torch.nn as nn
assert_size_s... | spatial-Transcriptomics/DeepST | InnerProductDecoder | false | 4,363 | [
"MIT"
] | 0 | 47ce64b06b62395cd2983939d4bf2419f558a562 | https://github.com/spatial-Transcriptomics/DeepST/tree/47ce64b06b62395cd2983939d4bf2419f558a562 | import torch
import torch.nn
import torch.nn.modules.loss
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""Decoder for using inner product for prediction."""
def __init__(self, dropout, act=torch.sigmoid):
super().__init__()
self.dropout = dropout
self.... |
Encoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
class Encoder(torch.nn.Module):
"""Documentation for Encoder
"""
def __init__(self, input_dim, hidden_dim, latent_dim):
super(Encoder, self).__init__()
self.e1 = torch.nn.Linear(input_dim, hidden_dim)
self.e2 = torch.nn.Linear(hidden_d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cu... | slgao/FU-DeepLearningCourse | Encoder | false | 4,364 | [
"MIT"
] | 0 | 2300e8bdaa2afb4c73535d5de80874f6103af6f2 | https://github.com/slgao/FU-DeepLearningCourse/tree/2300e8bdaa2afb4c73535d5de80874f6103af6f2 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""Documentation for Encoder
"""
def __init__(self, input_dim, hidden_dim, latent_dim):
super().__init__()
self.e1 = torch.nn.Linear(input_dim, hidden_dim)
self.e2 = torch.nn.Linear(hidden_dim, hidden_dim)... |
PartitionedMultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class PartitionedMultiHeadAttention(nn.Module):
def __init__(self, d_model, n_head, d_qkv, attention_dropout=0.1,
initializer_range=0.02):
super().__init__()
self.w_qkv_c = nn.Parameter(torch.Tensor(n_head, d_m... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | skulick/self-attentive-parser | PartitionedMultiHeadAttention | false | 4,365 | [
"MIT"
] | 0 | 04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | https://github.com/skulick/self-attentive-parser/tree/04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_model, n_head, d_qkv, attention_dropout=0.1,
initializer_range=0.02):
super().__init__()
self.w_qkv_c = nn.Parameter(torch.Tensor(n_head, d_model // 2, 3,
... |
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
import torch.nn as nn
class CausalConv1d(nn.Conv1d):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=1,
**kwargs):
super(CausalConv1d, self).__init__(in_channels, out_channels,
kernel_size, padding=dilation * (kernel_size - 1), dilation=
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | soumyac1999/instrumental-music-translation | CausalConv1d | false | 4,366 | [
"MIT"
] | 0 | f0d5edfdf34ef7bc9b329c426089f61d3468caa8 | https://github.com/soumyac1999/instrumental-music-translation/tree/f0d5edfdf34ef7bc9b329c426089f61d3468caa8 | import torch
import torch.nn as nn
class Model(nn.Conv1d):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=1,
**kwargs):
super().__init__(in_channels, out_channels,
kernel_size, padding=dilation * (kernel_size - 1), dilation=
dilation, **kwargs)
... |
RefModel3d2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class RefModel3d2(torch.nn.Module):
"""The 3D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv3d(2, 2, 3, padding=1, stride=2,
padding_mode='replicate', bias=False)
self.l2 = torch.nn.GroupNorm(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | shuohan/pytorch-layers | RefModel3d2 | false | 4,367 | [
"MIT"
] | 0 | 020846fd02d501cf477552179c19ba4b5e9a0695 | https://github.com/shuohan/pytorch-layers/tree/020846fd02d501cf477552179c19ba4b5e9a0695 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""The 3D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv3d(2, 2, 3, padding=1, stride=2,
padding_mode='replicate', bias=False)
self.l2 = torch.nn.GroupNorm(2, 2)
... |
RefModel3d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class RefModel3d(torch.nn.Module):
"""The 3D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv3d(2, 2, 1, bias=True)
self.l2 = torch.nn.InstanceNorm3d(2, affine=True)
self.l3 = torch.nn.ReLU()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | shuohan/pytorch-layers | RefModel3d | false | 4,368 | [
"MIT"
] | 0 | 020846fd02d501cf477552179c19ba4b5e9a0695 | https://github.com/shuohan/pytorch-layers/tree/020846fd02d501cf477552179c19ba4b5e9a0695 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""The 3D reference model."""
def __init__(self):
super().__init__()
self.l1 = torch.nn.Conv3d(2, 2, 1, bias=True)
self.l2 = torch.nn.InstanceNorm3d(2, affine=True)
self.l3 = torch.nn.ReLU()
sel... |
HardSwish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class HardSwish(nn.Module):
"""hardswish activation func (see MobileNetV3)"""
def __init__(self):
super(HardSwish, self).__init__()
def forward(self, x):
return x * nn.ReLU6(inplace=True)(x + 3.0) / 6.0
def get_inputs():
return [torch.rand([4, 4, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | stepbuystep/LightNAS | HardSwish | false | 4,369 | [
"Apache-2.0"
] | 0 | 030d0e13e0c85354ed711e36fc4b91b1541f95e5 | https://github.com/stepbuystep/LightNAS/tree/030d0e13e0c85354ed711e36fc4b91b1541f95e5 | import torch
import torch.nn as nn
class Model(nn.Module):
"""hardswish activation func (see MobileNetV3)"""
def __init__(self):
super().__init__()
def forward(self, x):
return x * nn.ReLU6(inplace=True)(x + 3.0) / 6.0
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_i... |
DDPGActor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.nn.functional as F
def fanin_init(size, fanin=None):
"""
Initilise network weights
"""
fanin = fanin or size[0]
v = 1.0 / np.sqrt(fanin)
return torch.Tensor(size).uniform_(-v, v)
class DDPGActor(nn.Module):
"""
Pytorc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | Nikhil-Paleti/sawyer_analysis_reinforcement_learning | DDPGActor | false | 4,370 | [
"MIT"
] | 0 | dc774c9a162fabb98493b69d7656cb14cb37f094 | https://github.com/Nikhil-Paleti/sawyer_analysis_reinforcement_learning/tree/dc774c9a162fabb98493b69d7656cb14cb37f094 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def fanin_init(size, fanin=None):
"""
Initilise network weights
"""
fanin = fanin or size[0]
v = 1.0 / np.sqrt(fanin)
return torch.Tensor(size).uniform_(-v, v)
class Model(nn.Module):
"""
Pytorch ne... |
attentionLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch.nn import MultiheadAttention
from itertools import product as product
class attentionLayer(nn.Module):
def __init__(self, d_model, nhead, dropout=0.1):
super(attentionLayer, self).__init__()
self.self_attn = MultiheadAt... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | slapshin/TalkNet_ASD | attentionLayer | false | 4,371 | [
"MIT"
] | 0 | 343fac5c8d2bef2b98244e3acf20ac322711a4c7 | https://github.com/slapshin/TalkNet_ASD/tree/343fac5c8d2bef2b98244e3acf20ac322711a4c7 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import MultiheadAttention
from itertools import product as product
class Model(nn.Module):
def __init__(self, d_model, nhead, dropout=0.1):
super().__init__()
self.self_attn = MultiheadAttention(d_model, nhead, dropo... |
BananaResNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BananaResNet(nn.Module):
def __init__(self, state_size, action_size):
super(BananaResNet, self).__init__()
self.blk1fc1 = nn.Linear(state_size, 128)
self.blk1fc2 = nn.Linear(128, 128)
self.blk1fc3 = nn.Linear... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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_... | slash-fury/DRL-Navigation | BananaResNet | false | 4,372 | [
"MIT"
] | 0 | 5989dca62590b611ab39ac8722a22d897c65cc88 | https://github.com/slash-fury/DRL-Navigation/tree/5989dca62590b611ab39ac8722a22d897c65cc88 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_size, action_size):
super().__init__()
self.blk1fc1 = nn.Linear(state_size, 128)
self.blk1fc2 = nn.Linear(128, 128)
self.blk1fc3 = nn.Linear(128, 64)
self.bl... |
HardSigmoid | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class HardSigmoid(nn.Module):
"""hardsigmoid activation func used in squeeze-and-excitation module (see MobileNetV3)"""
def __init__(self):
super(HardSigmoid, self).__init__()
def forward(self, x):
return nn.ReLU6(inplace=True)(x + 3.0) / 6.0
def get_... | 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... | stepbuystep/LightNAS | HardSigmoid | false | 4,373 | [
"Apache-2.0"
] | 0 | 030d0e13e0c85354ed711e36fc4b91b1541f95e5 | https://github.com/stepbuystep/LightNAS/tree/030d0e13e0c85354ed711e36fc4b91b1541f95e5 | import torch
import torch.nn as nn
class Model(nn.Module):
"""hardsigmoid activation func used in squeeze-and-excitation module (see MobileNetV3)"""
def __init__(self):
super().__init__()
def forward(self, x):
return nn.ReLU6(inplace=True)(x + 3.0) / 6.0
def get_inputs():
return [t... |
HeatmapLoss | # 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
class HeatmapLoss(torch.nn.Module):
"""
loss for detection heatmap
"""
def __init__(self):
super(HeatmapLoss, self).__init__()
def forward(self, pred, gt):
l = (pred - gt) ** 2
l = l.mean(dim=3).mean(dim=2).mean(dim=1)
return 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
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_... | seeinggreen/pyslr | HeatmapLoss | false | 4,374 | [
"BSD-3-Clause"
] | 0 | 17009582f70aed09a9174ce47f9414f715173018 | https://github.com/seeinggreen/pyslr/tree/17009582f70aed09a9174ce47f9414f715173018 | import torch
import torch.utils.data
class Model(torch.nn.Module):
"""
loss for detection heatmap
"""
def __init__(self):
super().__init__()
def forward(self, pred, gt):
l = (pred - gt) ** 2
l = l.mean(dim=3).mean(dim=2).mean(dim=1)
return l
def get_inputs():
... |
GCN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GCLayer(Module):
def __init__(self, dim_in, dim_out):
super(GCLayer, self).__init__()
self.dim_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.... | spacemanidol/CS512DM | GCN | false | 4,375 | [
"MIT"
] | 0 | fa664ceb7526e27b9cccd372b65b15c587095c49 | https://github.com/spacemanidol/CS512DM/tree/fa664ceb7526e27b9cccd372b65b15c587095c49 | from torch.nn import Module
import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GCLayer(Module):
def __init__(self, dim_in, dim_out):
super().__init__()
self.dim_in = dim_in
... |
DilatedResConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DilatedResConv(nn.Module):
def __init__(self, channels, dilation=1, activation='relu', padding=1,
kernel_size=3, left_pad=0):
super().__init__()
in_channels = channels
if activation == 'relu':
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | soumyac1999/instrumental-music-translation | DilatedResConv | false | 4,376 | [
"MIT"
] | 0 | f0d5edfdf34ef7bc9b329c426089f61d3468caa8 | https://github.com/soumyac1999/instrumental-music-translation/tree/f0d5edfdf34ef7bc9b329c426089f61d3468caa8 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, channels, dilation=1, activation='relu', padding=1,
kernel_size=3, left_pad=0):
super().__init__()
in_channels = channels
if activation == 'relu':
self.activat... |
VitMlpHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def get_args():
parser = argparse.ArgumentParser()
group = parser.add_argument_group(title='input data')
group.add_argument('--input', type=str, required=True, help=
'Path to input JSON')
group.add_argument('--json-keys', nargs='+', default=['text'], help=
'space separate ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride ... | sourcery-ai-bot/Megatron-LM | VitMlpHead | false | 4,377 | [
"MIT"
] | 0 | f27f44e2c49d1cb39b2288bef6f7d837e11094cb | https://github.com/sourcery-ai-bot/Megatron-LM/tree/f27f44e2c49d1cb39b2288bef6f7d837e11094cb | import torch
def get_args():
parser = argparse.ArgumentParser()
group = parser.add_argument_group(title='input data')
group.add_argument('--input', type=str, required=True, help=
'Path to input JSON')
group.add_argument('--json-keys', nargs='+', default=['text'], help=
'space separate ... |
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
import torch.nn.functional as F
class Attention(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
"""
def __init__(self, dim):
super(Attention, self).__init__()
self.dim = dim
self.linear1 = nn.Linear(dim ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | salmon7ish/Video-Captioning | Attention | false | 4,378 | [
"MIT"
] | 0 | 08359b1824195a7f5eac5b58982efd19ebc6db01 | https://github.com/salmon7ish/Video-Captioning/tree/08359b1824195a7f5eac5b58982efd19ebc6db01 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
"""
def __init__(self, dim):
super().__init__()
self.dim = dim
self.linear1 = nn.Linear(dim * 2, dim)
s... |
PartitionedTransformerEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class FeatureDropoutFunction(torch.autograd.function.InplaceFunction):
@staticmethod
def forward(ctx, input, p=0.5, train=False, inplace=False):
if p < 0 or p > 1:
raise ValueError(
'dropout pro... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | skulick/self-attentive-parser | PartitionedTransformerEncoderLayer | false | 4,379 | [
"MIT"
] | 0 | 04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | https://github.com/skulick/self-attentive-parser/tree/04a91e80cc05bcfe8f48145517f58e85f0c8ade6 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class FeatureDropoutFunction(torch.autograd.function.InplaceFunction):
@staticmethod
def forward(ctx, input, p=0.5, train=False, inplace=False):
if p < 0 or p > 1:
raise ValueError(
'dropout pro... |
mlp_model | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class mlp_model(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(mlp_model, self).__init__()
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(hidden_dim, 128)
self.relu2 = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | st186/complementary_label_learning | mlp_model | false | 4,380 | [
"MIT"
] | 0 | 5d22ea638e9e6c087cc5bba7797c1c201679ba12 | https://github.com/st186/complementary_label_learning/tree/5d22ea638e9e6c087cc5bba7797c1c201679ba12 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super().__init__()
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(hidden_dim, 128)
self.relu2 = nn.ReLU()
self... |
PrimaryCaps | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 squash(x, dim=2):
v_length_sq = x.pow(2).sum(dim=dim, keepdim=True)
v_length = torch.sqrt(v_length_sq)
scaling_factor = v_length_sq / (1 + v_length_sq) / v_length
return x * scaling_factor
class PrimaryCaps(nn.Module):
"""
PrimaryCaps layers.
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | spikefairway/CapsNet-PyTorch | PrimaryCaps | false | 4,381 | [
"MIT"
] | 0 | 76aaabaad01283333a5f73a564cb1461449b4449 | https://github.com/spikefairway/CapsNet-PyTorch/tree/76aaabaad01283333a5f73a564cb1461449b4449 | import torch
import torch.nn as nn
def squash(x, dim=2):
v_length_sq = x.pow(2).sum(dim=dim, keepdim=True)
v_length = torch.sqrt(v_length_sq)
scaling_factor = v_length_sq / (1 + v_length_sq) / v_length
return x * scaling_factor
class Model(nn.Module):
"""
PrimaryCaps layers.
"""
def... |
DownRightShiftedConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DownRightShiftedConv2d(nn.Conv2d):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.shift_pad = nn.ConstantPad2d((self.kernel_size[1] - 1, 0, self
.kernel_size[0] - 1, 0), 0.0)
def forward(self, x):
x = s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | stankevich-mipt/pixiv-tags-to-image | DownRightShiftedConv2d | false | 4,382 | [
"MIT"
] | 0 | 220a157956296c8a5b183ffe219e7c1929342c39 | https://github.com/stankevich-mipt/pixiv-tags-to-image/tree/220a157956296c8a5b183ffe219e7c1929342c39 | import torch
import torch.nn as nn
class Model(nn.Conv2d):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.shift_pad = nn.ConstantPad2d((self.kernel_size[1] - 1, 0, self
.kernel_size[0] - 1, 0), 0.0)
def forward(self, x):
x = self.shift_pad(x)
... |
OhemLoss | # 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 OhemLoss(nn.Module):
def __init__(self):
super(OhemLoss, self).__init__()
self.criteria = nn.BCELoss()
def forward(self, label_p, label_t):
label_p = label_p.view(-1)
label_t = label_t.view(-1)
loss = self.criteria(label_p, lab... | 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... | suifengwangshi/MotifC | OhemLoss | false | 4,383 | [
"Apache-2.0"
] | 0 | 34117a6bfb7dacd5a84da3abd5b8a339ae73cc76 | https://github.com/suifengwangshi/MotifC/tree/34117a6bfb7dacd5a84da3abd5b8a339ae73cc76 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.criteria = nn.BCELoss()
def forward(self, label_p, label_t):
label_p = label_p.view(-1)
label_t = label_t.view(-1)
loss = self.criteria(label_p, label_t)
ret... |
EncoderBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 collections import OrderedDict
class EncoderBlock(nn.Module):
def __init__(self, n_in, n_out, n_layers):
super().__init__()
self.n_in = n_in
self.n_out = n_out
self.n_hid = self.n_out
self.n_layers = n_layers
self.post_gain =... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from co... | stankevich-mipt/pixiv-tags-to-image | EncoderBlock | false | 4,384 | [
"MIT"
] | 0 | 220a157956296c8a5b183ffe219e7c1929342c39 | https://github.com/stankevich-mipt/pixiv-tags-to-image/tree/220a157956296c8a5b183ffe219e7c1929342c39 | import torch
import torch.nn as nn
from collections import OrderedDict
class Model(nn.Module):
def __init__(self, n_in, n_out, n_layers):
super().__init__()
self.n_in = n_in
self.n_out = n_out
self.n_hid = self.n_out
self.n_layers = n_layers
self.post_gain = 1.0
... |
DownShiftedConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DownShiftedConv2d(nn.Conv2d):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.shift_pad = nn.ConstantPad2d((int((self.kernel_size[1] - 1) //
2), int((self.kernel_size[1] - 1) // 2), self.kernel_size[0] -
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | stankevich-mipt/pixiv-tags-to-image | DownShiftedConv2d | false | 4,385 | [
"MIT"
] | 0 | 220a157956296c8a5b183ffe219e7c1929342c39 | https://github.com/stankevich-mipt/pixiv-tags-to-image/tree/220a157956296c8a5b183ffe219e7c1929342c39 | import torch
import torch.nn as nn
class Model(nn.Conv2d):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.shift_pad = nn.ConstantPad2d((int((self.kernel_size[1] - 1) //
2), int((self.kernel_size[1] - 1) // 2), self.kernel_size[0] -
1, 0), 0.0)... |
StatsPool | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import warnings
import torch.nn as nn
from typing import Optional
import torch.optim
import torch.nn.functional as F
class StatsPool(nn.Module):
"""Statistics pooling
Compute temporal mean and (unbiased) standard deviation
and returns their concatenation.
Reference
---------
htt... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._dynamo.... | suissemaxx/pyannote-audio-develop_colab | StatsPool | false | 4,386 | [
"MIT"
] | 0 | e9499372a1771c21e1604424a6dd041337111093 | https://github.com/suissemaxx/pyannote-audio-develop_colab/tree/e9499372a1771c21e1604424a6dd041337111093 | import torch
import warnings
import torch.nn as nn
from typing import Optional
import torch.optim
import torch.nn.functional as F
class Model(nn.Module):
"""Statistics pooling
Compute temporal mean and (unbiased) standard deviation
and returns their concatenation.
Reference
---------
https:/... |
ConvRelu | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConvRelu(nn.Module):
def __init__(self, in_, out):
super().__init__()
self.conv = nn.Conv2d(in_, out, 3, padding=1)
self.activation = nn.LeakyReLU(inplace=True)
def forward(self, x):
x = self.conv(x)
x = self.activation(x)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | sudonull1/Crack-Segmentation | ConvRelu | false | 4,387 | [
"MIT"
] | 0 | 640f86839ce5d79b48916b176caf8ad83c7355ae | https://github.com/sudonull1/Crack-Segmentation/tree/640f86839ce5d79b48916b176caf8ad83c7355ae | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_, out):
super().__init__()
self.conv = nn.Conv2d(in_, out, 3, padding=1)
self.activation = nn.LeakyReLU(inplace=True)
def forward(self, x):
x = self.conv(x)
x = self.activation(x)
... |
fire | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 itertools import product as product
import torch.nn as nn
class fire(nn.Module):
def __init__(self, inplanes, squeeze_planes, expand_planes, st=1):
super(fire, self).__init__()
self.conv1 = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1,
stride=1)
self.rel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from itertools import product... | suiguoxin/Pytorch_Retinaface | fire | false | 4,388 | [
"MIT"
] | 0 | d9393bad43103635261b4ec5b03f20e79931d0da | https://github.com/suiguoxin/Pytorch_Retinaface/tree/d9393bad43103635261b4ec5b03f20e79931d0da | import torch
from itertools import product as product
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inplanes, squeeze_planes, expand_planes, st=1):
super().__init__()
self.conv1 = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1,
stride=1)
self.relu1 = nn.R... |
Attn | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class Attn(torch.nn.Module):
"""
Attention:
feature_dim: dimension of feature embedding
method: method to calculate attention, (general, dot, concat)
input_dim: dimension of input embedding, default is the same as feature_dim; method dot is only availa... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | stillarrow/NRT-Lite | Attn | false | 4,389 | [
"MIT"
] | 0 | ba0f091ebfeae19325ce713e11bc426ff63402cd | https://github.com/stillarrow/NRT-Lite/tree/ba0f091ebfeae19325ce713e11bc426ff63402cd | import torch
from torch import nn
class Model(torch.nn.Module):
"""
Attention:
feature_dim: dimension of feature embedding
method: method to calculate attention, (general, dot, concat)
input_dim: dimension of input embedding, default is the same as feature_dim; method dot is only avail... |
TransformerEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
def fill_with_neg_inf(t):
"""FP16-compatible function that fills a tensor with -inf."""
return t.float().fill_(float('-inf')).type_as(t)
def buffered_future_mask(tensor1, tensor2, device):
dim1 = dim2 = tensor1.size()
if tensor2 is not None:
dim2 = tensor2.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.... | sreekanth-sreekumar/daiz-woz-nlp-project | TransformerEncoderLayer | false | 4,390 | [
"MIT"
] | 0 | 9971f752aee6a850e265f15e97a3a1ef2dacd323 | https://github.com/sreekanth-sreekumar/daiz-woz-nlp-project/tree/9971f752aee6a850e265f15e97a3a1ef2dacd323 | import torch
from torch import nn
def fill_with_neg_inf(t):
"""FP16-compatible function that fills a tensor with -inf."""
return t.float().fill_(float('-inf')).type_as(t)
def buffered_future_mask(tensor1, tensor2, device):
dim1 = dim2 = tensor1.size()
if tensor2 is not None:
dim2 = tensor2.s... |
IdentityPadding | # 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 IdentityPadding(nn.Module):
def __init__(self, num_filters, channels_in, stride):
super(IdentityPadding, self).__init__()
self.identity = nn.MaxPool2d(1, stride=stride)
self.num_zeros = num_filters - channels_in
... | 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... | sunqcc/Pytorch-HW-CIFAR10 | IdentityPadding | false | 4,391 | [
"MIT"
] | 0 | 33a55a5a832474083820b65c46f809ac98f8b109 | https://github.com/sunqcc/Pytorch-HW-CIFAR10/tree/33a55a5a832474083820b65c46f809ac98f8b109 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_filters, channels_in, stride):
super().__init__()
self.identity = nn.MaxPool2d(1, stride=stride)
self.num_zeros = num_filters - channels_in
def forward(self, x):
... |
SoftCrossEntropyLoss2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
from torch import nn
class SoftCrossEntropyLoss2d(nn.Module):
def forward(self, inputs, targets):
loss = 0
inputs = -F.log_softmax(inputs, dim=1)
for index in range(inputs.size()[0]):
loss += F.conv2d(inputs[range(index, index + 1)]... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | sudohainguyen/GLNet-pytorch | SoftCrossEntropyLoss2d | false | 4,392 | [
"Apache-2.0"
] | 0 | 91454831fac6e27f894d55d320dd3bcec946ac0f | https://github.com/sudohainguyen/GLNet-pytorch/tree/91454831fac6e27f894d55d320dd3bcec946ac0f | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
def forward(self, inputs, targets):
loss = 0
inputs = -F.log_softmax(inputs, dim=1)
for index in range(inputs.size()[0]):
loss += F.conv2d(inputs[range(index, index + 1)], targets[range
... |
TransformerDecoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def _get_activation_fn(activation):
if activation == 'relu':
return F.relu
raise RuntimeError('activation shud be relu, not {}'.format(activation))
class TransformerDecoderLayer(nn.Module):
def __init__(self, d_model, nhead, dim_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | salmon7ish/Video-Captioning | TransformerDecoderLayer | false | 4,393 | [
"MIT"
] | 0 | 08359b1824195a7f5eac5b58982efd19ebc6db01 | https://github.com/salmon7ish/Video-Captioning/tree/08359b1824195a7f5eac5b58982efd19ebc6db01 | import torch
from torch import nn
import torch.nn.functional as F
def _get_activation_fn(activation):
if activation == 'relu':
return F.relu
raise RuntimeError('activation shud be relu, not {}'.format(activation))
class Model(nn.Module):
def __init__(self, d_model, nhead, dim_feedforward, dropo... |
AvgPoolPadding | # 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 AvgPoolPadding(nn.Module):
def __init__(self, num_filters, channels_in, stride):
super(AvgPoolPadding, self).__init__()
self.identity = nn.AvgPool2d(stride, stride=stride)
self.num_zeros = num_filters - channels_in
... | 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... | sunqcc/Pytorch-HW-CIFAR10 | AvgPoolPadding | false | 4,394 | [
"MIT"
] | 0 | 33a55a5a832474083820b65c46f809ac98f8b109 | https://github.com/sunqcc/Pytorch-HW-CIFAR10/tree/33a55a5a832474083820b65c46f809ac98f8b109 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_filters, channels_in, stride):
super().__init__()
self.identity = nn.AvgPool2d(stride, stride=stride)
self.num_zeros = num_filters - channels_in
def forward(self, x):
... |
GrayScaleToRGB | # 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
class GrayScaleToRGB(torch.nn.Module):
"""
Applies the transformation on an image to convert grayscale to rgb
"""
def __init__(self):
super().__init__()
def forward(self, sample):
return sample.repeat(3, 1, 1)
def get_inputs():
return [t... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_... | saifullah3396/doc_robustness | GrayScaleToRGB | false | 4,395 | [
"Apache-2.0"
] | 0 | 80207fb44709d4b97de826331c074784be9c75ca | https://github.com/saifullah3396/doc_robustness/tree/80207fb44709d4b97de826331c074784be9c75ca | import torch
import torch.utils.data
class Model(torch.nn.Module):
"""
Applies the transformation on an image to convert grayscale to rgb
"""
def __init__(self):
super().__init__()
def forward(self, sample):
return sample.repeat(3, 1, 1)
def get_inputs():
return [torch.rand... |
SineActivation | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 t2v(tau, f, weight_linear, bias_linear, weight_periodic, bias_periodic,
arg=None):
if arg:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear, arg)
else:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear)
v2 = torch.matmul(tau, weight_perio... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | sungreong/PyTimeSeries | SineActivation | false | 4,396 | [
"MIT"
] | 0 | d5321c1226fc7fb6a45fec7009843894be417594 | https://github.com/sungreong/PyTimeSeries/tree/d5321c1226fc7fb6a45fec7009843894be417594 | import torch
import torch.nn as nn
def t2v(tau, f, weight_linear, bias_linear, weight_periodic, bias_periodic,
arg=None):
if arg:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear, arg)
else:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear)
v2 = torch.matmul(tau, weight_perio... |
GraphConvolution | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
from torch import nn
import torch.autograd
from torch.nn.modules.module import Module
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907.
"""
def __init__(self, state_dim, name='', out_state_dim=None):
sup... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
from torch import nn
import torch.autograd
from torc... | sumanmichael/Palmira_pb | GraphConvolution | false | 4,397 | [
"MIT"
] | 0 | 8ca9f370ccd9bba694317be648ce5e4f4c55d0e7 | https://github.com/sumanmichael/Palmira_pb/tree/8ca9f370ccd9bba694317be648ce5e4f4c55d0e7 | from torch.nn import Module
import torch
from torch import nn
import torch.autograd
from torch.nn.modules.module import Module
class Model(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907.
"""
def __init__(self, state_dim, name='', out_state_dim=None):
super().__init... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.