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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
Conv1dSamePadding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 conv1d_same_padding(input, weight, bias, stride, dilation, groups):
kernel, dilation, stride = weight.size(2), dilation[0], stride[0]
l_out = l_in = input.size(2)
padding = (l_out - 1) * stride - l_in + dilation * (kernel - 1) + 1
i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.nn.functional as F
assert_size_stride = torch.... | UlysseCoteAllard/LongShortNetworkBipolar | Conv1dSamePadding | false | 5,921 | [
"Apache-2.0"
] | 1 | f6d146b967b4747f02d6589a0483d6c67394ee87 | https://github.com/UlysseCoteAllard/LongShortNetworkBipolar/tree/f6d146b967b4747f02d6589a0483d6c67394ee87 | import torch
from torch import nn
import torch.nn.functional as F
def conv1d_same_padding(input, weight, bias, stride, dilation, groups):
kernel, dilation, stride = weight.size(2), dilation[0], stride[0]
l_out = l_in = input.size(2)
padding = (l_out - 1) * stride - l_in + dilation * (kernel - 1) + 1
i... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ResidualBlock(nn.Module):
"""Redisual network block for style transfer."""
def __init__(self, nchannels):
"""Create a block of a residual network."""
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(nchannels, nchannels, kernel_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | TrueMatthewKirkham/face-preserving-style-transfer | ResidualBlock | false | 5,922 | [
"MIT"
] | 1 | ae8a9509570227ea52776fba85658022124c886c | https://github.com/TrueMatthewKirkham/face-preserving-style-transfer/tree/ae8a9509570227ea52776fba85658022124c886c | import torch
import torch.nn as nn
class Model(nn.Module):
"""Redisual network block for style transfer."""
def __init__(self, nchannels):
"""Create a block of a residual network."""
super().__init__()
self.conv1 = nn.Conv2d(nchannels, nchannels, kernel_size=3)
self.conv2 = nn... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.utils.data
import torch
import torch.nn as nn
import torch.nn.functional as F
class PositionalEncoding(nn.Module):
def __init__(self, max_pos, d_k):
super().__init__()
self.w_rpr = nn.Linear(d_k, max_pos + 1, bias=False)
def __call__(self, q, dist... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | TomerRonen34/MeshCNN | MultiHeadAttention | false | 5,923 | [
"MIT"
] | 1 | 8c50f3804c48044b78572d652a42184640e904d9 | https://github.com/TomerRonen34/MeshCNN/tree/8c50f3804c48044b78572d652a42184640e904d9 | import torch
import numpy as np
import torch.utils.data
import torch
import torch.nn as nn
import torch.nn.functional as F
class PositionalEncoding(nn.Module):
def __init__(self, max_pos, d_k):
super().__init__()
self.w_rpr = nn.Linear(d_k, max_pos + 1, bias=False)
def __call__(self, q, dist... |
FFN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class FFN(nn.Module):
def __init__(self, d):
super().__init__()
self.fc_1 = nn.Linear(2 * d, 4 * d)
self.drop = nn.Dropout(0.1)
self.fc_2 = nn.Linear(4 * d, d)
def forward(self, x_1, x_2):
x = self.fc_1... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | VKCOM/TopicsDataset | FFN | false | 5,924 | [
"MIT"
] | 1 | 149919321ba61a8f17b22f62f60f4aedec43d72b | https://github.com/VKCOM/TopicsDataset/tree/149919321ba61a8f17b22f62f60f4aedec43d72b | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d):
super().__init__()
self.fc_1 = nn.Linear(2 * d, 4 * d)
self.drop = nn.Dropout(0.1)
self.fc_2 = nn.Linear(4 * d, d)
def forward(self, x_1, x_2):
x = self.fc... |
GSAHelper | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GSAHelper(nn.Module):
def __init__(self, d):
super().__init__()
self.d = d
self.fc_k = nn.Linear(self.d, self.d)
self.fc_q = nn.Linear(self.d, self.d)
self.fc_kq = nn.Linear(self.d, self.d)
def forward(self, k, q):
m = 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.... | VKCOM/TopicsDataset | GSAHelper | false | 5,925 | [
"MIT"
] | 1 | 149919321ba61a8f17b22f62f60f4aedec43d72b | https://github.com/VKCOM/TopicsDataset/tree/149919321ba61a8f17b22f62f60f4aedec43d72b | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, d):
super().__init__()
self.d = d
self.fc_k = nn.Linear(self.d, self.d)
self.fc_q = nn.Linear(self.d, self.d)
self.fc_kq = nn.Linear(self.d, self.d)
def forward(self, k, q):
m = k.sha... |
PoolFormerBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 warnings
import torch.nn as nn
def _no_grad_trunc_normal_(tensor, mean, std, a, b):
"""Copy & paste from PyTorch official master until it's in a few official releases - RW
Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
"""
def n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
import ... | TranNhiem/MVAR_SSL | PoolFormerBlock | false | 5,926 | [
"MIT"
] | 1 | 339964db4d40f06a92866675ff99ef67cd968cca | https://github.com/TranNhiem/MVAR_SSL/tree/339964db4d40f06a92866675ff99ef67cd968cca | import math
import torch
import warnings
import torch.nn as nn
def _no_grad_trunc_normal_(tensor, mean, std, a, b):
"""Copy & paste from PyTorch official master until it's in a few official releases - RW
Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
"""
def n... |
ActorCritic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def log_normal_density(x, mean, log_std, std):
"""returns guassian density given x on log scale"""
variance = std.pow(2)
log_density = -(x - mean).pow(2) / (2 * variance) - 0.5 * np.log(2 * np.pi
) - ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
im... | Tzenthin/pytorch-ppo-sac-HalfCheetah-v2 | ActorCritic | false | 5,927 | [
"MIT"
] | 1 | 282a4104ec577056a141909e29dc97ed425a566c | https://github.com/Tzenthin/pytorch-ppo-sac-HalfCheetah-v2/tree/282a4104ec577056a141909e29dc97ed425a566c | import math
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def log_normal_density(x, mean, log_std, std):
"""returns guassian density given x on log scale"""
variance = std.pow(2)
log_density = -(x - mean).pow(2) / (2 * variance) - 0.5 * np.log(2 * np.pi
) - ... |
AttentionPool2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class AttentionPool2d(nn.Module):
def __init__(self, spacial_dim: 'int', embed_dim: 'int', num_heads:
'int', output_dim: 'int'=None):
super().__init__()
self.positional_embedding = nn.Parameter(torch.randn(spacial_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.... | Vaishaal/CLIP | AttentionPool2d | false | 5,928 | [
"MIT"
] | 1 | 16adcf2a5ff41d6a3f1bb45165aa348031fdbafe | https://github.com/Vaishaal/CLIP/tree/16adcf2a5ff41d6a3f1bb45165aa348031fdbafe | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, spacial_dim: 'int', embed_dim: 'int', num_heads:
'int', output_dim: 'int'=None):
super().__init__()
self.positional_embedding = nn.Parameter(torch.randn(spacial_dim **
... |
AttnBahd | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 as nn
class AttnBahd(nn.Module):
def __init__(self, encoder_out_dim, decoder_hid_dim, attn_dim=None):
"""
Attention mechanism
:param encoder_out_dim: Dimension of hidden states of the encoder h_j
:param decoder_hid_dim: Dimension of the hidden sta... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | UKPLab/acl2018-msr-workshop-binlin | AttnBahd | false | 5,929 | [
"Apache-2.0"
] | 1 | 9b8021dfa14a8bc131df117fa9985699fc8cedea | https://github.com/UKPLab/acl2018-msr-workshop-binlin/tree/9b8021dfa14a8bc131df117fa9985699fc8cedea | import torch
from torch import nn as nn
class Model(nn.Module):
def __init__(self, encoder_out_dim, decoder_hid_dim, attn_dim=None):
"""
Attention mechanism
:param encoder_out_dim: Dimension of hidden states of the encoder h_j
:param decoder_hid_dim: Dimension of the hidden states... |
GSA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GSAHelper(nn.Module):
def __init__(self, d):
super().__init__()
self.d = d
self.fc_k = nn.Linear(self.d, self.d)
self.fc_q = nn.Linear(self.d, self.d)
self.fc_kq = nn.Linear(self.d, self.d)
def forward(self, k, q):
m = 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.... | VKCOM/TopicsDataset | GSA | false | 5,930 | [
"MIT"
] | 1 | 149919321ba61a8f17b22f62f60f4aedec43d72b | https://github.com/VKCOM/TopicsDataset/tree/149919321ba61a8f17b22f62f60f4aedec43d72b | import torch
from torch import nn
class GSAHelper(nn.Module):
def __init__(self, d):
super().__init__()
self.d = d
self.fc_k = nn.Linear(self.d, self.d)
self.fc_q = nn.Linear(self.d, self.d)
self.fc_kq = nn.Linear(self.d, self.d)
def forward(self, k, q):
m = k... |
CpuSpeedModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CpuSpeedModel(nn.Module):
def __init__(self, input_size, output_size):
super(CpuSpeedModel, self).__init__()
hidden_size = 100
self.linear1 = nn.Linear(input_size, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidden_size)
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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | VVKot/mlinsecond-general-cpu | CpuSpeedModel | false | 5,931 | [
"MIT"
] | 1 | d3e08027dc3152b5c88c2e5bf4b365eedbdcb0d1 | https://github.com/VVKot/mlinsecond-general-cpu/tree/d3e08027dc3152b5c88c2e5bf4b365eedbdcb0d1 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, output_size):
super().__init__()
hidden_size = 100
self.linear1 = nn.Linear(input_size, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidden_size)
self.linear3 = nn.Linear(hidden... |
SinkhornKnopp | # 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.distributed as dist
class SinkhornKnopp(torch.nn.Module):
def __init__(self, num_iters: 'int'=3, epsilon: 'float'=0.05,
world_size: 'int'=1):
"""Approximates optimal transport using the Sinkhorn-Knopp algorithm.
A simple iterative method to approach the double s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_str... | TranNhiem/MVAR_SSL | SinkhornKnopp | false | 5,932 | [
"MIT"
] | 1 | 339964db4d40f06a92866675ff99ef67cd968cca | https://github.com/TranNhiem/MVAR_SSL/tree/339964db4d40f06a92866675ff99ef67cd968cca | import torch
import torch.distributed as dist
class Model(torch.nn.Module):
def __init__(self, num_iters: 'int'=3, epsilon: 'float'=0.05,
world_size: 'int'=1):
"""Approximates optimal transport using the Sinkhorn-Knopp algorithm.
A simple iterative method to approach the double stochasti... |
WeightNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 WeightNet(nn.Module):
"""WeightNet in Temporal interlace module.
The WeightNet consists of two parts: one convolution layer
and a sigmoid function. Following the convolution layer, the sigmoid
function and rescale module can scale our output to the range (0, 2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | VisualAnalysisOfHumans/LOVEU_TRACK1_TOP3_SUBMISSION | WeightNet | false | 5,933 | [
"MIT"
] | 1 | 6f4d1c7e6883d6b0664fcd04265f437247afab54 | https://github.com/VisualAnalysisOfHumans/LOVEU_TRACK1_TOP3_SUBMISSION/tree/6f4d1c7e6883d6b0664fcd04265f437247afab54 | import torch
import torch.nn as nn
class Model(nn.Module):
"""WeightNet in Temporal interlace module.
The WeightNet consists of two parts: one convolution layer
and a sigmoid function. Following the convolution layer, the sigmoid
function and rescale module can scale our output to the range (0, 2).
... |
ResidualSequential | # 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.optim
import torch.nn as nn
import torch.nn.init
class ResidualSequential(nn.Sequential):
def __init__(self, *args):
super(ResidualSequential, self).__init__(*args)
def forward(self, x):
out = super(ResidualSequential, self).forward(x)
x_ = None
if o... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.optim
import torch.nn as nn
import torch.nn.init
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_... | Volodimirich/DL-in-denoising-MCT-rock-images | ResidualSequential | false | 5,934 | [
"MIT"
] | 1 | 0201d42a45221e4e0faaf50c59bf48c435bcdc82 | https://github.com/Volodimirich/DL-in-denoising-MCT-rock-images/tree/0201d42a45221e4e0faaf50c59bf48c435bcdc82 | import torch
import torch.optim
import torch.nn as nn
import torch.nn.init
class Model(nn.Sequential):
def __init__(self, *args):
super().__init__(*args)
def forward(self, x):
out = super(ResidualSequential, self).forward(x)
x_ = None
if out.size(2) != x.size(2) or out.size(3... |
TorchModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class TorchLinearModule(torch.nn.Module):
def __init__(self, in_size, out_size):
super(TorchLinearModule, self).__init__()
self._linear = torch.nn.Linear(in_size, out_size)
def forward(self, x):
return self._linear(x)
class TorchModule(torch.nn.Module):... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn
ass... | VedPatwardhan/ivy | TorchModule | false | 5,935 | [
"Apache-2.0"
] | 1 | 7b2105fa8cf38879444a1029bfaa7f0b2f27717a | https://github.com/VedPatwardhan/ivy/tree/7b2105fa8cf38879444a1029bfaa7f0b2f27717a | import torch
import torch.nn
class TorchLinearModule(torch.nn.Module):
def __init__(self, in_size, out_size):
super().__init__()
self._linear = torch.nn.Linear(in_size, out_size)
def forward(self, x):
return self._linear(x)
class Model(torch.nn.Module):
def __init__(self, in_s... |
TVLoss | # 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
import torch.utils.data
import torch.utils.data.dataset
import torch
import torch.nn as nn
import torch.utils.data.distributed
class TVLoss(nn.Module):
"""Regularization loss based on Li FeiFei."""
def __init__(self, weight: 'Tensor') ->None:
"""The weight inform... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import Tensor
import torch.utils.data
import torch.utils.data.dataset
import torch
import torch.nn as nn
import torch.utils.data.... | Tubbz-alt/SRGAN-PyTorch-2 | TVLoss | false | 5,936 | [
"Apache-2.0"
] | 1 | c1a01c99287a6212a3dc76ac17baafcf1c9f3013 | https://github.com/Tubbz-alt/SRGAN-PyTorch-2/tree/c1a01c99287a6212a3dc76ac17baafcf1c9f3013 | import torch
from torch import Tensor
import torch.utils.data
import torch.utils.data.dataset
import torch
import torch.nn as nn
import torch.utils.data.distributed
class Model(nn.Module):
"""Regularization loss based on Li FeiFei."""
def __init__(self, weight: 'Tensor') ->None:
"""The weight informa... |
OffsetNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 OffsetNet(nn.Module):
"""OffsetNet in Temporal interlace module.
The OffsetNet consists of one convolution layer and two fc layers
with a relu activation following with a sigmoid function. Following
the convolution layer, two fc layers and relu are applied to ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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_... | VisualAnalysisOfHumans/LOVEU_TRACK1_TOP3_SUBMISSION | OffsetNet | false | 5,937 | [
"MIT"
] | 1 | 6f4d1c7e6883d6b0664fcd04265f437247afab54 | https://github.com/VisualAnalysisOfHumans/LOVEU_TRACK1_TOP3_SUBMISSION/tree/6f4d1c7e6883d6b0664fcd04265f437247afab54 | import torch
import torch.nn as nn
class Model(nn.Module):
"""OffsetNet in Temporal interlace module.
The OffsetNet consists of one convolution layer and two fc layers
with a relu activation following with a sigmoid function. Following
the convolution layer, two fc layers and relu are applied to the ... |
CombinedPooling | # 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.optim
import torch.utils.data
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data.distributed
class CombinedPooling(nn.Module):
def __init__(self):
super().__init__()
self.max_pooling = nn.AdaptiveMaxPool2d(1)
self.avg_pooling = nn.AdaptiveAvgP... | 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.optim
import torch.utils.data
import torch.nn as nn
import torch.nn.parallel... | VisualComputingInstitute/CROWDBOT_perception | CombinedPooling | false | 5,938 | [
"MIT"
] | 1 | df98f3f658c39fb3fa4ac0456f1214f7918009f6 | https://github.com/VisualComputingInstitute/CROWDBOT_perception/tree/df98f3f658c39fb3fa4ac0456f1214f7918009f6 | import torch
import torch.optim
import torch.utils.data
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
self.max_pooling = nn.AdaptiveMaxPool2d(1)
self.avg_pooling = nn.AdaptiveAvgPool2d(1)
... |
SEModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SEModule(nn.Module):
def __init__(self, channels, reduction=1 / 16):
super().__init__()
self.avg_pool = nn.AdaptiveAvgPool3d(1)
self.bottleneck = self._round_width(channels, reduction)
self.fc1 = nn.Conv3d(channels, self.bottleneck, kernel_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | VisualAnalysisOfHumans/LOVEU_TRACK1_TOP3_SUBMISSION | SEModule | false | 5,939 | [
"MIT"
] | 1 | 6f4d1c7e6883d6b0664fcd04265f437247afab54 | https://github.com/VisualAnalysisOfHumans/LOVEU_TRACK1_TOP3_SUBMISSION/tree/6f4d1c7e6883d6b0664fcd04265f437247afab54 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, channels, reduction=1 / 16):
super().__init__()
self.avg_pool = nn.AdaptiveAvgPool3d(1)
self.bottleneck = self._round_width(channels, reduction)
self.fc1 = nn.Conv3d(channels, self.bottleneck, kernel_siz... |
PointWiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PointWiseFeedForward(torch.nn.Module):
def __init__(self, hidden_units, dropout_rate):
super(PointWiseFeedForward, self).__init__()
self.conv1 = torch.nn.Conv1d(hidden_units, hidden_units, kernel_size=1)
self.dropout1 = torch.nn.Dropout(p=dropout_rate)
self.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
assert_size_stride = torch._C... | Vivdaddy/recsys-filterbubbles | PointWiseFeedForward | false | 5,940 | [
"MIT"
] | 1 | d21639bce515ffef5ba2db530dc2505eee1f83c0 | https://github.com/Vivdaddy/recsys-filterbubbles/tree/d21639bce515ffef5ba2db530dc2505eee1f83c0 | import torch
class Model(torch.nn.Module):
def __init__(self, hidden_units, dropout_rate):
super().__init__()
self.conv1 = torch.nn.Conv1d(hidden_units, hidden_units, kernel_size=1)
self.dropout1 = torch.nn.Dropout(p=dropout_rate)
self.relu = torch.nn.ReLU()
self.conv2 = t... |
SigmaL1SmoothLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class SigmaL1SmoothLoss(nn.Module):
def forward(self, pred, targ):
reg_diff = torch.abs(targ - pred)
reg_loss = torch.where(torch.le(reg_diff, 1 / 9), 4.5 * torch.pow(
reg_diff, 2), reg_diff - 1 / 18)
return reg_loss.mean()
def get_inputs():... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | VrunArya/Hacktoberfest2021 | SigmaL1SmoothLoss | false | 5,941 | [
"MIT"
] | 1 | 5e739e52310dabf8b131abe5ecf906e13711b9d6 | https://github.com/VrunArya/Hacktoberfest2021/tree/5e739e52310dabf8b131abe5ecf906e13711b9d6 | import torch
from torch import nn
class Model(nn.Module):
def forward(self, pred, targ):
reg_diff = torch.abs(targ - pred)
reg_loss = torch.where(torch.le(reg_diff, 1 / 9), 4.5 * torch.pow(
reg_diff, 2), reg_diff - 1 / 18)
return reg_loss.mean()
def get_inputs():
return ... |
ChebConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class ChebConv(nn.Module):
"""
The ChebNet convolution operation.
:param in_c: int, number of input dim
:param out_c: int, number of output dim
:param K: int, the order of Chebyshev Polynomial,切比雪夫展开多少阶
"""
def __init__(self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | V-cyberpunk-01/GNN | ChebConv | false | 5,942 | [
"MIT"
] | 1 | 25a6b24f4d8fad626af33f98e189b221c50406cd | https://github.com/V-cyberpunk-01/GNN/tree/25a6b24f4d8fad626af33f98e189b221c50406cd | import torch
import torch.nn as nn
import torch.nn.init as init
class Model(nn.Module):
"""
The ChebNet convolution operation.
:param in_c: int, number of input dim
:param out_c: int, number of output dim
:param K: int, the order of Chebyshev Polynomial,切比雪夫展开多少阶
"""
def __init__(self, i... |
Loss_fn | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class Loss_fn(nn.Module):
def __init__(self, eps=0.001):
super().__init__()
self.eps = eps
def forward(self, ip, target):
diff = ip - target
loss = torch.mean(torch.sqrt(diff * diff + self.eps * self.eps))
return loss
def get_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
import torch.nn as nn
assert... | Vrushank264/Low-Light-Enhancement | Loss_fn | false | 5,943 | [
"MIT"
] | 1 | 3c13a10a16eab8183b8fbd0c063d9815b662259a | https://github.com/Vrushank264/Low-Light-Enhancement/tree/3c13a10a16eab8183b8fbd0c063d9815b662259a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps=0.001):
super().__init__()
self.eps = eps
def forward(self, ip, target):
diff = ip - target
loss = torch.mean(torch.sqrt(diff * diff + self.eps * self.eps))
return loss
def get_inputs(... |
TemporallyBatchedAdditiveAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AdditiveAttention(nn.Module):
def __init__(self, encoder_hidden_state_dim, decoder_hidden_state_dim,
internal_dim=None):
super(AdditiveAttention, self).__init__()
if internal_dim is None:
internal_dim = i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Vision-CAIR/UnlikelihoodMotionForecasting | TemporallyBatchedAdditiveAttention | false | 5,944 | [
"MIT"
] | 1 | 556d6a3ed3e4e0e2d88108d7dbb48933313b58aa | https://github.com/Vision-CAIR/UnlikelihoodMotionForecasting/tree/556d6a3ed3e4e0e2d88108d7dbb48933313b58aa | import torch
import torch.nn as nn
import torch.nn.functional as F
class AdditiveAttention(nn.Module):
def __init__(self, encoder_hidden_state_dim, decoder_hidden_state_dim,
internal_dim=None):
super().__init__()
if internal_dim is None:
internal_dim = int((encoder_hidden_stat... |
FocalLoss2d | # 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 FocalLoss2d(nn.Module):
def __init__(self, alpha=0.25, gamma=2, ignore_index=None, reduction=
'mean', **kwargs):
super(FocalLoss2d, self).__init__()
self.alpha = alpha
self.gamma = gamma
self.smooth = 1e-06
self.ignore_index... | 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
... | WHU-YH-jx/bionetwork_segmentation | FocalLoss2d | false | 5,945 | [
"MIT"
] | 1 | 556c5b61a1a3784875b31eacb8c6bb418d70ee9a | https://github.com/WHU-YH-jx/bionetwork_segmentation/tree/556c5b61a1a3784875b31eacb8c6bb418d70ee9a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, alpha=0.25, gamma=2, ignore_index=None, reduction=
'mean', **kwargs):
super().__init__()
self.alpha = alpha
self.gamma = gamma
self.smooth = 1e-06
self.ignore_index = ignore_index
... |
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.nn as nn
class CompressChannels(nn.Module):
"""
Compresses the input channels to 2 by concatenating the results of
Global Average Pooling(GAP) and Global Max Pooling(GMP).
HxWxC => HxWx2
"""
def forward(self, x):
return torch.cat((torch.max(x, 1)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Vrushank264/Low-Light-Enhancement | SpatialAttention | false | 5,946 | [
"MIT"
] | 1 | 3c13a10a16eab8183b8fbd0c063d9815b662259a | https://github.com/Vrushank264/Low-Light-Enhancement/tree/3c13a10a16eab8183b8fbd0c063d9815b662259a | import torch
import torch.nn as nn
class CompressChannels(nn.Module):
"""
Compresses the input channels to 2 by concatenating the results of
Global Average Pooling(GAP) and Global Max Pooling(GMP).
HxWxC => HxWx2
"""
def forward(self, x):
return torch.cat((torch.max(x, 1)... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class DiceLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, target):
smooth = 1e-05
num = target.size(0)
input = input.view(num, -1)
target = target.view(num, -1)
intersection = input * target
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | WHU-YH-jx/bionetwork_segmentation | DiceLoss | false | 5,947 | [
"MIT"
] | 1 | 556c5b61a1a3784875b31eacb8c6bb418d70ee9a | https://github.com/WHU-YH-jx/bionetwork_segmentation/tree/556c5b61a1a3784875b31eacb8c6bb418d70ee9a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, target):
smooth = 1e-05
num = target.size(0)
input = input.view(num, -1)
target = target.view(num, -1)
intersection = input * target
... |
DiffLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.checkpoint
class DiffLoss(nn.Module):
def __init__(self):
super(DiffLoss, self).__init__()
def forward(self, input1, input2):
batch_size = input1.size(0)
input1 = input1.view(batch_size, -1)
input2 = input2.view(batch_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | Wang-Chuanyu/MMSA | DiffLoss | false | 5,948 | [
"MIT"
] | 1 | 2a720530c369e68656102287edb651780e827135 | https://github.com/Wang-Chuanyu/MMSA/tree/2a720530c369e68656102287edb651780e827135 | import torch
import torch.nn as nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input1, input2):
batch_size = input1.size(0)
input1 = input1.view(batch_size, -1)
input2 = input2.view(batch_size, -1)
inp... |
BBoxTransform | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.onnx
class BBoxTransform(nn.Module):
def forward(self, anchors, regression):
"""
decode_box_outputs adapted from https://github.com/google/automl/blob/master/efficientdet/anchors.py
Args:
anchors: [batchsize, boxes, (y1, x1, y2, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
import torch.onnx
assert_size_stride = torch._C._dyn... | Wabinab/eye_of_ml | BBoxTransform | false | 5,949 | [
"Apache-2.0"
] | 1 | 9c475ddf4e56d84bc5a23d871d59169bc6061ab0 | https://github.com/Wabinab/eye_of_ml/tree/9c475ddf4e56d84bc5a23d871d59169bc6061ab0 | import torch
from torch import nn
import torch.onnx
class Model(nn.Module):
def forward(self, anchors, regression):
"""
decode_box_outputs adapted from https://github.com/google/automl/blob/master/efficientdet/anchors.py
Args:
anchors: [batchsize, boxes, (y1, x1, y2, x2)]
... |
MSE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.checkpoint
class MSE(nn.Module):
def __init__(self):
super(MSE, self).__init__()
def forward(self, pred, real):
diffs = torch.add(real, -pred)
n = torch.numel(diffs.data)
mse = torch.sum(diffs.pow(2)) / n
return ms... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.checkpoint
assert_size_stride = torch._C._dynamo... | Wang-Chuanyu/MMSA | MSE | false | 5,950 | [
"MIT"
] | 1 | 2a720530c369e68656102287edb651780e827135 | https://github.com/Wang-Chuanyu/MMSA/tree/2a720530c369e68656102287edb651780e827135 | import torch
import torch.nn as nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, real):
diffs = torch.add(real, -pred)
n = torch.numel(diffs.data)
mse = torch.sum(diffs.pow(2)) / n
return mse
def... |
AdditiveAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AdditiveAttention(nn.Module):
def __init__(self, encoder_hidden_state_dim, decoder_hidden_state_dim,
internal_dim=None):
super(AdditiveAttention, self).__init__()
if internal_dim is None:
internal_dim = i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Vision-CAIR/UnlikelihoodMotionForecasting | AdditiveAttention | false | 5,951 | [
"MIT"
] | 1 | 556d6a3ed3e4e0e2d88108d7dbb48933313b58aa | https://github.com/Vision-CAIR/UnlikelihoodMotionForecasting/tree/556d6a3ed3e4e0e2d88108d7dbb48933313b58aa | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, encoder_hidden_state_dim, decoder_hidden_state_dim,
internal_dim=None):
super().__init__()
if internal_dim is None:
internal_dim = int((encoder_hidden_state_dim +
... |
CapsuleLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
class CapsuleLoss(nn.Module):
def __init__(self):
super(CapsuleLoss, self).__init__()
def forward(self, output, target):
class_loss = (target * F.relu(0.9 - output) + 0.5 * (1 - target) *
F.relu(output - 0.1)).mean... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | WdBlink/AugMix-3DOCUNet-Brats2019 | CapsuleLoss | false | 5,952 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, target):
class_loss = (target * F.relu(0.9 - output) + 0.5 * (1 - target) *
F.relu(output - 0.1)).mean()
return class... |
DDPGConvBody | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
def layer_init(layer, w_scale=1.0):
nn.init.orthogonal_(layer.weight.data)
layer.weight.data.mul_(w_scale)
nn.init.constant_(layer.bias.data, 0)
return layer
class DDPGConvBody(nn.Module):
def __init__(self, in_channels=4):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | Sohojoe/UdacityDeepRL-Project2 | DDPGConvBody | false | 5,953 | [
"MIT"
] | 1 | 7137eea0b606ea32d00424d23130ff213f03ecf1 | https://github.com/Sohojoe/UdacityDeepRL-Project2/tree/7137eea0b606ea32d00424d23130ff213f03ecf1 | import torch
import torch.nn as nn
import torch.nn.functional as F
def layer_init(layer, w_scale=1.0):
nn.init.orthogonal_(layer.weight.data)
layer.weight.data.mul_(w_scale)
nn.init.constant_(layer.bias.data, 0)
return layer
class Model(nn.Module):
def __init__(self, in_channels=4):
sup... |
CustomKLLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch.nn.modules.loss import _Loss
class CustomKLLoss(_Loss):
"""
KL_Loss = (|dot(mean , mean)| + |dot(std, std)| - |log(dot(std, std))| - 1) / N
N is the total number of image voxels
"""
def __init__(self, *args, **kwargs):
super(CustomKLLoss, self).__init__()
def ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch.nn.modules.... | WdBlink/AugMix-3DOCUNet-Brats2019 | CustomKLLoss | false | 5,954 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch.nn.modules.loss import _Loss
class Model(_Loss):
"""
KL_Loss = (|dot(mean , mean)| + |dot(std, std)| - |log(dot(std, std))| - 1) / N
N is the total number of image voxels
"""
def __init__(self, *args, **kwargs):
super().__init__()
def forward(self, mean, std):... |
SIMSE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.checkpoint
class SIMSE(nn.Module):
def __init__(self):
super(SIMSE, self).__init__()
def forward(self, pred, real):
diffs = torch.add(real, -pred)
n = torch.numel(diffs.data)
simse = torch.sum(diffs).pow(2) / n ** 2
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.checkpoint
assert_size_stride = torch._C._dynamo... | Wang-Chuanyu/MMSA | SIMSE | false | 5,955 | [
"MIT"
] | 1 | 2a720530c369e68656102287edb651780e827135 | https://github.com/Wang-Chuanyu/MMSA/tree/2a720530c369e68656102287edb651780e827135 | import torch
import torch.nn as nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, real):
diffs = torch.add(real, -pred)
n = torch.numel(diffs.data)
simse = torch.sum(diffs).pow(2) / n ** 2
return si... |
GridAttentionBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GridAttentionBlock(nn.Module):
def __init__(self, in_channels):
super(GridAttentionBlock, self).__init__()
self.inter_channels = in_channels
self.in_channels = in_channels
self.gating_channels = in_channels
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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_... | WHU-YH-jx/bionetwork_segmentation | GridAttentionBlock | false | 5,956 | [
"MIT"
] | 1 | 556c5b61a1a3784875b31eacb8c6bb418d70ee9a | https://github.com/WHU-YH-jx/bionetwork_segmentation/tree/556c5b61a1a3784875b31eacb8c6bb418d70ee9a | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.inter_channels = in_channels
self.in_channels = in_channels
self.gating_channels = in_channels
self.theta = nn.Conv2d(in_chan... |
Relu_Caps | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
class Relu_Caps(nn.Module):
def __init__(self, num_C, num_D, theta=0.2, eps=0.0001):
super(Relu_Caps, self).__init__()
self.num_C = num_C
self.num_D = num_D
self.theta = theta
self.eps = eps
def forward... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_... | WdBlink/AugMix-3DOCUNet-Brats2019 | Relu_Caps | false | 5,957 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_C, num_D, theta=0.2, eps=0.0001):
super().__init__()
self.num_C = num_C
self.num_D = num_D
self.theta = theta
self.eps = eps
def forward(self, x):
... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.autograd import Variable
def compute_per_channel_dice(input, target, epsilon=1e-05, ignore_index=
None, weight=None):
assert input.size() == target.size(
), "'input' and 'target' must have the same shape"
if ignore_index is not None:
mask = targ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | WdBlink/AugMix-3DOCUNet-Brats2019 | DiceLoss | false | 5,958 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
from torch.autograd import Variable
def compute_per_channel_dice(input, target, epsilon=1e-05, ignore_index=
None, weight=None):
assert input.size() == target.size(
), "'input' and 'target' must have the same shape"
if ignore_index is not None:
mask = targ... |
CPC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.checkpoint
class CPC(nn.Module):
"""
Contrastive Predictive Coding: score computation. See https://arxiv.org/pdf/1807.03748.pdf.
Args:
x_size (int): embedding size of input modality representation x
y_size (int): embedd... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | Wang-Chuanyu/MMSA | CPC | false | 5,959 | [
"MIT"
] | 1 | 2a720530c369e68656102287edb651780e827135 | https://github.com/Wang-Chuanyu/MMSA/tree/2a720530c369e68656102287edb651780e827135 | import torch
import torch.nn as nn
import torch.utils.checkpoint
class Model(nn.Module):
"""
Contrastive Predictive Coding: score computation. See https://arxiv.org/pdf/1807.03748.pdf.
Args:
x_size (int): embedding size of input modality representation x
y_size (int): embe... |
Caps_Conv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Caps_Conv(nn.Module):
def __init__(self, in_C, in_D, out_C, out_D, kernel_size, stride=1,
padding=0, dilation=1, bias=False):
super(Caps_Conv, self).__init__()
self.in_C = in_C
self.in_D = in_D
self.out_C = out_C
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.as... | WdBlink/AugMix-3DOCUNet-Brats2019 | Caps_Conv | false | 5,960 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import math
import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_C, in_D, out_C, out_D, kernel_size, stride=1,
padding=0, dilation=1, bias=False):
super().__init__()
self.in_C = in_C
self.in_D = in_D
self.out_C = out_C
self.out_D = out_D
... |
MSEWithLogitsLoss | # 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 MSELoss
class MSEWithLogitsLoss(MSELoss):
"""
This loss combines a `Sigmoid` layer and the `MSELoss` in one single class.
"""
def __init__(self):
super(MSEWithLogitsLoss, self).__init__()
self.sigmoid = nn.Sigmoid()
def forwa... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
from torch.nn import MSELoss
assert_size_stride = torch._C._dynamo.g... | WdBlink/AugMix-3DOCUNet-Brats2019 | MSEWithLogitsLoss | false | 5,961 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
from torch.nn import MSELoss
class Model(MSELoss):
"""
This loss combines a `Sigmoid` layer and the `MSELoss` in one single class.
"""
def __init__(self):
super().__init__()
self.sigmoid = nn.Sigmoid()
def forward(self, input, target):
re... |
SoftDiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch.nn.modules.loss import _Loss
class SoftDiceLoss(_Loss):
"""
Soft_Dice = 2*|dot(A, B)| / (|dot(A, A)| + |dot(B, B)| + eps)
eps is a small constant to avoid zero division,
"""
def __init__(self, *args, **kwargs):
super(SoftDiceLoss, self).__init__()
def forward(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn.modules.loss import _Loss
assert_size_stride = torch._C._dynamo.guards.asse... | WdBlink/AugMix-3DOCUNet-Brats2019 | SoftDiceLoss | false | 5,962 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch.nn.modules.loss import _Loss
class Model(_Loss):
"""
Soft_Dice = 2*|dot(A, B)| / (|dot(A, A)| + |dot(B, B)| + eps)
eps is a small constant to avoid zero division,
"""
def __init__(self, *args, **kwargs):
super().__init__()
def forward(self, y_pred, y_true, eps... |
Squash | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class Squash(nn.Module):
def __init__(self, num_C, num_D, eps=0.0001):
super(Squash, self).__init__()
self.num_C = num_C
self.num_D = num_D
self.eps = eps
def forward(self, x):
x_caps = x.view(x.shape[0], self.num_C, self.num_D, x.sha... | 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... | WdBlink/AugMix-3DOCUNet-Brats2019 | Squash | false | 5,963 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, num_C, num_D, eps=0.0001):
super().__init__()
self.num_C = num_C
self.num_D = num_D
self.eps = eps
def forward(self, x):
x_caps = x.view(x.shape[0], self.num_C, self.num_D, x.shape[2], x.
... |
LinearCaps | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.nn.functional as F
from torch.nn.parameter import Parameter
class LinearCaps(nn.Module):
def __init__(self, in_features, num_C, num_D, bias=False, eps=0.0001):
super(LinearCaps, self).__init__()
self.in_features = in_features
self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | WdBlink/AugMix-3DOCUNet-Brats2019 | LinearCaps | false | 5,964 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import math
import torch
from torch import nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, in_features, num_C, num_D, bias=False, eps=0.0001):
super().__init__()
self.in_features = in_features
self.num_C = num_C
... |
Encoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
def conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
def create_conv(in_channels, out_channels, kernel_size, order, num_groups,
padding=1):... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | WdBlink/AugMix-3DOCUNet-Brats2019 | Encoder | false | 5,965 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
def conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
def create_conv(in_channels, out_channels, kernel_size, order, num_groups,
padding=1):... |
OutputTransition | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 OutputTransition(nn.Module):
"""
Decoder output layer
output the prediction of segmentation result
"""
def __init__(self, inChans, outChans):
super(OutputTransition, self).__init__()
self.conv1 = nn.Conv3d(in_channels=inChans, out_channels=o... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | WdBlink/AugMix-3DOCUNet-Brats2019 | OutputTransition | false | 5,966 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
class Model(nn.Module):
"""
Decoder output layer
output the prediction of segmentation result
"""
def __init__(self, inChans, outChans):
super().__init__()
self.conv1 = nn.Conv3d(in_channels=inChans, out_channels=outChans,
kernel_size=... |
MultiheadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import torch.utils.checkpoint
from torch.nn import Parameter
class MultiheadAttention(nn.Module):
"""Multi-headed attention.
See "Attention Is All You Need" for more details.
"""
def __init__(s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Wang-Chuanyu/MMSA | MultiheadAttention | false | 5,967 | [
"MIT"
] | 1 | 2a720530c369e68656102287edb651780e827135 | https://github.com/Wang-Chuanyu/MMSA/tree/2a720530c369e68656102287edb651780e827135 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import torch.utils.checkpoint
from torch.nn import Parameter
class Model(nn.Module):
"""Multi-headed attention.
See "Attention Is All You Need" for more details.
"""
def __init__(self, embed_di... |
Relu_Adpt | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch.nn.parameter import Parameter
class Relu_Adpt(nn.Module):
def __init__(self, num_C, num_D, eps=0.0001):
super(Relu_Adpt, self).__init__()
self.num_C = num_C
self.num_D = num_D
self.eps = eps
self.... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
from to... | WdBlink/AugMix-3DOCUNet-Brats2019 | Relu_Adpt | false | 5,968 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, num_C, num_D, eps=0.0001):
super().__init__()
self.num_C = num_C
self.num_D = num_D
self.eps = eps
self.theta = Parameter(t... |
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.nn as nn
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_size == 7 else 1
self.conv1 = nn.Conv2d(2, 1, kernel_s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | WhuEven/multi_hyp_cc | SpatialAttention | false | 5,969 | [
"MIT"
] | 1 | 53a6bc438b865d606f5e6a53a442efbd8a04fe5b | https://github.com/WhuEven/multi_hyp_cc/tree/53a6bc438b865d606f5e6a53a442efbd8a04fe5b | import torch
import torch.nn as nn
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.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)... |
UpBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
class UpBlock(nn.Module):
"""
A module down sa... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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... | WdBlink/AugMix-3DOCUNet-Brats2019 | UpBlock | false | 5,970 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
import torch.nn.functional as F
def conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
class Model(nn.Module):
"""
A module down samp... |
GreenBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
class GreenBlock(nn.Module):
"""
green_block(inp, filters, name=None)
--------... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | WdBlink/AugMix-3DOCUNet-Brats2019 | GreenBlock | false | 5,971 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
def conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
class Model(nn.Module):
"""
green_block(inp, filters, name=None)
-------------... |
ExtResNetBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
def create_conv(in_channels, out_channels, kernel_size, order, num_groups,
padding=1):... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | WdBlink/AugMix-3DOCUNet-Brats2019 | ExtResNetBlock | false | 5,972 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import torch
from torch import nn
def conv3d(in_channels, out_channels, kernel_size, bias, padding=1, stride=1):
return nn.Conv3d(in_channels, out_channels, kernel_size, padding=
padding, bias=bias, stride=stride)
def create_conv(in_channels, out_channels, kernel_size, order, num_groups,
padding=1):... |
LeNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.utils
class LeNet(torch.nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = torch.nn.Conv2d(1, 6, kernel_size=5, padding=2)
self.conv2 = torch.nn.Conv2d(6, 16, kernel_size=5)
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
import t... | WingFeiTsang/FedML_New | LeNet | false | 5,973 | [
"Apache-2.0"
] | 1 | 755d8fc63ce08df4dc3eef326aa7693e94262c7e | https://github.com/WingFeiTsang/FedML_New/tree/755d8fc63ce08df4dc3eef326aa7693e94262c7e | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(1, 6, kernel_size=5, padding=2)
self.conv2 = torch.nn.Conv2d(6, 16, kernel_size=5)
self.max_poolin... |
LinearCapsPro | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch.nn.parameter import Parameter
class LinearCapsPro(nn.Module):
def __init__(self, in_features, num_C, num_D, eps=0.0001):
super(LinearCapsPro, self).__init__()
self.in_features = in_features
self.num_C = num_C
self.num_D = nu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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... | WdBlink/AugMix-3DOCUNet-Brats2019 | LinearCapsPro | false | 5,974 | [
"MIT"
] | 1 | 125c6c8682b51a550eeac9173d13d0a211576abc | https://github.com/WdBlink/AugMix-3DOCUNet-Brats2019/tree/125c6c8682b51a550eeac9173d13d0a211576abc | import math
import torch
from torch import nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, in_features, num_C, num_D, eps=0.0001):
super().__init__()
self.in_features = in_features
self.num_C = num_C
self.num_D = num_D
self.eps = eps
... |
ConvertPointsFromHomogeneous | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def convert_points_from_homogeneous(points, eps=1e-06):
"""Function that converts points from homogeneous to Euclidean space.
See :class:`~torchgeometry.ConvertPointsFromHomogeneous` for details.
Examples::
>>> input = torch.rand(2, 4, 3) # BxNx3
>>> ... | 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... | Wizaron/torchgeometry | ConvertPointsFromHomogeneous | false | 5,975 | [
"Apache-2.0"
] | 1 | 59a8d25dd811ded6a139d5c0c2442b06f43dc775 | https://github.com/Wizaron/torchgeometry/tree/59a8d25dd811ded6a139d5c0c2442b06f43dc775 | import torch
import torch.nn as nn
def convert_points_from_homogeneous(points, eps=1e-06):
"""Function that converts points from homogeneous to Euclidean space.
See :class:`~torchgeometry.ConvertPointsFromHomogeneous` for details.
Examples::
>>> input = torch.rand(2, 4, 3) # BxNx3
>>> ... |
CPUForgetMult | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import *
class CPUForgetMult(torch.nn.Module):
def __init__(self):
super(CPUForgetMult, self).__init__()
def forward(self, f, x, hidden_init=None):
result = []
forgets = f.split(1, dim=0)
prev_h = hidden_init
for i, h in enumerate((f * x).spli... | 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 typing import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | WittmannF/fastai_docs | CPUForgetMult | false | 5,976 | [
"Apache-2.0"
] | 1 | 03ecae01557a5e4a196dd858b10a57b224df52cd | https://github.com/WittmannF/fastai_docs/tree/03ecae01557a5e4a196dd858b10a57b224df52cd | import torch
from typing import *
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, f, x, hidden_init=None):
result = []
forgets = f.split(1, dim=0)
prev_h = hidden_init
for i, h in enumerate((f * x).split(1, dim=0)):
i... |
LearnedPositionalEmbedding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LearnedPositionalEmbedding(nn.Embedding):
"""
This module learns positional embeddings up to a fixed maximum size.
Padding ids are ignored by either offsetting based on padding_idx
or by setting padding_idx to None and ensuring 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.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | William-Zhanng/Protein_affinity | LearnedPositionalEmbedding | false | 5,977 | [
"MIT"
] | 1 | 8abd12073b182274bf464ff23fd3be406c4e39ac | https://github.com/William-Zhanng/Protein_affinity/tree/8abd12073b182274bf464ff23fd3be406c4e39ac | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Embedding):
"""
This module learns positional embeddings up to a fixed maximum size.
Padding ids are ignored by either offsetting based on padding_idx
or by setting padding_idx to None and ensuring that the appropriate
... |
AdaptiveConcatPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from typing import *
from typing import Optional
class AdaptiveConcatPool2d(nn.Module):
"""Layer that concats `AdaptiveAvgPool2d` and `AdaptiveMaxPool2d`"""
def __init__(self, sz: 'Optional[int]'=None):
"""Output will be 2*sz or 2 if sz is None"""
super().__i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
from typing import *
from typing import Optional
assert_size_stride ... | WittmannF/fastai_docs | AdaptiveConcatPool2d | false | 5,978 | [
"Apache-2.0"
] | 1 | 03ecae01557a5e4a196dd858b10a57b224df52cd | https://github.com/WittmannF/fastai_docs/tree/03ecae01557a5e4a196dd858b10a57b224df52cd | import torch
from torch import nn
from typing import *
from typing import Optional
class Model(nn.Module):
"""Layer that concats `AdaptiveAvgPool2d` and `AdaptiveMaxPool2d`"""
def __init__(self, sz: 'Optional[int]'=None):
"""Output will be 2*sz or 2 if sz is None"""
super().__init__()
... |
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
from torchvision.datasets import *
import torch.nn.functional as F
import torch.nn as nn
from torchvision.transforms import *
class Normalize(nn.Module):
"""Performs :math:`L_p` normalization of inputs over specified dimension.
Does:
.. math::
v = \\frac{v}{\\max(\\lVert v \\rVert_p... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torchvision.datasets im... | Womcos/SCARF | Normalize | false | 5,979 | [
"MIT"
] | 1 | b90251bc23410cb810a7082ca75147a7aae21dec | https://github.com/Womcos/SCARF/tree/b90251bc23410cb810a7082ca75147a7aae21dec | import torch
from torchvision.datasets import *
import torch.nn.functional as F
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
"""Performs :math:`L_p` normalization of inputs over specified dimension.
Does:
.. math::
v = \\frac{v}{\\max(\\lVert v \\rVert_p, \\... |
Mean | # 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 torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Mean(nn.Module):
def __init__(self, dim, keep_dim=False):
super(Mean, self).__init__()
self.dim = dim
self.keep_dim = keep_dim
def forward(self, input):
return 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
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
assert_size_stride = torch._C._dynamo.guards.a... | Womcos/SCARF | Mean | false | 5,980 | [
"MIT"
] | 1 | b90251bc23410cb810a7082ca75147a7aae21dec | https://github.com/Womcos/SCARF/tree/b90251bc23410cb810a7082ca75147a7aae21dec | import torch
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
def __init__(self, dim, keep_dim=False):
super().__init__()
self.dim = dim
self.keep_dim = keep_dim
def forward(self, input):
return input.mean(s... |
Sum | # 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 torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Sum(nn.Module):
def __init__(self, dim, keep_dim=False):
super(Sum, self).__init__()
self.dim = dim
self.keep_dim = keep_dim
def forward(self, input):
return 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 torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
assert_size_stride = torch._C._dynamo.guards.a... | Womcos/SCARF | Sum | false | 5,981 | [
"MIT"
] | 1 | b90251bc23410cb810a7082ca75147a7aae21dec | https://github.com/Womcos/SCARF/tree/b90251bc23410cb810a7082ca75147a7aae21dec | import torch
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
def __init__(self, dim, keep_dim=False):
super().__init__()
self.dim = dim
self.keep_dim = keep_dim
def forward(self, input):
return input.sum(se... |
InvDepth | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 InvDepth(nn.Module):
def __init__(self, height, width, min_depth=0.5, max_depth=25.0):
super(InvDepth, self).__init__()
self._min_range = 1.0 / max_depth
self._max_range = 1.0 / min_depth
self.w = nn.Parameter(self._init_weights(height, wid... | 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... | Wizaron/torchgeometry | InvDepth | false | 5,982 | [
"Apache-2.0"
] | 1 | 59a8d25dd811ded6a139d5c0c2442b06f43dc775 | https://github.com/Wizaron/torchgeometry/tree/59a8d25dd811ded6a139d5c0c2442b06f43dc775 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, height, width, min_depth=0.5, max_depth=25.0):
super().__init__()
self._min_range = 1.0 / max_depth
self._max_range = 1.0 / min_depth
self.w = nn.Parameter(self._init_weights(height, width))
def _in... |
ActivationBin | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.autograd import Function
import torch
import torch.nn as nn
class BinaryActivation(Function):
@staticmethod
def forward(self, input):
self.save_for_backward(input)
output = torch.sign(input)
return output
@staticmethod
def backward(self, grad_output):
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.autograd import Function
import torch.nn as nn
assert_size_stride = torch._C._... | Wulingtian/micronet | ActivationBin | false | 5,983 | [
"MIT"
] | 1 | d04298bced90258d38a6455a743aa0b55a12852e | https://github.com/Wulingtian/micronet/tree/d04298bced90258d38a6455a743aa0b55a12852e | from torch.autograd import Function
import torch
import torch.nn as nn
class BinaryActivation(Function):
@staticmethod
def forward(self, input):
self.save_for_backward(input)
output = torch.sign(input)
return output
@staticmethod
def backward(self, grad_output):
input... |
UpsampleConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 torchvision.datasets import *
import torch.nn.functional as F
from torch.nn.parameter import Parameter
from torch.nn import Parameter
from torch.nn.modules.utils import _pair
from torchvision.transforms import *
class UpsampleConv2d(Module):
"""
To avo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
import math
from torchvision.datasets import *
from ... | Womcos/SCARF | UpsampleConv2d | false | 5,984 | [
"MIT"
] | 1 | b90251bc23410cb810a7082ca75147a7aae21dec | https://github.com/Womcos/SCARF/tree/b90251bc23410cb810a7082ca75147a7aae21dec | from torch.nn import Module
import math
import torch
from torchvision.datasets import *
import torch.nn.functional as F
from torch.nn.parameter import Parameter
from torch.nn import Parameter
from torch.nn.modules.utils import _pair
from torchvision.transforms import *
class Model(Module):
"""
To avoid the ch... |
TranLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 TranLayer(nn.Module):
def __init__(self, embed_dim, num_nodes):
super(TranLayer, self).__init__()
self.embed_dim = embed_dim
self.num_nodes = num_nodes
self.linear_nodes = nn.Linear(in_features=self.num_nodes... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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_... | WingsUpete/EEG2Age | TranLayer | false | 5,985 | [
"MIT"
] | 1 | 8d7b9049fe4e47c701659bbbf2843600fa7c8d8d | https://github.com/WingsUpete/EEG2Age/tree/8d7b9049fe4e47c701659bbbf2843600fa7c8d8d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, embed_dim, num_nodes):
super().__init__()
self.embed_dim = embed_dim
self.num_nodes = num_nodes
self.linear_nodes = nn.Linear(in_features=self.num_nodes,
out_f... |
TokenEmbedding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 TokenEmbedding(nn.Module):
def __init__(self, c_in, d_model):
super(TokenEmbedding, self).__init__()
padding = 1 if torch.__version__ >= '1.5.0' else 2
self.tokenConv = nn.Conv1d(in_channels=c_in, out_channels=d_model,
kernel_size=3, pa... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Xianchao-Wu/informer | TokenEmbedding | false | 5,986 | [
"Apache-2.0"
] | 1 | bb9cb3c6ff9e7e76c8dbbf3bcc7924df1f18982d | https://github.com/Xianchao-Wu/informer/tree/bb9cb3c6ff9e7e76c8dbbf3bcc7924df1f18982d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, c_in, d_model):
super().__init__()
padding = 1 if torch.__version__ >= '1.5.0' else 2
self.tokenConv = nn.Conv1d(in_channels=c_in, out_channels=d_model,
kernel_size=3, padding=padding, padding_mode='... |
InversePose | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def inverse_pose(pose, eps=1e-06):
"""Function that inverts a 4x4 pose.
Args:
points (Tensor): tensor with poses.
Returns:
Tensor: tensor with inverted poses.
Shape:
- Input: :math:`(N, 4, 4)`
- Output: :math:`(N, 4, 4)`
Exampl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Wizaron/torchgeometry | InversePose | false | 5,987 | [
"Apache-2.0"
] | 1 | 59a8d25dd811ded6a139d5c0c2442b06f43dc775 | https://github.com/Wizaron/torchgeometry/tree/59a8d25dd811ded6a139d5c0c2442b06f43dc775 | import torch
import torch.nn as nn
def inverse_pose(pose, eps=1e-06):
"""Function that inverts a 4x4 pose.
Args:
points (Tensor): tensor with poses.
Returns:
Tensor: tensor with inverted poses.
Shape:
- Input: :math:`(N, 4, 4)`
- Output: :math:`(N, 4, 4)`
Exampl... |
BalancedL1Loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
import torch.onnx
def balanced_l1_loss(pred, target, beta=1.0, alpha=0.5, gamma=1.5,
reduction='none'):
assert beta > 0
assert pred.size() == target.size() and target.numel() > 0
diff = torch.abs(pred - target)
b = np.e ** (gamma / alpha) - 1
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import numpy as np
imp... | Xiangzhaohong/LidarNet | BalancedL1Loss | false | 5,988 | [
"Apache-2.0"
] | 1 | 42d025a7b629e387c9b9b01ead3558a8da81a3b0 | https://github.com/Xiangzhaohong/LidarNet/tree/42d025a7b629e387c9b9b01ead3558a8da81a3b0 | import torch
import numpy as np
import torch.nn as nn
import torch.onnx
def balanced_l1_loss(pred, target, beta=1.0, alpha=0.5, gamma=1.5,
reduction='none'):
assert beta > 0
assert pred.size() == target.size() and target.numel() > 0
diff = torch.abs(pred - target)
b = np.e ** (gamma / alpha) - 1
... |
triplet_my_loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
def normalize(x, axis=-1):
"""Normalizing to unit length along the specified dimension.
Args:
x: pytorch Variable
Returns:
x: pytorch Variable, same shape as input
"""
x = 1.0 * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)
return... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | Xavierxhq/fruit_identification | triplet_my_loss | false | 5,989 | [
"MIT"
] | 1 | 54cdf2c3e0aad26ae98b081e44ad1655b6f0a758 | https://github.com/Xavierxhq/fruit_identification/tree/54cdf2c3e0aad26ae98b081e44ad1655b6f0a758 | import torch
from torch import nn
def normalize(x, axis=-1):
"""Normalizing to unit length along the specified dimension.
Args:
x: pytorch Variable
Returns:
x: pytorch Variable, same shape as input
"""
x = 1.0 * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)
return... |
LinearExcitability | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch.nn.parameter import Parameter
def linearExcitability(input, weight, excitability=None, bias=None):
"""Applies a linear transformation to the incoming data: :math:`y = c(xA^T) + b`.
Shape:
- input: :math:`(N, *, in_features)`
- we... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
from torch import nn
from torch.nn.parameter import Parameter
assert... | XSMUBC/DNC-lifelong-learning | LinearExcitability | false | 5,990 | [
"MIT"
] | 1 | 55b40bad65eb3cb68c50411acf8f770bfc52e3d9 | https://github.com/XSMUBC/DNC-lifelong-learning/tree/55b40bad65eb3cb68c50411acf8f770bfc52e3d9 | import math
import torch
from torch import nn
from torch.nn.parameter import Parameter
def linearExcitability(input, weight, excitability=None, bias=None):
"""Applies a linear transformation to the incoming data: :math:`y = c(xA^T) + b`.
Shape:
- input: :math:`(N, *, in_features)`
- we... |
TemporalEmbedding | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.nn as nn
class FixedEmbedding(nn.Module):
def __init__(self, c_in, d_model):
super(FixedEmbedding, self).__init__()
w = torch.zeros(c_in, d_model).float()
w.require_grad = False
position = torch.arange(0, c_in).float().unsqueeze(1)
div... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guar... | Xianchao-Wu/informer | TemporalEmbedding | false | 5,991 | [
"Apache-2.0"
] | 1 | bb9cb3c6ff9e7e76c8dbbf3bcc7924df1f18982d | https://github.com/Xianchao-Wu/informer/tree/bb9cb3c6ff9e7e76c8dbbf3bcc7924df1f18982d | import math
import torch
import torch.nn as nn
class FixedEmbedding(nn.Module):
def __init__(self, c_in, d_model):
super().__init__()
w = torch.zeros(c_in, d_model).float()
w.require_grad = False
position = torch.arange(0, c_in).float().unsqueeze(1)
div_term = (torch.arang... |
StraightThroughEstimator | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.autograd import Function
import torch
import torch.nn.functional as F
from torch import nn
from torchvision.transforms import functional as F
import torch.jit
def straight_through_estimator(input: 'torch.Tensor') ->torch.Tensor:
""" straight through estimator
>>> straight_through_estimator(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.autograd import Function
import torch.nn.functional as F
from torch import nn
from torchvision.transforms import functional as F
... | Xiangyu-Han/homura | StraightThroughEstimator | false | 5,992 | [
"Apache-2.0"
] | 1 | c366ca70b4b65f6a4809bf76926bbd926320262e | https://github.com/Xiangyu-Han/homura/tree/c366ca70b4b65f6a4809bf76926bbd926320262e | from torch.autograd import Function
import torch
import torch.nn.functional as F
from torch import nn
from torchvision.transforms import functional as F
import torch.jit
def straight_through_estimator(input: 'torch.Tensor') ->torch.Tensor:
""" straight through estimator
>>> straight_through_estimator(torch.r... |
GateLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GateLayer(nn.Module):
def __init__(self, input_dim):
super(GateLayer, self).__init__()
self._norm_layer1 = nn.Linear(input_dim * 2, input_dim)
self._norm_layer2 = nn.Linear(input_dim, 1)
def forward(self, input1, input2):
norm_input = 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 import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | Xiaolong-Qi/CRSLab | GateLayer | false | 5,993 | [
"MIT"
] | 1 | d507378c86f4996727bf062482e1f224486d4533 | https://github.com/Xiaolong-Qi/CRSLab/tree/d507378c86f4996727bf062482e1f224486d4533 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_dim):
super().__init__()
self._norm_layer1 = nn.Linear(input_dim * 2, input_dim)
self._norm_layer2 = nn.Linear(input_dim, 1)
def forward(self, input1, input2):
norm_input = self._norm_layer1(to... |
SpatialPyramidPooling2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from math import floor
from math import ceil
import torch.nn as nn
import torch.nn.functional as F
class SpatialPyramidPooling2d(nn.Module):
"""apply spatial pyramid pooling over a 4d input(a mini-batch of 2d inputs
with additional channel dimension) as described in the paper
'Spatial Pyramid... | 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... | Wyattwwwww/CS172_Visualized-Sanitation-Evaluator-in-Microenvironment | SpatialPyramidPooling2d | false | 5,994 | [
"MIT"
] | 1 | 02880a0698f262aad65639e8de52349fdb610355 | https://github.com/Wyattwwwww/CS172_Visualized-Sanitation-Evaluator-in-Microenvironment/tree/02880a0698f262aad65639e8de52349fdb610355 | import torch
from math import floor
from math import ceil
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""apply spatial pyramid pooling over a 4d input(a mini-batch of 2d inputs
with additional channel dimension) as described in the paper
'Spatial Pyramid Pooling in deep c... |
complex_relu_layer | # 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 complex_relu_layer(nn.Module):
def __init__(self):
super(complex_relu_layer, self).__init__()
def complex_relu(self, real, img):
mask = 1.0 * (real >= 0)
return mask * real, mask * img
def forward(self, real, img=None):
if img is ... | 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... | XitongZhang1994/SimpleMagNet | complex_relu_layer | false | 5,995 | [
"MIT"
] | 1 | d3df7a2f528474214b7d396ea9831db3aa280090 | https://github.com/XitongZhang1994/SimpleMagNet/tree/d3df7a2f528474214b7d396ea9831db3aa280090 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def complex_relu(self, real, img):
mask = 1.0 * (real >= 0)
return mask * real, mask * img
def forward(self, real, img=None):
if img is None:
img = real[1]
... |
Discriminator2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
class Discriminator2(nn.Module):
def __init__(self, n_h):
super(Discriminator2, self).__init__()
self.f_k = nn.Bilinear(n_h, n_h, 1)
for m in self.modules():
self.weights_init(m)
def weights_init(self, m):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | XrosLiang/GraphCL | Discriminator2 | false | 5,996 | [
"MIT"
] | 1 | fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | https://github.com/XrosLiang/GraphCL/tree/fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_h):
super().__init__()
self.f_k = nn.Bilinear(n_h, n_h, 1)
for m in self.modules():
self.weights_init(m)
def weights_init(self, m):
if isinstance(m, nn.Bilinear... |
PartialConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.onnx
class PartialConv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=True):
super(PartialConv, self).__init__()
self.feature_conv = nn.Conv2d(in_channels, out_channels,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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.onnx
assert_size_stride = torch._C._dynamo.gu... | XiaoSanGit/talking-head-anime-landing | PartialConv | false | 5,997 | [
"MIT"
] | 1 | 36dbf1b8aef7357cda2a3524cb0c533f32670394 | https://github.com/XiaoSanGit/talking-head-anime-landing/tree/36dbf1b8aef7357cda2a3524cb0c533f32670394 | import torch
import torch.nn as nn
import torch.onnx
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=True):
super().__init__()
self.feature_conv = nn.Conv2d(in_channels, out_channels,
kernel_siz... |
Unfold | # 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 Unfold(torch.nn.Module):
"""Module for unfolding tensor.
Performs strided crops on 2d (image) tensors. Stride is assumed to be half the crop size.
"""
def __init__(self, img_size, fold_size):
"""
Args:
img_size: Input size.
... | 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_... | XrosLiang/GraphCL | Unfold | false | 5,998 | [
"MIT"
] | 1 | fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | https://github.com/XrosLiang/GraphCL/tree/fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | import torch
import torch.utils.data
class Model(torch.nn.Module):
"""Module for unfolding tensor.
Performs strided crops on 2d (image) tensors. Stride is assumed to be half the crop size.
"""
def __init__(self, img_size, fold_size):
"""
Args:
img_size: Input size.
... |
SelfAttentionBatch | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SelfAttentionBatch(nn.Module):
def __init__(self, dim, da, alpha=0.2, dropout=0.5):
super(SelfAttentionBatch, self).__init__()
self.dim = dim
self.da = da
self.alpha = alpha
self.dropout = dropout
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | Xiaolong-Qi/CRSLab | SelfAttentionBatch | false | 5,999 | [
"MIT"
] | 1 | d507378c86f4996727bf062482e1f224486d4533 | https://github.com/Xiaolong-Qi/CRSLab/tree/d507378c86f4996727bf062482e1f224486d4533 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim, da, alpha=0.2, dropout=0.5):
super().__init__()
self.dim = dim
self.da = da
self.alpha = alpha
self.dropout = dropout
self.a = nn.Parameter(torch.zeros... |
PriorDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
class PriorDiscriminator(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.l0 = nn.Linear(input_dim, input_dim)
self.l1 = nn.Linear(input_dim, input_dim)
self.l2 = 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.utils.data
impor... | XrosLiang/GraphCL | PriorDiscriminator | false | 6,000 | [
"MIT"
] | 1 | fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | https://github.com/XrosLiang/GraphCL/tree/fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.l0 = nn.Linear(input_dim, input_dim)
self.l1 = nn.Linear(input_dim, input_dim)
self.l2 = nn.Linear(input_dim, 1... |
L1_Charbonnier_loss_color | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch.nn.modules.loss import _Loss
class L1_Charbonnier_loss_color(_Loss):
"""
L1 Charbonnierloss color
"""
def __init__(self, para):
super(L1_Charbonnier_loss_color, self).__init__()
self.eps = 0.001
def forward(self, X, Y):
diff... | 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.utils.data
from torch.nn.modules.loss import _Loss
assert_size_str... | YDDDDG/3D2Unet | L1_Charbonnier_loss_color | false | 6,001 | [
"MIT"
] | 1 | daca056958fb2ae319dc18a350e04b3cefe0d99f | https://github.com/YDDDDG/3D2Unet/tree/daca056958fb2ae319dc18a350e04b3cefe0d99f | import torch
import torch.utils.data
from torch.nn.modules.loss import _Loss
class Model(_Loss):
"""
L1 Charbonnierloss color
"""
def __init__(self, para):
super().__init__()
self.eps = 0.001
def forward(self, X, Y):
diff = torch.add(X, -Y)
diff_sq = diff * diff
... |
L1_Charbonnier_loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch.nn.modules.loss import _Loss
class L1_Charbonnier_loss(_Loss):
"""
L1 Charbonnierloss
"""
def __init__(self, para):
super(L1_Charbonnier_loss, self).__init__()
self.eps = 0.001
def forward(self, X, Y):
diff = torch.add(X, -Y... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.data
from... | YDDDDG/3D2Unet | L1_Charbonnier_loss | false | 6,002 | [
"MIT"
] | 1 | daca056958fb2ae319dc18a350e04b3cefe0d99f | https://github.com/YDDDDG/3D2Unet/tree/daca056958fb2ae319dc18a350e04b3cefe0d99f | import torch
import torch.utils.data
from torch.nn.modules.loss import _Loss
class Model(_Loss):
"""
L1 Charbonnierloss
"""
def __init__(self, para):
super().__init__()
self.eps = 0.001
def forward(self, X, Y):
diff = torch.add(X, -Y)
error = torch.sqrt(diff * dif... |
Discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
class Discriminator(nn.Module):
def __init__(self, n_h):
super(Discriminator, self).__init__()
self.f_k = nn.Bilinear(n_h, n_h, 1)
for m in self.modules():
self.weights_init(m)
def weights_init(self, m):
i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | XrosLiang/GraphCL | Discriminator | false | 6,003 | [
"MIT"
] | 1 | fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | https://github.com/XrosLiang/GraphCL/tree/fdf9fabcdaddbc17e5c8b7ac9e9d2bdfe4acc56c | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_h):
super().__init__()
self.f_k = nn.Bilinear(n_h, n_h, 1)
for m in self.modules():
self.weights_init(m)
def weights_init(self, m):
if isinstance(m, nn.Bilinear... |
ResNetBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
import torch.onnx
from torch.nn import Conv2d
from torch.nn import InstanceNorm2d
from torch.nn.init import kaiming_normal_
from torch.nn.init import xavier_normal_
from torch import relu
def create_init_function(method: 'str'='none'):
def init(module: 'Module'):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | XiaoSanGit/talking-head-anime-landing | ResNetBlock | false | 6,004 | [
"MIT"
] | 1 | 36dbf1b8aef7357cda2a3524cb0c533f32670394 | https://github.com/XiaoSanGit/talking-head-anime-landing/tree/36dbf1b8aef7357cda2a3524cb0c533f32670394 | from torch.nn import Module
import torch
import torch.onnx
from torch.nn import Conv2d
from torch.nn import InstanceNorm2d
from torch.nn.init import kaiming_normal_
from torch.nn.init import xavier_normal_
from torch import relu
def create_init_function(method: 'str'='none'):
def init(module: 'Module'):
... |
BCE_LOSS | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
from torch.nn.modules.loss import _Loss
import torch.optim
import torch.nn
class BCE_LOSS(_Loss):
def __init__(self):
super().__init__()
self.bce_loss = torch.nn.BCEWithLogitsLoss()
def forward(self, input, label):
one_hot = torch.zeros_like(input)
C ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch.... | YZW-explorer/EOD | BCE_LOSS | false | 6,005 | [
"Apache-2.0"
] | 1 | f10e64de86c0f356ebf5c7e923f4042eec4207b1 | https://github.com/YZW-explorer/EOD/tree/f10e64de86c0f356ebf5c7e923f4042eec4207b1 | import math
import torch
from torch.nn.modules.loss import _Loss
import torch.optim
import torch.nn
class Model(_Loss):
def __init__(self):
super().__init__()
self.bce_loss = torch.nn.BCEWithLogitsLoss()
def forward(self, input, label):
one_hot = torch.zeros_like(input)
C = i... |
PSNR | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch.nn.modules.loss import _Loss
def normalize_reverse(x, centralize=False, normalize=False, val_range=255.0):
if normalize:
x = x * val_range
if centralize:
x = x + val_range / 2
return x
class PSNR(_Loss):
def __init__(self, centralize=F... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.data
from... | YDDDDG/3D2Unet | PSNR | false | 6,006 | [
"MIT"
] | 1 | daca056958fb2ae319dc18a350e04b3cefe0d99f | https://github.com/YDDDDG/3D2Unet/tree/daca056958fb2ae319dc18a350e04b3cefe0d99f | import torch
import torch.utils.data
from torch.nn.modules.loss import _Loss
def normalize_reverse(x, centralize=False, normalize=False, val_range=255.0):
if normalize:
x = x * val_range
if centralize:
x = x + val_range / 2
return x
class Model(_Loss):
def __init__(self, centralize=... |
DownsampleA | # 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 DownsampleA(nn.Module):
def __init__(self, nIn, nOut, stride):
super(DownsampleA, self).__init__()
self.avg = nn.AvgPool2d(kernel_size=1, stride=stride)
def forward(self, x):
x = self.avg(x)
return torch.cat((x, x.mul(0)), 1)
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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | YasufumiSakai/Pruning | DownsampleA | false | 6,007 | [
"BSD-3-Clause"
] | 1 | 5c8bc0d780fab41e1bd894b0360bd50e14cd0571 | https://github.com/YasufumiSakai/Pruning/tree/5c8bc0d780fab41e1bd894b0360bd50e14cd0571 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, nIn, nOut, stride):
super().__init__()
self.avg = nn.AvgPool2d(kernel_size=1, stride=stride)
def forward(self, x):
x = self.avg(x)
return torch.cat((x, x.mul(0)), 1)
def get_inputs():
return [... |
Gradient | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data
class Gradient(nn.Module):
def __init__(self):
super(Gradient, self).__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1], [0, 0, 0]]
kernel_h = torch.Fl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | YDDDDG/3D2Unet | Gradient | false | 6,008 | [
"MIT"
] | 1 | daca056958fb2ae319dc18a350e04b3cefe0d99f | https://github.com/YDDDDG/3D2Unet/tree/daca056958fb2ae319dc18a350e04b3cefe0d99f | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1], [0, 0, 0]]
kernel_h = torch.FloatTensor(kernel_... |
L1GradientLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data
from torch.nn.modules.loss import _Loss
class Gradient(nn.Module):
def __init__(self):
super(Gradient, self).__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1]... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | YDDDDG/3D2Unet | L1GradientLoss | false | 6,009 | [
"MIT"
] | 1 | daca056958fb2ae319dc18a350e04b3cefe0d99f | https://github.com/YDDDDG/3D2Unet/tree/daca056958fb2ae319dc18a350e04b3cefe0d99f | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data
from torch.nn.modules.loss import _Loss
class Gradient(nn.Module):
def __init__(self):
super().__init__()
kernel_v = [[0, -1, 0], [0, 0, 0], [0, 1, 0]]
kernel_h = [[0, 0, 0], [-1, 0, 1], [0, 0, 0]]
... |
PosEnc | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.utils
from matplotlib import cm as cm
from torch.nn.parallel import *
from torchvision.models import *
from torchvision.datasets import *
class PosEnc(nn.Module):
def __init__(self, C, ks):
super().__init__()
self.weight = nn... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
import torch.utils
from matplotlib import cm as cm
from torch.nn.parallel import *
from torchv... | XuelianCheng/ppuda | PosEnc | false | 6,010 | [
"MIT"
] | 1 | d5b89928e430e2d5b976f84b1ea66b4b901e6cda | https://github.com/XuelianCheng/ppuda/tree/d5b89928e430e2d5b976f84b1ea66b4b901e6cda | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils
from matplotlib import cm as cm
from torch.nn.parallel import *
from torchvision.models import *
from torchvision.datasets import *
class Model(nn.Module):
def __init__(self, C, ks):
super().__init__()
self.weight = nn.... |
SpatialAttn | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class SpatialAttn(nn.Module):
"""Spatial Attention Layer"""
def __init__(self):
super(SpatialAttn, self).__init__()
def forward(self, x):
x = x.mean(1, keepdim=True)
h = x.size(2)
w = x.size(3)
x = x.view(x.size(0), -1)
z ... | 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... | YUE-FAN/Spatial-Attention | SpatialAttn | false | 6,011 | [
"MIT"
] | 1 | 71cf324f0fb0829355e5ca322058ebbb9d8be610 | https://github.com/YUE-FAN/Spatial-Attention/tree/71cf324f0fb0829355e5ca322058ebbb9d8be610 | import torch
from torch import nn
class Model(nn.Module):
"""Spatial Attention Layer"""
def __init__(self):
super().__init__()
def forward(self, x):
x = x.mean(1, keepdim=True)
h = x.size(2)
w = x.size(3)
x = x.view(x.size(0), -1)
z = x
for b in ra... |
fpn_module | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 fpn_module(nn.Module):
def __init__(self, numClass):
super(fpn_module, self).__init__()
self.toplayer = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0
)
self.smooth1_1 = nn.Conv2d(256, 256, kerne... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | ShenZheng2000/Syn2Real-Pytorch | fpn_module | false | 6,012 | [
"MIT"
] | 1 | 214c800914e2bcd57d4ca74a4c8476a11e1b5905 | https://github.com/ShenZheng2000/Syn2Real-Pytorch/tree/214c800914e2bcd57d4ca74a4c8476a11e1b5905 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, numClass):
super().__init__()
self.toplayer = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0
)
self.smooth1_1 = nn.Conv2d(256, 256, kernel_size=3, stride=1, p... |
RWKV_TimeMix | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 RWKV_TimeMix(nn.Module):
def __init__(self, config, layer_id):
super().__init__()
assert config.n_attn % config.n_head == 0
self.layer_id = layer_id
self.ctx_len = config.ctx_len
self.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.... | YUASDS/AI-Writer | RWKV_TimeMix | false | 6,013 | [
"BSD-3-Clause"
] | 1 | 6ec1e9548802ed5b5a2f1fd297595a52cb605266 | https://github.com/YUASDS/AI-Writer/tree/6ec1e9548802ed5b5a2f1fd297595a52cb605266 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config, layer_id):
super().__init__()
assert config.n_attn % config.n_head == 0
self.layer_id = layer_id
self.ctx_len = config.ctx_len
self.n_head = ... |
LearnablePositionalEncoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LearnablePositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=1024):
super(LearnablePositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
self.pe = nn.Parameter(torch.empty(max_len, 1, d_model))
... | 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... | YexuZhou/TimeSeriesClassification_Transformer | LearnablePositionalEncoding | false | 6,014 | [
"MIT"
] | 1 | c20e00cfac4cfdb849e57e14c184f7d424257409 | https://github.com/YexuZhou/TimeSeriesClassification_Transformer/tree/c20e00cfac4cfdb849e57e14c184f7d424257409 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=1024):
super().__init__()
self.dropout = nn.Dropout(p=dropout)
self.pe = nn.Parameter(torch.empty(max_len, 1, d_model))
nn.init.uniform_(self.pe, -0.02, 0.02)
def forwa... |
DW_PW_projection | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DW_PW_projection(nn.Module):
def __init__(self, c_in, c_out, kernel_size, bias=False, padding_mode=
'replicate'):
super(DW_PW_projection, self).__init__()
self.dw_conv1d = nn.Conv1d(in_channels=c_in, out_channels=c_in,
kernel_size=kerne... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | YexuZhou/TimeSeriesClassification_Transformer | DW_PW_projection | false | 6,015 | [
"MIT"
] | 1 | c20e00cfac4cfdb849e57e14c184f7d424257409 | https://github.com/YexuZhou/TimeSeriesClassification_Transformer/tree/c20e00cfac4cfdb849e57e14c184f7d424257409 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, c_in, c_out, kernel_size, bias=False, padding_mode=
'replicate'):
super().__init__()
self.dw_conv1d = nn.Conv1d(in_channels=c_in, out_channels=c_in,
kernel_size=kernel_size, padding=int(kernel_size /... |
ChannelSELayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.utils
from matplotlib import cm as cm
from torch.nn.parallel import *
from torchvision.models import *
from torchvision.datasets import *
class ChannelSELayer(nn.Module):
"""
Copied from https://github.com/ai-med/squeeze_and_excitation/bl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | XuelianCheng/ppuda | ChannelSELayer | false | 6,016 | [
"MIT"
] | 1 | d5b89928e430e2d5b976f84b1ea66b4b901e6cda | https://github.com/XuelianCheng/ppuda/tree/d5b89928e430e2d5b976f84b1ea66b4b901e6cda | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils
from matplotlib import cm as cm
from torch.nn.parallel import *
from torchvision.models import *
from torchvision.datasets import *
class Model(nn.Module):
"""
Copied from https://github.com/ai-med/squeeze_and_excitation/blob/master... |
RWKV_ChannelMix | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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
from torch.nn import functional as F
class RWKV_ChannelMix(nn.Module):
def __init__(self, config, layer_id):
super().__init__()
self.layer_id = layer_id
self.time_shift = nn.ZeroPad2d((0, 0, 1, -1))
h... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
im... | YUASDS/AI-Writer | RWKV_ChannelMix | false | 6,017 | [
"BSD-3-Clause"
] | 1 | 6ec1e9548802ed5b5a2f1fd297595a52cb605266 | https://github.com/YUASDS/AI-Writer/tree/6ec1e9548802ed5b5a2f1fd297595a52cb605266 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, config, layer_id):
super().__init__()
self.layer_id = layer_id
self.time_shift = nn.ZeroPad2d((0, 0, 1, -1))
hidden_sz =... |
TransformerLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 uuid
from torch import Tensor
import torch.nn as nn
from typing import Tuple
import torch.nn.functional as F
from typing import Optional
from typing import Dict
from torch.nn import Parameter
def gelu(x):
"""Implementation of the gelu activation function.
For information: Open... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | William-Zhanng/Protein_affinity | TransformerLayer | false | 6,018 | [
"MIT"
] | 1 | 8abd12073b182274bf464ff23fd3be406c4e39ac | https://github.com/William-Zhanng/Protein_affinity/tree/8abd12073b182274bf464ff23fd3be406c4e39ac | import math
import torch
import uuid
from torch import Tensor
import torch.nn as nn
from typing import Tuple
import torch.nn.functional as F
from typing import Optional
from typing import Dict
from torch.nn import Parameter
def gelu(x):
"""Implementation of the gelu activation function.
For information: Open... |
RecCrossEntropyLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class RecCrossEntropyLoss(nn.Module):
def __init__(self, rec_ratio):
super(RecCrossEntropyLoss, self).__init__()
self.rec_ratio = rec_ratio
def forward(self, rec, inputs, logits, targets):
rec_loss = nn.MSELoss()
cls_loss = nn.CrossEntropyLos... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | YuhengZhi/Attention-Net-with-MNIST- | RecCrossEntropyLoss | false | 6,019 | [
"MIT"
] | 1 | aa6805e4df777dee1056d5f4f4f9a9b1e4a5e4ff | https://github.com/YuhengZhi/Attention-Net-with-MNIST-/tree/aa6805e4df777dee1056d5f4f4f9a9b1e4a5e4ff | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, rec_ratio):
super().__init__()
self.rec_ratio = rec_ratio
def forward(self, rec, inputs, logits, targets):
rec_loss = nn.MSELoss()
cls_loss = nn.CrossEntropyLoss()
return cls_loss(logits, tar... |
BasicDeconv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BasicDeconv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
use_bn=False):
super(BasicDeconv, self).__init__()
self.use_bn = use_bn
self.tconv = nn.ConvTranspose2d(in_channels... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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_... | Yuuchuin/C3_V2 | BasicDeconv | false | 6,020 | [
"MIT"
] | 1 | 92a5edbc2c2b3452c5f57e74f928591192293e81 | https://github.com/Yuuchuin/C3_V2/tree/92a5edbc2c2b3452c5f57e74f928591192293e81 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
use_bn=False):
super().__init__()
self.use_bn = use_bn
self.tconv = nn.ConvTranspose2d(in_channels, out_channels,
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.