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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
DuRB_p | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.serialization
import torch
import torch.nn as nn
import torch.utils.data
class ConvLayer(nn.Module):
def __init__(self, in_dim, out_dim, kernel_size, stride, dilation=1):
super(ConvLayer, self).__init__()
self.dilation = dilation
if dilation ==... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | vis-opt-group/GTANet | DuRB_p | false | 4,500 | [
"MIT"
] | 0 | 269ff4418ee5f0267987e1fa4c69bda13e5cb00d | https://github.com/vis-opt-group/GTANet/tree/269ff4418ee5f0267987e1fa4c69bda13e5cb00d | import torch
import numpy as np
import torch.serialization
import torch
import torch.nn as nn
import torch.utils.data
class ConvLayer(nn.Module):
def __init__(self, in_dim, out_dim, kernel_size, stride, dilation=1):
super().__init__()
self.dilation = dilation
if dilation == 1:
... |
Accuracy | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
class Accuracy(Module):
"""
Class for calculating the accuracy for a given prediction and the labels
for comparison.
Expects the inputs to be from a range of 0 to 1 and sets a crossing threshold at 0.5
the labels are similarly round... | 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 import Module
from torch import Tensor
assert_size_stride = torch._C._dynam... | vixadd/sparseml | Accuracy | false | 4,501 | [
"Apache-2.0"
] | 0 | e2dcb66bad713542158dfe54cba113a0cc02ed39 | https://github.com/vixadd/sparseml/tree/e2dcb66bad713542158dfe54cba113a0cc02ed39 | from torch.nn import Module
import torch
from torch import Tensor
class Model(Module):
"""
Class for calculating the accuracy for a given prediction and the labels
for comparison.
Expects the inputs to be from a range of 0 to 1 and sets a crossing threshold at 0.5
the labels are similarly rounded.... |
PureUpsampling | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class PureUpsampling(nn.Module):
def __init__(self, scale=2, mode='bilinear'):
super(PureUpsampling, self).__init__()
assert isinstance(scale, int)
self.scale = scale
self.mode = mode
def forward(self, x):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | vlbthambawita/polyp-inpainting | PureUpsampling | false | 4,502 | [
"MIT"
] | 0 | f1d754f8ffb3f6d991206b2a661933ff32de0d7a | https://github.com/vlbthambawita/polyp-inpainting/tree/f1d754f8ffb3f6d991206b2a661933ff32de0d7a | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, scale=2, mode='bilinear'):
super().__init__()
assert isinstance(scale, int)
self.scale = scale
self.mode = mode
def forward(self, x):
h, w = x.size(2) * self.... |
RandomCrop | # 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 choose_rand_patches(x, patch_sz, dim):
assert dim == 2 or dim == 3
batch_sz = x.shape[0]
patches = x.unfold(dim, patch_sz, 1)
n_patches = patches.shape[2]
idx = torch.randint(0, n_patches, (batch_sz,))
if dim == 2:
patches = patches[torch.arange(ba... | import torch
from torch import device
import triton
import 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.... | vitskvara/shape-guided-anomaly-detection | RandomCrop | false | 4,503 | [
"MIT"
] | 0 | 6685b2e0b97968a6d0f478d2920486da107b277f | https://github.com/vitskvara/shape-guided-anomaly-detection/tree/6685b2e0b97968a6d0f478d2920486da107b277f | import torch
from torch import nn
def choose_rand_patches(x, patch_sz, dim):
assert dim == 2 or dim == 3
batch_sz = x.shape[0]
patches = x.unfold(dim, patch_sz, 1)
n_patches = patches.shape[2]
idx = torch.randint(0, n_patches, (batch_sz,))
if dim == 2:
patches = patches[torch.arange(ba... |
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
import torch.nn as nn
class TVLoss(nn.Module):
def __init__(self):
super(TVLoss, self).__init__()
def forward(self, x):
h_x, w_x = x.size()[2:]
h_tv = torch.abs(x[:, :, 1:, :] - x[:, :, :h_x - 1, :])
w_tv = torch.abs(x[:, :, :, 1:] - x[:, :, :, :w_x - 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.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | vlbthambawita/polyp-inpainting | TVLoss | false | 4,504 | [
"MIT"
] | 0 | f1d754f8ffb3f6d991206b2a661933ff32de0d7a | https://github.com/vlbthambawita/polyp-inpainting/tree/f1d754f8ffb3f6d991206b2a661933ff32de0d7a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
h_x, w_x = x.size()[2:]
h_tv = torch.abs(x[:, :, 1:, :] - x[:, :, :h_x - 1, :])
w_tv = torch.abs(x[:, :, :, 1:] - x[:, :, :, :w_x - 1])
loss = torch... |
conv_head_pooling | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class conv_head_pooling(nn.Module):
def __init__(self, in_feature, out_feature, stride, conv_type,
padding_mode='zeros', dilation=1):
super(conv_head_pooling, self).__init__()
if conv_type == 'depthwise':
_groups = in_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | tsubauaaa/d2go | conv_head_pooling | false | 4,505 | [
"Apache-2.0"
] | 0 | 9f746159ebf78ce79f644c405ca8695bc29d1075 | https://github.com/tsubauaaa/d2go/tree/9f746159ebf78ce79f644c405ca8695bc29d1075 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_feature, out_feature, stride, conv_type,
padding_mode='zeros', dilation=1):
super().__init__()
if conv_type == 'depthwise':
_groups = in_feature
else:
_... |
ShortcutLayer | # 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 ShortcutLayer(nn.Module):
def __init__(self, idx):
super(ShortcutLayer, self).__init__()
self.idx = idx
def forward(self, x, outputs):
return x + outputs[self.idx]
def get_inputs():
return [torch.rand([5, 4, 4, 4]), torch.rand([5, 4, 4, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | vrindaprabhu/solofy | ShortcutLayer | false | 4,506 | [
"MIT"
] | 0 | d5e26ff20d293c200485c70be6dcd6481afba396 | https://github.com/vrindaprabhu/solofy/tree/d5e26ff20d293c200485c70be6dcd6481afba396 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, idx):
super().__init__()
self.idx = idx
def forward(self, x, outputs):
return x + outputs[self.idx]
def get_inputs():
return [torch.rand([5, 4, 4, 4]), torch.rand([5, 4, 4, 4])]
def get_init_inputs(... |
CustomGroupNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CustomGroupNorm(torch.nn.Module):
"""
Custom Group Norm which adds n_groups=2 as default parameter
"""
def __init__(self, n_features, n_groups=2):
"""
Parameters
----------
n_features : int
number of input features
n_groups : int... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | vuamitom/shapenet | CustomGroupNorm | false | 4,507 | [
"BSD-2-Clause"
] | 0 | 9eb3dadc91801756cb3460707c37146c8176643e | https://github.com/vuamitom/shapenet/tree/9eb3dadc91801756cb3460707c37146c8176643e | import torch
class Model(torch.nn.Module):
"""
Custom Group Norm which adds n_groups=2 as default parameter
"""
def __init__(self, n_features, n_groups=2):
"""
Parameters
----------
n_features : int
number of input features
n_groups : int
... |
PairwiseNorm | # 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 PairwiseNorm(nn.Module):
def __init__(self, order=1, size_average=True):
super().__init__()
self.order = order
self.average = size_average
def forward(self, inp, target=None):
inp = inp.flatten(1)
assert len(inp) % 2 == 0
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_... | vzinche/inferno | PairwiseNorm | false | 4,508 | [
"Apache-2.0"
] | 0 | 91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | https://github.com/vzinche/inferno/tree/91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, order=1, size_average=True):
super().__init__()
self.order = order
self.average = size_average
def forward(self, inp, target=None):
inp = inp.flatten(1)
assert len(inp) % 2 == 0
sampl... |
Norm | # 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 Norm(nn.Module):
def __init__(self, order=1, size_average=True):
super().__init__()
self.order = order
self.average = size_average
def forward(self, inp, target=None):
if target is not None:
inp = inp - target
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 torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | vzinche/inferno | Norm | false | 4,509 | [
"Apache-2.0"
] | 0 | 91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | https://github.com/vzinche/inferno/tree/91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, order=1, size_average=True):
super().__init__()
self.order = order
self.average = size_average
def forward(self, inp, target=None):
if target is not None:
inp = inp - target
inp =... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class ContrastiveLoss(nn.Module):
def __init__(self, margin=1.0, reduction='mean'):
super().__init__()
self.m = margin
assert reduction in ['mean', 'sum', 'none']
self.reduction = reduction
def forward(self, dist, class_):
dist = dist... | 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... | vzinche/inferno | ContrastiveLoss | false | 4,510 | [
"Apache-2.0"
] | 0 | 91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | https://github.com/vzinche/inferno/tree/91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, margin=1.0, reduction='mean'):
super().__init__()
self.m = margin
assert reduction in ['mean', 'sum', 'none']
self.reduction = reduction
def forward(self, dist, class_):
dist = dist.transpose... |
WordPredictor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx.operators
class WordPredictor(nn.Module):
def __init__(self, encoder_output_dim, hidden_dim, output_dim):
super().__init__()
self.encoder_output_dim = encoder_output_dim
self.hidden_dim = hidden_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.... | vincentLiangBerkeley/translate | WordPredictor | false | 4,511 | [
"BSD-3-Clause"
] | 0 | 734ae1ad9dfb778935e4825b5ce2687e2df559ea | https://github.com/vincentLiangBerkeley/translate/tree/734ae1ad9dfb778935e4825b5ce2687e2df559ea | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx.operators
class Model(nn.Module):
def __init__(self, encoder_output_dim, hidden_dim, output_dim):
super().__init__()
self.encoder_output_dim = encoder_output_dim
self.hidden_dim = hidden_dim
self.... |
PairwiseCrossCorrelation | # 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 PairwiseCrossCorrelation(nn.Module):
def __init__(self, lambd=1):
super().__init__()
self.lambd = lambd
def off_diagonal(self, x):
n, m = x.shape
assert n == m
return x.flatten()[:-1].view(n - 1, n + 1)[:, 1:].flatten()
def... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | vzinche/inferno | PairwiseCrossCorrelation | false | 4,512 | [
"Apache-2.0"
] | 0 | 91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | https://github.com/vzinche/inferno/tree/91b22dfcd1b6a9ec415f0bbb6ae66caea42f4034 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, lambd=1):
super().__init__()
self.lambd = lambd
def off_diagonal(self, x):
n, m = x.shape
assert n == m
return x.flatten()[:-1].view(n - 1, n + 1)[:, 1:].flatten()
def forward(self, inp,... |
Linear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
from warnings import warn
from torch.nn import functional as F
from torch.nn import Linear as normal_linear
import torch.utils.data
from torchvision import transforms as transforms
class Linear(normal_linear):
def __init__(self, *args, **kwargs):
super(Linear, 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 warnings import warn
from torch.nn import Linear as normal_linear
import to... | wang93/pytorch-cifar10 | Linear | false | 4,513 | [
"Apache-2.0"
] | 0 | 07a54dd575aad9b011114352d08fdd9f61e360a1 | https://github.com/wang93/pytorch-cifar10/tree/07a54dd575aad9b011114352d08fdd9f61e360a1 | import torch
from torch import Tensor
from warnings import warn
from torch.nn import functional as F
from torch.nn import Linear as normal_linear
import torch.utils.data
from torchvision import transforms as transforms
class Model(normal_linear):
def __init__(self, *args, **kwargs):
super().__init__(*arg... |
Mnist_CNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.quantization
import torch.onnx
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Mnist_CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | voyageth/PyTorch-tutorials-kr | Mnist_CNN | false | 4,514 | [
"BSD-3-Clause"
] | 0 | 05d2dd5931abfca6ce1e0b297f4ceb7f4eae6239 | https://github.com/voyageth/PyTorch-tutorials-kr/tree/05d2dd5931abfca6ce1e0b297f4ceb7f4eae6239 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.quantization
import torch.onnx
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Con... |
FrequencyLoss | # 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 FrequencyLoss(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=0.001):
super(FrequencyLoss, self).__init__()
self.criterion = torch.nn.L1Loss()
def forward(self, x, y):
x_fft = torch.fft.rfft2(x, dim=(2, 3))
y_fft = 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... | vztu/DebandingNet | FrequencyLoss | false | 4,515 | [
"MIT"
] | 0 | 4af8e83ffbfc70dc220dd6fea2827fb75796f10c | https://github.com/vztu/DebandingNet/tree/4af8e83ffbfc70dc220dd6fea2827fb75796f10c | import torch
import torch.nn as nn
class Model(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=0.001):
super().__init__()
self.criterion = torch.nn.L1Loss()
def forward(self, x, y):
x_fft = torch.fft.rfft2(x, dim=(2, 3))
y_fft = torch.fft.rfft2(y, dim=(2, 3... |
FocalLossSigmoid | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from math import sqrt as sqrt
from itertools import product as product
class FocalLossSigmoid(nn.Module):
"""
sigmoid version focal loss
"""
def __init__(self, alpha=0.25, gamma=2, size_average=False):
super(FocalLossSigmoid, self).__init__()
self.al... | 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
... | wangbingok1118/SSD_Pytorch | FocalLossSigmoid | false | 4,516 | [
"MIT"
] | 0 | 8d3f924671cec367c3c420eba2f002cc5b5181bb | https://github.com/wangbingok1118/SSD_Pytorch/tree/8d3f924671cec367c3c420eba2f002cc5b5181bb | import torch
import torch.nn as nn
from math import sqrt as sqrt
from itertools import product as product
class Model(nn.Module):
"""
sigmoid version focal loss
"""
def __init__(self, alpha=0.25, gamma=2, size_average=False):
super().__init__()
self.alpha = alpha
self.gamma = ... |
MedianPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _pair
from torch.nn.modules.utils import _quadruple
class MedianPool2d(nn.Module):
""" Median pool (usable as median filter when stride=1) module.
Args:
kernel_size: size of pooling kernel, int ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
from torch.nn.modules.utils import _pair
from torch... | vztu/DebandingNet | MedianPool2d | false | 4,517 | [
"MIT"
] | 0 | 4af8e83ffbfc70dc220dd6fea2827fb75796f10c | https://github.com/vztu/DebandingNet/tree/4af8e83ffbfc70dc220dd6fea2827fb75796f10c | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _pair
from torch.nn.modules.utils import _quadruple
class Model(nn.Module):
""" Median pool (usable as median filter when stride=1) module.
Args:
kernel_size: size of pooling kernel, int or 2-tu... |
ParseL1loss | # 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 ParseL1loss(nn.Module):
def __init__(self):
super(ParseL1loss, self).__init__()
def forward(self, output, target, mask):
mask = (mask == 1).float()
loss = F.l1_loss(output * mask, target * mask, size_average=Fals... | 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... | weberhen/NonCuboidRoom | ParseL1loss | false | 4,518 | [
"MIT"
] | 0 | 871a77941697f1457cdae541b8ffcdce4f9134e3 | https://github.com/weberhen/NonCuboidRoom/tree/871a77941697f1457cdae541b8ffcdce4f9134e3 | 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, mask):
mask = (mask == 1).float()
loss = F.l1_loss(output * mask, target * mask, size_average=False)
loss = loss ... |
WassersteinLoss | # 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 WassersteinLoss(nn.Module):
"""For WGAN."""
def forward(self, real, fake):
return real.mean() - fake.mean()
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | wegroupwolves/fastai | WassersteinLoss | false | 4,519 | [
"Apache-2.0"
] | 0 | df40df403e05e132411f0f7abc7ec33c86e58bb9 | https://github.com/wegroupwolves/fastai/tree/df40df403e05e132411f0f7abc7ec33c86e58bb9 | import torch
from torch import nn
class Model(nn.Module):
"""For WGAN."""
def forward(self, real, fake):
return real.mean() - fake.mean()
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
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
import torch.nn as 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | wangminjie920705/Part-reid | SpatialAttn | false | 4,520 | [
"MIT"
] | 0 | 34a1e968a2eab692ba810332f309e82b441793f6 | https://github.com/wangminjie920705/Part-reid/tree/34a1e968a2eab692ba810332f309e82b441793f6 | import torch
import torch.nn as 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 r... |
FocalLoss | # 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 FocalLoss(nn.Module):
def __init__(self, focusing_param=2, balance_param=0.25):
super(FocalLoss, self).__init__()
self.focusing_param = focusing_param
self.balance_param = balance_param
def forward(self, output, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | wanghao15536870732/plants_disease_classify | FocalLoss | false | 4,521 | [
"Apache-2.0"
] | 0 | 6d0d1d39f0ec15fc2bd523142c5c403a1577da84 | https://github.com/wanghao15536870732/plants_disease_classify/tree/6d0d1d39f0ec15fc2bd523142c5c403a1577da84 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, focusing_param=2, balance_param=0.25):
super().__init__()
self.focusing_param = focusing_param
self.balance_param = balance_param
def forward(self, output, target):
cr... |
SigmoidRange | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
def sigmoid_range(x, low, high):
"""Sigmoid function with range `(low, high)`"""
return torch.sigmoid(x) * (high - low) + low
class SigmoidRange(nn.Module):
"""Sigmoid module with range `(low,x_max)`"""
def __init__(self, low, high):
super().__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | wegroupwolves/fastai | SigmoidRange | false | 4,522 | [
"Apache-2.0"
] | 0 | df40df403e05e132411f0f7abc7ec33c86e58bb9 | https://github.com/wegroupwolves/fastai/tree/df40df403e05e132411f0f7abc7ec33c86e58bb9 | import torch
from torch import nn
def sigmoid_range(x, low, high):
"""Sigmoid function with range `(low, high)`"""
return torch.sigmoid(x) * (high - low) + low
class Model(nn.Module):
"""Sigmoid module with range `(low,x_max)`"""
def __init__(self, low, high):
super().__init__()
sel... |
TemporalRelation | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 TemporalRelation(nn.Module):
def __init__(self, feat_dim, time_window=1):
super(TemporalRelation, self).__init__()
self.time_window = time_window
self.feat_dim = feat_dim
self.WT = nn.Linear(self.feat_dim, self.feat_dim, bias=False)
de... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | weiyi1991/UA_Concurrent | TemporalRelation | false | 4,523 | [
"MIT"
] | 0 | 11238c778c60095abf326800d6e6a13a643bf071 | https://github.com/weiyi1991/UA_Concurrent/tree/11238c778c60095abf326800d6e6a13a643bf071 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, feat_dim, time_window=1):
super().__init__()
self.time_window = time_window
self.feat_dim = feat_dim
self.WT = nn.Linear(self.feat_dim, self.feat_dim, bias=False)
def forward(self, feats):
r... |
LinearNormalGamma | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LinearNormalGamma(nn.Module):
def __init__(self, in_chanels, out_channels):
super().__init__()
self.linear = nn.Linear(in_chanels, out_channels * 4)
def evidence(self, x):
return torch.log(torch.exp(x) + 1)
def forward(self, x):
pr... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 im... | wanzysky/evidential-deep-learning | LinearNormalGamma | false | 4,524 | [
"Apache-2.0"
] | 0 | 71ebd59ab3a4b66c38d919e8aa9ad3711a416796 | https://github.com/wanzysky/evidential-deep-learning/tree/71ebd59ab3a4b66c38d919e8aa9ad3711a416796 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_chanels, out_channels):
super().__init__()
self.linear = nn.Linear(in_chanels, out_channels * 4)
def evidence(self, x):
return torch.log(torch.exp(x) + 1)
def forward(self, x):
pred = self.li... |
GMM_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 math
import torch
import torch.nn as nn
import torch.utils.data
class GMM_Module(nn.Module):
"""
GMM Module
"""
def __init__(self, out_channel_M, k):
super(GMM_Module, self).__init__()
self.conv1 = nn.Conv2d(int(out_channel_M), k * out_channel_M,
kernel_size=1)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
import torch.utils.data
assert_size_stride = t... | wemozj/Image-Compression-based-GMM-and-Attention-Module | GMM_Module | false | 4,525 | [
"Apache-2.0"
] | 0 | 93f804dbcea8ffc1621456f3d104d0342c75373b | https://github.com/wemozj/Image-Compression-based-GMM-and-Attention-Module/tree/93f804dbcea8ffc1621456f3d104d0342c75373b | import math
import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
GMM Module
"""
def __init__(self, out_channel_M, k):
super().__init__()
self.conv1 = nn.Conv2d(int(out_channel_M), k * out_channel_M,
kernel_size=1)
torch.nn.init.xav... |
MobileViTv2Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 init
class MobileViTv2Attention(nn.Module):
"""
Scaled dot-product attention
"""
def __init__(self, d_model):
"""
:param d_model: Output dimensionality of the model
:param d_k: Dimensionality of queries and keys
:p... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | weihaoxie/External-Attention-pytorch | MobileViTv2Attention | false | 4,526 | [
"MIT"
] | 0 | 9bec70f4ed8dd858c815e9bad240ab2f95a91a9f | https://github.com/weihaoxie/External-Attention-pytorch/tree/9bec70f4ed8dd858c815e9bad240ab2f95a91a9f | import torch
from torch import nn
from torch.nn import init
class Model(nn.Module):
"""
Scaled dot-product attention
"""
def __init__(self, d_model):
"""
:param d_model: Output dimensionality of the model
:param d_k: Dimensionality of queries and keys
:param d_v: Dimen... |
BitEstimator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Bitparm(nn.Module):
"""
save params
"""
def __init__(self, channel, final=False):
super(Bitparm, self).__init__()
self.final = final
self.h = nn.Parameter(torch.nn.init.normal_(tor... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn as nn
import torch.nn.functional as F
import t... | wemozj/Image-Compression-based-GMM-and-Attention-Module | BitEstimator | false | 4,527 | [
"Apache-2.0"
] | 0 | 93f804dbcea8ffc1621456f3d104d0342c75373b | https://github.com/wemozj/Image-Compression-based-GMM-and-Attention-Module/tree/93f804dbcea8ffc1621456f3d104d0342c75373b | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Bitparm(nn.Module):
"""
save params
"""
def __init__(self, channel, final=False):
super().__init__()
self.final = final
self.h = nn.Parameter(torch.nn.init.normal_(torch.empty(chan... |
Prototype | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.optim
import torch.utils.data
class Prototype(torch.nn.Module):
""""""
def __init__(self, prototype_num, latent_size) ->None:
super(Prototype, self).__init__()
self.latent_size = latent_size
self.prototype_num = prototype_num
self.prot... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wenqiangxie/Prototype-Net | Prototype | false | 4,528 | [
"MIT"
] | 0 | a5ddd9976b78828d87806f9451a5092de3ff5c69 | https://github.com/wenqiangxie/Prototype-Net/tree/a5ddd9976b78828d87806f9451a5092de3ff5c69 | import torch
import torch.nn
import torch.optim
import torch.utils.data
class Model(torch.nn.Module):
""""""
def __init__(self, prototype_num, latent_size) ->None:
super().__init__()
self.latent_size = latent_size
self.prototype_num = prototype_num
self.prototypes = torch.nn.P... |
Model | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(2, 2, 1)
def forward(self, x):
return self.conv(x)
def get_inputs():
return [torch.rand([4, 2, 64, 64])]
def get_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch._C
import torch.serialization
assert_size_str... | whu-pzhang/mmsegmentation | Model | false | 4,529 | [
"Apache-2.0"
] | 0 | 46326f63ce411c794d237e986dd3924590d0e75e | https://github.com/whu-pzhang/mmsegmentation/tree/46326f63ce411c794d237e986dd3924590d0e75e | import torch
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(2, 2, 1)
def forward(self, x):
return self.conv(x)
def get_inputs():
return [torch.rand([4, 2, 64, 64])]
def get_... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
from typing import Any
import torch.nn.functional as F
from torch import nn
def ifnone(a: 'Any', b: 'Any') ->Any:
"""`a` if `a` is not None, otherwise `b`."""
return b if a is None else a
class MultiHeadAttention(nn.Module):
"""MutiHeadAttention."""
def __init_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wegroupwolves/fastai | MultiHeadAttention | false | 4,530 | [
"Apache-2.0"
] | 0 | df40df403e05e132411f0f7abc7ec33c86e58bb9 | https://github.com/wegroupwolves/fastai/tree/df40df403e05e132411f0f7abc7ec33c86e58bb9 | import torch
from torch import Tensor
from typing import Any
import torch.nn.functional as F
from torch import nn
def ifnone(a: 'Any', b: 'Any') ->Any:
"""`a` if `a` is not None, otherwise `b`."""
return b if a is None else a
class Model(nn.Module):
"""MutiHeadAttention."""
def __init__(self, n_hea... |
GDN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.autograd import Function
import torch
import torch.nn as nn
import torch.utils.data
class LowerBound(Function):
@staticmethod
def forward(ctx, inputs, bound):
b = torch.ones_like(inputs) * bound
ctx.save_for_backward(inputs, b)
return torch.max(inputs, b)
@staticmethod... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wemozj/Image-Compression-based-GMM-and-Attention-Module | GDN | false | 4,531 | [
"Apache-2.0"
] | 0 | 93f804dbcea8ffc1621456f3d104d0342c75373b | https://github.com/wemozj/Image-Compression-based-GMM-and-Attention-Module/tree/93f804dbcea8ffc1621456f3d104d0342c75373b | from torch.autograd import Function
import torch
import torch.nn as nn
import torch.utils.data
class LowerBound(Function):
@staticmethod
def forward(ctx, inputs, bound):
b = torch.ones_like(inputs) * bound
ctx.save_for_backward(inputs, b)
return torch.max(inputs, b)
@staticmethod... |
UFOAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 init
def XNorm(x, gamma):
norm_tensor = torch.norm(x, 2, -1, True)
return x * gamma / norm_tensor
class UFOAttention(nn.Module):
"""
Scaled dot-product attention
"""
def __init__(self, d_model, d_k, d_v, h, dropout=0.1):
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | weihaoxie/External-Attention-pytorch | UFOAttention | false | 4,532 | [
"MIT"
] | 0 | 9bec70f4ed8dd858c815e9bad240ab2f95a91a9f | https://github.com/weihaoxie/External-Attention-pytorch/tree/9bec70f4ed8dd858c815e9bad240ab2f95a91a9f | import torch
from torch import nn
from torch.nn import init
def XNorm(x, gamma):
norm_tensor = torch.norm(x, 2, -1, True)
return x * gamma / norm_tensor
class Model(nn.Module):
"""
Scaled dot-product attention
"""
def __init__(self, d_model, d_k, d_v, h, dropout=0.1):
"""
:p... |
NaiveGate | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 NaiveGate(nn.Module):
"""
A naive gate implementation that defines the standard behavior of the gate
which determines which experts the tokens are going to.
Both the indecies and the score, or confidence, are output to the parent... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | whn09/fastmoe | NaiveGate | false | 4,533 | [
"Apache-2.0"
] | 0 | d0ffaffc6431abcd3ea6d0287dbf09f8cd727a0a | https://github.com/whn09/fastmoe/tree/d0ffaffc6431abcd3ea6d0287dbf09f8cd727a0a | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
A naive gate implementation that defines the standard behavior of the gate
which determines which experts the tokens are going to.
Both the indecies and the score, or confidence, are output to the parent
... |
ActorNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ActorNetwork(nn.Module):
def __init__(self, input_size, hidden_size, action_size):
super(ActorNetwork, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | whongyu/MA3C | ActorNetwork | false | 4,534 | [
"MIT"
] | 0 | d3b38cf42a909c0938624ba853119804efaf47eb | https://github.com/whongyu/MA3C/tree/d3b38cf42a909c0938624ba853119804efaf47eb | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size, hidden_size, action_size):
super().__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.fc3 = nn.Linear... |
ComplexBatchNormalize | # 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 cylindricalToPolarConversion(input1, input2=None):
if input2 is None:
"""input1 is tensor of [B,C,H,W,D,2] contains both real and imaginary channels
in the last dims"""
ndims = input1.ndimension()
real_input = input1.narrow(ndims - 1, 0, 1).s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.gu... | wizofe/urus-mri-recon | ComplexBatchNormalize | false | 4,535 | [
"MIT"
] | 0 | eab8e48dca31d2b936ce69ccc251ec5a4a10facc | https://github.com/wizofe/urus-mri-recon/tree/eab8e48dca31d2b936ce69ccc251ec5a4a10facc | import torch
import torch.nn as nn
def cylindricalToPolarConversion(input1, input2=None):
if input2 is None:
"""input1 is tensor of [B,C,H,W,D,2] contains both real and imaginary channels
in the last dims"""
ndims = input1.ndimension()
real_input = input1.narrow(ndims - 1, 0, 1).s... |
Channel_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
import torch.nn as nn
class Channel_mean(nn.Module):
def __init__(self) ->None:
super().__init__()
def forward(self, V):
"""
only V[0]
"""
return torch.sum(V[0], dim=0).squeeze()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inp... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | wk989898/ARES-implement | Channel_mean | false | 4,536 | [
"MIT"
] | 0 | b2411be01124feaccbc89d74f6025fbfa584bb3f | https://github.com/wk989898/ARES-implement/tree/b2411be01124feaccbc89d74f6025fbfa584bb3f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self) ->None:
super().__init__()
def forward(self, V):
"""
only V[0]
"""
return torch.sum(V[0], dim=0).squeeze()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
... |
MnistFeatureExtractor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MnistFeatureExtractor(nn.Module):
def __init__(self, activation=F.leaky_relu):
super(MnistFeatureExtractor, self).__init__()
self.conv1 = nn.Conv2d(3, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | wiatrak2/BScThesis | MnistFeatureExtractor | false | 4,537 | [
"MIT"
] | 0 | e5dd012fd9052e7088d8464b409dc055dbfcf840 | https://github.com/wiatrak2/BScThesis/tree/e5dd012fd9052e7088d8464b409dc055dbfcf840 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, activation=F.leaky_relu):
super().__init__()
self.conv1 = nn.Conv2d(3, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
... |
AspectMean | # 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 AspectMean(nn.Module):
def __init__(self, max_sen_len):
"""
:param max_sen_len: maximum length of sentence
"""
super(AspectMean, self).__init__()
self.max_sen_len = max_sen_len
def forward(self, aspect):
"""
: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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | williamSYSU/ABSA-william | AspectMean | false | 4,538 | [
"MIT"
] | 0 | 84ccd3dca00e84c7fefadb9f5835216b2c4fe1df | https://github.com/williamSYSU/ABSA-william/tree/84ccd3dca00e84c7fefadb9f5835216b2c4fe1df | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, max_sen_len):
"""
:param max_sen_len: maximum length of sentence
"""
super().__init__()
self.max_sen_len = max_sen_len
def forward(self, aspect):
"""
:param aspect: size: [b... |
ComplexConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ComplexConv(nn.Module):
def __init__(self, rank, in_channels, out_channels, kernel_size, stride
=1, padding=0, output_padding=0, dilation=1, groups=1, bias=True,
normalize_weight=False, epsilon=1e-07, conv_transposed=False):
super(ComplexConv, 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... | wizofe/urus-mri-recon | ComplexConv | false | 4,539 | [
"MIT"
] | 0 | eab8e48dca31d2b936ce69ccc251ec5a4a10facc | https://github.com/wizofe/urus-mri-recon/tree/eab8e48dca31d2b936ce69ccc251ec5a4a10facc | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, rank, in_channels, out_channels, kernel_size, stride
=1, padding=0, output_padding=0, dilation=1, groups=1, bias=True,
normalize_weight=False, epsilon=1e-07, conv_transposed=False):
super().__init__()
se... |
TotalVariations | # 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 TotalVariations(_Loss):
def forward(self, img1):
return torch.sum(torch.abs(img1[:, :, :-1] - img1[:, :, 1:])
) + torch.sum(torch.abs(img1[:, :-1, :] - img1[:, 1:, :]))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def g... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch.nn.modules.loss import _Loss
assert_size_stride = torch._C._dy... | wizofe/urus-mri-recon | TotalVariations | false | 4,540 | [
"MIT"
] | 0 | eab8e48dca31d2b936ce69ccc251ec5a4a10facc | https://github.com/wizofe/urus-mri-recon/tree/eab8e48dca31d2b936ce69ccc251ec5a4a10facc | import torch
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def forward(self, img1):
return torch.sum(torch.abs(img1[:, :, :-1] - img1[:, :, 1:])
) + torch.sum(torch.abs(img1[:, :-1, :] - img1[:, 1:, :]))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_in... |
CenteredL1Loss | # 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.functional import l1_loss
class CenteredL1Loss(torch.nn.Module):
def __init__(self, margin):
super(CenteredL1Loss, self).__init__()
self.m = margin
def forward(self, true, preds):
return l1_loss(preds[:, :, self.m:-self.m, self.m:-self.m], true[:,
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | wsdea/EfficientSR | CenteredL1Loss | false | 4,541 | [
"MIT"
] | 0 | 077dea18c90e0d5bed722c609a776033c09f80e6 | https://github.com/wsdea/EfficientSR/tree/077dea18c90e0d5bed722c609a776033c09f80e6 | import torch
from torch.nn.functional import l1_loss
class Model(torch.nn.Module):
def __init__(self, margin):
super().__init__()
self.m = margin
def forward(self, true, preds):
return l1_loss(preds[:, :, self.m:-self.m, self.m:-self.m], true[:,
:, self.m:-self.m, self.m:... |
ZReLU | # 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
def cylindricalToPolarConversion(input1, input2=None):
if input2 is None:
"""input1 is tensor of [B,C,H,W,D,2] contains both real and imaginary channels
in the last dims"""
ndims = input1.ndimension()
real_input = input1.narrow... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | wizofe/urus-mri-recon | ZReLU | false | 4,542 | [
"MIT"
] | 0 | eab8e48dca31d2b936ce69ccc251ec5a4a10facc | https://github.com/wizofe/urus-mri-recon/tree/eab8e48dca31d2b936ce69ccc251ec5a4a10facc | import torch
import numpy as np
import torch.nn as nn
def cylindricalToPolarConversion(input1, input2=None):
if input2 is None:
"""input1 is tensor of [B,C,H,W,D,2] contains both real and imaginary channels
in the last dims"""
ndims = input1.ndimension()
real_input = input1.narrow... |
ModReLU | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
def magnitude(input):
if input.ndimension() == 4:
return (input[:, :, :, 0] ** 2 + input[:, :, :, 1] ** 2) ** 0.5
elif input.ndimension() == 5:
return (input[:, :, :, :, 0] ** 2 + input[:, :, :, :, 1] ** 2) ** 0.5
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
from torch.nn.parameter import Parameter
assert_size_stri... | wizofe/urus-mri-recon | ModReLU | false | 4,543 | [
"MIT"
] | 0 | eab8e48dca31d2b936ce69ccc251ec5a4a10facc | https://github.com/wizofe/urus-mri-recon/tree/eab8e48dca31d2b936ce69ccc251ec5a4a10facc | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
def magnitude(input):
if input.ndimension() == 4:
return (input[:, :, :, 0] ** 2 + input[:, :, :, 1] ** 2) ** 0.5
elif input.ndimension() == 5:
return (input[:, :, :, :, 0] ** 2 + input[:, :, :, :, 1] ** 2) ** 0.5
... |
PointLoss | # 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 array2samples_distance(array1, array2):
"""
arguments:
array1: the array, size: (num_point, num_feature)
array2: the samples, size: (num_point, num_feature)
returns:
distances: each entry is the distance from a sample to array1
"""
n... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | wendydidi/MISO-PCN | PointLoss | false | 4,544 | [
"MIT"
] | 0 | fdb8ed80d16ed5d019c3ca85e26ce23884067c0d | https://github.com/wendydidi/MISO-PCN/tree/fdb8ed80d16ed5d019c3ca85e26ce23884067c0d | import torch
import torch.nn as nn
def array2samples_distance(array1, array2):
"""
arguments:
array1: the array, size: (num_point, num_feature)
array2: the samples, size: (num_point, num_feature)
returns:
distances: each entry is the distance from a sample to array1
"""
n... |
Dueling_DQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class Dueling_DQN(nn.Module):
def __init__(self, args):
super().__init__()
self.state_space = args.state_space
self.fc1 = nn.Linear(self.state_space, args.hidden_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | wotmd5731/pseudo_random_gen | Dueling_DQN | false | 4,545 | [
"MIT"
] | 0 | f79810cd5ac79afe0a73dee73aa21bd8c01aeb9b | https://github.com/wotmd5731/pseudo_random_gen/tree/f79810cd5ac79afe0a73dee73aa21bd8c01aeb9b | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, args):
super().__init__()
self.state_space = args.state_space
self.fc1 = nn.Linear(self.state_space, args.hidden_size)
self.a... |
DQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class DQN(nn.Module):
def __init__(self, args):
super().__init__()
self.state_space = args.state_space
self.fc1 = nn.Linear(self.state_space, args.hidden_size)
self.fc2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | wotmd5731/pseudo_random_gen | DQN | false | 4,547 | [
"MIT"
] | 0 | f79810cd5ac79afe0a73dee73aa21bd8c01aeb9b | https://github.com/wotmd5731/pseudo_random_gen/tree/f79810cd5ac79afe0a73dee73aa21bd8c01aeb9b | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, args):
super().__init__()
self.state_space = args.state_space
self.fc1 = nn.Linear(self.state_space, args.hidden_size)
self.f... |
NearestNeighbourx4 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 NearestNeighbourx4(nn.Module):
def __init__(self, nf, bias, custom_init=False):
super(NearestNeighbourx4, self).__init__()
self.conv0 = nn.Conv2d(nf, nf, 3, 1, 1, bias=bias)
self.conv1 = nn.Conv2d(nf, nf, 3, 1, 1, bi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | wsdea/EfficientSR | NearestNeighbourx4 | false | 4,548 | [
"MIT"
] | 0 | 077dea18c90e0d5bed722c609a776033c09f80e6 | https://github.com/wsdea/EfficientSR/tree/077dea18c90e0d5bed722c609a776033c09f80e6 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, nf, bias, custom_init=False):
super().__init__()
self.conv0 = nn.Conv2d(nf, nf, 3, 1, 1, bias=bias)
self.conv1 = nn.Conv2d(nf, nf, 3, 1, 1, bias=bias)
self.conv2 = nn.Conv... |
Synthesis_prior_net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.utils.data
class Synthesis_prior_net(nn.Module):
"""
Decode synthesis prior
"""
def __init__(self, out_channel_N=192, out_channel_M=320):
super(Synthesis_prior_net, self).__init__()
self.deconv1 = nn.ConvTranspose2d(out_chann... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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
import torch.utils.data
assert_size_stride = t... | wemozj/Image-Compression-based-GMM-and-Attention-Module | Synthesis_prior_net | false | 4,549 | [
"Apache-2.0"
] | 0 | 93f804dbcea8ffc1621456f3d104d0342c75373b | https://github.com/wemozj/Image-Compression-based-GMM-and-Attention-Module/tree/93f804dbcea8ffc1621456f3d104d0342c75373b | import math
import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
Decode synthesis prior
"""
def __init__(self, out_channel_N=192, out_channel_M=320):
super().__init__()
self.deconv1 = nn.ConvTranspose2d(out_channel_N, out_channel_N, 5,
str... |
baseline_upscale | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def initialize_weights(net_l, scale=1):
if not isinstance(net_l, list):
net_l = [net_l]
for net in net_l:
for m in net.modules():
if isinstance(m, torch.nn.Conv2d):
init.kaiming_normal_(m.weight, a=0, m... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.init as init
assert_size_stride = torch._C... | wsdea/EfficientSR | baseline_upscale | false | 4,550 | [
"MIT"
] | 0 | 077dea18c90e0d5bed722c609a776033c09f80e6 | https://github.com/wsdea/EfficientSR/tree/077dea18c90e0d5bed722c609a776033c09f80e6 | import torch
import torch.nn as nn
import torch.nn.init as init
def initialize_weights(net_l, scale=1):
if not isinstance(net_l, list):
net_l = [net_l]
for net in net_l:
for m in net.modules():
if isinstance(m, torch.nn.Conv2d):
init.kaiming_normal_(m.weight, a=0, m... |
QueryEncoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 QueryEncoding(nn.Module):
def __init__(self, d_model):
super(QueryEncoding, self).__init__()
self.pe = nn.Embedding(2, d_model)
def forward(self, x):
B, N, L, _K = x.shape
idx = torch.ones((B, N, L), device=x.device).long()
idx... | 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... | wukevin/RoseTTAFold | QueryEncoding | false | 4,551 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d_model):
super().__init__()
self.pe = nn.Embedding(2, d_model)
def forward(self, x):
B, N, L, _K = x.shape
idx = torch.ones((B, N, L), device=x.device).long()
idx[:, 0, :] = 0
x = x... |
PCN1 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class PCN1(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=2, dilation=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2)
self.conv3 = nn.Conv2d(32, 64... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wkdhkr/pytorch-PCN | PCN1 | false | 4,552 | [
"BSD-2-Clause"
] | 0 | 4686c8fcda0b4fe7ecd7488f5554e19e8f6a8f68 | https://github.com/wkdhkr/pytorch-PCN/tree/4686c8fcda0b4fe7ecd7488f5554e19e8f6a8f68 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=2, dilation=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2)
self.conv3 = nn.Conv2d(32, 6... |
LinearNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LinearNet(nn.Module):
def __init__(self, n_feature, n_output):
super(LinearNet, self).__init__()
self.fc1 = nn.Linear(n_feature, 256)
self.fc2 = nn.Linear(256, 512)
self.fc3 = nn.Linear(512, 1024)
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | wslerry/regresstorch | LinearNet | false | 4,553 | [
"MIT"
] | 0 | b2e3507d8ed794e5d1d75ebfe910f74bbcb9a06b | https://github.com/wslerry/regresstorch/tree/b2e3507d8ed794e5d1d75ebfe910f74bbcb9a06b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, n_feature, n_output):
super().__init__()
self.fc1 = nn.Linear(n_feature, 256)
self.fc2 = nn.Linear(256, 512)
self.fc3 = nn.Linear(512, 1024)
self.fc4 = nn.Linear(1... |
ResidualDenseBlock_3C | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def initialize_weights(net_l, scale=1):
if not isinstance(net_l, list):
net_l = [net_l]
for net in net_l:
for m in net.modules():
if isinstance(m, torch.nn.Conv2d):
init.kaiming_normal_(m.weight, a=0, m... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.init as init
assert_size_stride = torch._C... | wsdea/EfficientSR | ResidualDenseBlock_3C | false | 4,554 | [
"MIT"
] | 0 | 077dea18c90e0d5bed722c609a776033c09f80e6 | https://github.com/wsdea/EfficientSR/tree/077dea18c90e0d5bed722c609a776033c09f80e6 | import torch
import torch.nn as nn
import torch.nn.init as init
def initialize_weights(net_l, scale=1):
if not isinstance(net_l, list):
net_l = [net_l]
for net in net_l:
for m in net.modules():
if isinstance(m, torch.nn.Conv2d):
init.kaiming_normal_(m.weight, a=0, m... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super(LayerNorm, self).__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
def forward(self, x):
mea... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | wukevin/RoseTTAFold | LayerNorm | false | 4,555 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d_model, eps=1e-05):
super().__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
def forward(self, x):
mean = x.mean(-1, keep... |
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
class ScaledDotProductAttention(nn.Module):
def __init__(self, temperature, dropout=0.1):
super(ScaledDotProductAttention, self).__init__()
self.temperature = temperature
self.dropout = nn.Dropout(p=dropout)
def forward(self, q, k, v, mask=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.... | wu0004in/vedastr | MultiHeadAttention | false | 4,557 | [
"Apache-2.0"
] | 0 | 83511a408b68c264561a30daff5154cd0148bebd | https://github.com/wu0004in/vedastr/tree/83511a408b68c264561a30daff5154cd0148bebd | import torch
import torch.nn as nn
class ScaledDotProductAttention(nn.Module):
def __init__(self, temperature, dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(p=dropout)
def forward(self, q, k, v, mask=None):
attn = torch.matmul(q, k.... |
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... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class FC(nn.Module):
def __init__(self, in_size, out_size, dropout_rate=0.0, use_relu=True):
super(FC, self).__init__()
self.dropout_r = dropout_rate
self.use_relu = use_relu
self.linear = nn.Linear(i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Originofamonia/mcan-vqa | FFN | false | 4,558 | [
"Apache-2.0"
] | 0 | e7e9fdc654d72dbbcbc03e43ae8a59c16b6d10d1 | https://github.com/Originofamonia/mcan-vqa/tree/e7e9fdc654d72dbbcbc03e43ae8a59c16b6d10d1 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class FC(nn.Module):
def __init__(self, in_size, out_size, dropout_rate=0.0, use_relu=True):
super().__init__()
self.dropout_r = dropout_rate
self.use_relu = use_relu
self.linear = nn.Linear(in_size, ... |
CoevolExtractor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super(LayerNorm, self).__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
def forward(self, x):
mea... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | wukevin/RoseTTAFold | CoevolExtractor | false | 4,559 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import torch
import torch.nn as nn
class LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super().__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
def forward(self, x):
mean = x.mean(-1, ... |
DirectMultiheadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DirectMultiheadAttention(nn.Module):
def __init__(self, d_in, d_out, heads, dropout=0.1):
super(DirectMultiheadAttention, self).__init__()
self.heads = heads
self.proj_pair = nn.Linear(d_in, heads)
self.drop ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wukevin/RoseTTAFold | DirectMultiheadAttention | false | 4,560 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_in, d_out, heads, dropout=0.1):
super().__init__()
self.heads = heads
self.proj_pair = nn.Linear(d_in, heads)
self.drop = nn.Dropout(dropout, inplace=True)
self.... |
PVABlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def constant_init(module, val, bias=0):
nn.init.constant_(module.weight, val)
if hasattr(module, 'bias') and module.bias is not None:
nn.init.constant_(module.bias, bias)
def kaiming_init(module, a=0, is_rnn=False, mode='fan_in', nonlinearity=
'leaky_relu', bia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wu0004in/vedastr | PVABlock | false | 4,561 | [
"Apache-2.0"
] | 0 | 83511a408b68c264561a30daff5154cd0148bebd | https://github.com/wu0004in/vedastr/tree/83511a408b68c264561a30daff5154cd0148bebd | import torch
import torch.nn as nn
def constant_init(module, val, bias=0):
nn.init.constant_(module.weight, val)
if hasattr(module, 'bias') and module.bias is not None:
nn.init.constant_(module.bias, bias)
def kaiming_init(module, a=0, is_rnn=False, mode='fan_in', nonlinearity=
'leaky_relu', bia... |
MultiheadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class MultiheadAttention(nn.Module):
def __init__(self, d_model, heads, k_dim=None, v_dim=None, dropout=0.1):
super(MultiheadAttention, self).__init__()
if k_dim is None:
k_dim = d_model
if v_dim is... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wukevin/RoseTTAFold | MultiheadAttention | false | 4,562 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_model, heads, k_dim=None, v_dim=None, dropout=0.1):
super().__init__()
if k_dim is None:
k_dim = d_model
if v_dim is None:
v_dim = d_model
... |
MaskedDirectMultiheadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class MaskedDirectMultiheadAttention(nn.Module):
def __init__(self, d_in, d_out, heads, d_k=32, dropout=0.1):
super(MaskedDirectMultiheadAttention, self).__init__()
self.heads = heads
self.scaling = 1 / math.sq... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wukevin/RoseTTAFold | MaskedDirectMultiheadAttention | false | 4,563 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_in, d_out, heads, d_k=32, dropout=0.1):
super().__init__()
self.heads = heads
self.scaling = 1 / math.sqrt(d_k)
self.to_query = nn.Linear(d_in, heads * d_k)
... |
SequenceWeight | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class SequenceWeight(nn.Module):
def __init__(self, d_model, heads, dropout=0.1):
super(SequenceWeight, self).__init__()
self.heads = heads
self.d_model = d_model
self.d_k = d_model // heads
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wukevin/RoseTTAFold | SequenceWeight | false | 4,564 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_model, heads, dropout=0.1):
super().__init__()
self.heads = heads
self.d_model = d_model
self.d_k = d_model // heads
self.scale = 1.0 / math.sqrt(sel... |
MFM2_1 | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class MFM2_1(torch.nn.Module):
"""Max-Feature-Map (MFM) 2/1 operation. """
def forward(self, input):
input = input.reshape((input.shape[0], 2, -1, *input.shape[2:]))
output = input.max(dim=1)[0]
return output
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | x6rulin/TP-GAN | MFM2_1 | false | 4,565 | [
"MIT"
] | 0 | 1716cf06aaff8a6a2cee2548ec662dcdd68c0449 | https://github.com/x6rulin/TP-GAN/tree/1716cf06aaff8a6a2cee2548ec662dcdd68c0449 | import torch
class Model(torch.nn.Module):
"""Max-Feature-Map (MFM) 2/1 operation. """
def forward(self, input):
input = input.reshape((input.shape[0], 2, -1, *input.shape[2:]))
output = input.max(dim=1)[0]
return output
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def ... |
Spatial_Attention_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 math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Spatial_Attention_layer(nn.Module):
"""
compute spatial attention scores
"""
def __init__(self, dropout=0.0):
super(Spatial_Attention_layer, self).__init__()
self.dropout = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wxh453751461/Gformer | Spatial_Attention_layer | false | 4,566 | [
"Apache-2.0"
] | 0 | a033eb6fce59ceacc61a76430010805023ac230f | https://github.com/wxh453751461/Gformer/tree/a033eb6fce59ceacc61a76430010805023ac230f | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
"""
compute spatial attention scores
"""
def __init__(self, dropout=0.0):
super().__init__()
self.dropout = nn.Dropout(p=dropout)
def forward(self, x):
... |
SubpixelConvolutionLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class SubpixelConvolutionLayer(nn.Module):
def __init__(self, channels: 'int') ->None:
"""
Args:
channels (int): Number of channels in the input image.
"""
super(SubpixelConvolutionLayer, self).__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | wuyushuwys/SRGAN-PyTorch | SubpixelConvolutionLayer | false | 4,567 | [
"Apache-2.0"
] | 0 | 3a4aaaf7b55692264fca8451e4401466fcb1f39a | https://github.com/wuyushuwys/SRGAN-PyTorch/tree/3a4aaaf7b55692264fca8451e4401466fcb1f39a | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, channels: 'int') ->None:
"""
Args:
channels (int): Number of channels in the input image.
"""
super().__init__()
self.conv = nn.Conv2d(channels, channels * 4, ... |
Synthesis_net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.autograd import Function
import math
import torch
import torch.nn as nn
import torch.utils.data
class LowerBound(Function):
@staticmethod
def forward(ctx, inputs, bound):
b = torch.ones_like(inputs) * bound
ctx.save_for_backward(inputs, b)
return torch.max(inputs, b)
@... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wemozj/Image-Compression-based-GMM-and-Attention-Module | Synthesis_net | false | 4,568 | [
"Apache-2.0"
] | 0 | 93f804dbcea8ffc1621456f3d104d0342c75373b | https://github.com/wemozj/Image-Compression-based-GMM-and-Attention-Module/tree/93f804dbcea8ffc1621456f3d104d0342c75373b | from torch.autograd import Function
import math
import torch
import torch.nn as nn
import torch.utils.data
class LowerBound(Function):
@staticmethod
def forward(ctx, inputs, bound):
b = torch.ones_like(inputs) * bound
ctx.save_for_backward(inputs, b)
return torch.max(inputs, b)
@... |
BertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class BertSelfAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.num_attention_heads = config.num_attention_heads
self.attention_head_size = int(config.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 import triton_helpers
from torch._inductor.runtime.... | SamarthMM/cs769-assignments | BertSelfAttention | false | 4,569 | [
"MIT"
] | 0 | bac2ad57c50043608276df8e0f21181ef62696c7 | https://github.com/SamarthMM/cs769-assignments/tree/bac2ad57c50043608276df8e0f21181ef62696c7 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.num_attention_heads = config.num_attention_heads
self.attention_head_size = int(config.hidden_size /... |
SFU | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
class SFU(torch.nn.Module):
"""
only two input, one input vector and one fusion vector
Args:
- input_size:
- fusions_size:
Inputs:
- input: (seq_len, batch, input_size)
- fusions: (seq_len, batch, fus... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | xdong73S/Match_LSTM_v2.0 | SFU | false | 4,570 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
import torch.nn.functional as F
class Model(torch.nn.Module):
"""
only two input, one input vector and one fusion vector
Args:
- input_size:
- fusions_size:
Inputs:
- input: (seq_len, batch, input_size)
- fusions: (seq_len, batch, f... |
SpecialEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SpecialEncoderLayer(nn.Module):
def __init__(self, heads, d_in, d_out, d_ff, p_drop=0.1):
super(SpecialEncoderLayer, self).__init__()
self.heads = heads
self.norm = nn.LayerNorm(d_in)
self.proj_pair_1 = nn.Li... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wukevin/RoseTTAFold | SpecialEncoderLayer | false | 4,571 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, heads, d_in, d_out, d_ff, p_drop=0.1):
super().__init__()
self.heads = heads
self.norm = nn.LayerNorm(d_in)
self.proj_pair_1 = nn.Linear(d_in, heads // 2)
self.pro... |
SeqToSeqAtten | # 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
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim=True)[0])
if m is not 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.... | xdong73S/Match_LSTM_v2.0 | SeqToSeqAtten | false | 4,572 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim=True)[0])
if m is not None:... |
EncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from functools import partial
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def orthogonal_matrix_chunk(cols, qr_uniform_q=False, device=None):
unstructured_block = torch.rand... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wukevin/RoseTTAFold | EncoderLayer | false | 4,573 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from functools import partial
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def orthogonal_matrix_chunk(cols, qr_uniform_q=False, device=None):
unstructured_block = torch.rand... |
Analysis_prior_net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.utils.data
class Analysis_prior_net(nn.Module):
"""
Analysis prior net
"""
def __init__(self, out_channel_N=192, out_channel_M=320):
super(Analysis_prior_net, self).__init__()
self.conv1 = nn.Conv2d(out_channel_M, out_channel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import math
i... | wemozj/Image-Compression-based-GMM-and-Attention-Module | Analysis_prior_net | false | 4,574 | [
"Apache-2.0"
] | 0 | 93f804dbcea8ffc1621456f3d104d0342c75373b | https://github.com/wemozj/Image-Compression-based-GMM-and-Attention-Module/tree/93f804dbcea8ffc1621456f3d104d0342c75373b | import math
import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
Analysis prior net
"""
def __init__(self, out_channel_N=192, out_channel_M=320):
super().__init__()
self.conv1 = nn.Conv2d(out_channel_M, out_channel_N, 3, stride=1,
padding=... |
MatchRNNAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | xdong73S/Match_LSTM_v2.0 | MatchRNNAttention | false | 4,575 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... |
AttentionPooling | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | xdong73S/Match_LSTM_v2.0 | AttentionPooling | false | 4,576 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... |
_MixPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class _MixPool2d(torch.nn.Module):
def __init__(self, kernel_size, stride, padding=0, ceil_mode=False):
super(_MixPool2d, self).__init__()
self.max_pool = torch.nn.MaxPool2d(kernel_size, stride, padding,
ceil_mode=ceil_mode)
self.avg_pool = torch.nn.AvgPool2d(kern... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | x6rulin/TP-GAN | _MixPool2d | false | 4,577 | [
"MIT"
] | 0 | 1716cf06aaff8a6a2cee2548ec662dcdd68c0449 | https://github.com/x6rulin/TP-GAN/tree/1716cf06aaff8a6a2cee2548ec662dcdd68c0449 | import torch
class Model(torch.nn.Module):
def __init__(self, kernel_size, stride, padding=0, ceil_mode=False):
super().__init__()
self.max_pool = torch.nn.MaxPool2d(kernel_size, stride, padding,
ceil_mode=ceil_mode)
self.avg_pool = torch.nn.AvgPool2d(kernel_size, stride, padd... |
SelfGated | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
class SelfGated(torch.nn.Module):
"""
Self-Gated layer. math: \\sigmoid(W*x) * x
"""
def __init__(self, input_size):
super(SelfGated, self).__init__()
self.linear_g = torch.nn.Linear(input_size, input_size)
def ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | xdong73S/Match_LSTM_v2.0 | SelfGated | false | 4,578 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
import torch.nn.functional as F
class Model(torch.nn.Module):
"""
Self-Gated layer. math: \\sigmoid(W*x) * x
"""
def __init__(self, input_size):
super().__init__()
self.linear_g = torch.nn.Linear(input_size, input_size)
def forward(self, x):
... |
RingLoss | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 warnings
import torch.nn as nn
from torchvision.transforms import *
class RingLoss(nn.Module):
"""Ring loss.
Reference:
Zheng et al. Ring loss: Convex Feature Normalization for Face Recognition. CVPR 2018.
"""
def __init__(self):
super(RingLoss, self).__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import warnings
import torch.nn as nn
from torchvision.transforms import *
asse... | xijiali/ABD_Net | RingLoss | false | 4,579 | [
"MIT"
] | 0 | 8d2d9b316b7c181ce441ceb4b1c62fb9a6d53153 | https://github.com/xijiali/ABD_Net/tree/8d2d9b316b7c181ce441ceb4b1c62fb9a6d53153 | import torch
import warnings
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
"""Ring loss.
Reference:
Zheng et al. Ring loss: Convex Feature Normalization for Face Recognition. CVPR 2018.
"""
def __init__(self):
super().__init__()
warnings.w... |
AxialEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from functools import partial
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def orthogonal_matrix_chunk(cols, qr_uniform_q=False, device=None):
unstructured_block = torch.rand... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wukevin/RoseTTAFold | AxialEncoderLayer | false | 4,580 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from functools import partial
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def orthogonal_matrix_chunk(cols, qr_uniform_q=False, device=None):
unstructured_block = torch.rand... |
PointerAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | xdong73S/Match_LSTM_v2.0 | PointerAttention | false | 4,581 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... |
Enrichment | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Enrichment(nn.Module):
def __init__(self, c_in, rate=2):
super(Enrichment, self).__init__()
self.rate = rate
self.relu = nn.ReLU(inplace=True)
self.conv = nn.Conv2d(c_in, 32, 3, stride=1, padding=1)
dilation = self.rate * 1 if self.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | xavysp/TIN_xsp | Enrichment | false | 4,582 | [
"MIT"
] | 0 | 9f68e03923f637f4d4ef885694dfc3aaaaad6cea | https://github.com/xavysp/TIN_xsp/tree/9f68e03923f637f4d4ef885694dfc3aaaaad6cea | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, c_in, rate=2):
super().__init__()
self.rate = rate
self.relu = nn.ReLU(inplace=True)
self.conv = nn.Conv2d(c_in, 32, 3, stride=1, padding=1)
dilation = self.rate * 1 if self.rate >= 1 else 1
... |
PredLayer | # 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 module_test_print(var_input, var_inmed, var_ouput):
for var in (var_input, var_inmed, var_ouput):
None
for key, value in var.items():
None
None
class PredLayer(nn.Module):
def __init__(self, module_test=False):
super(Pre... | 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... | xlx0010/HGNN | PredLayer | false | 4,583 | [
"MIT"
] | 0 | 219352405db021c1f435f3aa55961adcf2a6df19 | https://github.com/xlx0010/HGNN/tree/219352405db021c1f435f3aa55961adcf2a6df19 | import torch
import torch.nn as nn
def module_test_print(var_input, var_inmed, var_ouput):
for var in (var_input, var_inmed, var_ouput):
None
for key, value in var.items():
None
None
class Model(nn.Module):
def __init__(self, module_test=False):
super().__ini... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class FocalLoss(nn.Module):
def __init__(self, gamma):
super().__init__()
self.gamma = gamma
def forward(self, input, target):
if not target.size() == input.size():
raise ValueError(
'Targe... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | xkp793003821/kaggle-tgs-salt | FocalLoss | false | 4,584 | [
"MIT"
] | 0 | 4acd7f8b6aff914e2c8558677d6dac8b5ddc1f30 | https://github.com/xkp793003821/kaggle-tgs-salt/tree/4acd7f8b6aff914e2c8558677d6dac8b5ddc1f30 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, gamma):
super().__init__()
self.gamma = gamma
def forward(self, input, target):
if not target.size() == input.size():
raise ValueError(
'Target si... |
MyGlobalAvgPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.parallel
import torch.optim
class MyGlobalAvgPool2d(nn.Module):
def __init__(self, keep_dim=True):
super(MyGlobalAvgPool2d, self).__init__()
self.keep_dim = keep_dim
def forward(self, x):
return x.mean(3, keep... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
import torch.nn.parallel
import torch.optim
assert_size_stride = torch._C._dynamo.guards.asser... | xmyqsh/once-for-all | MyGlobalAvgPool2d | false | 4,585 | [
"MIT"
] | 0 | 0bca1778b106d33460fc8d0f7d7e6ca4e1e937d9 | https://github.com/xmyqsh/once-for-all/tree/0bca1778b106d33460fc8d0f7d7e6ca4e1e937d9 | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.parallel
import torch.optim
class Model(nn.Module):
def __init__(self, keep_dim=True):
super().__init__()
self.keep_dim = keep_dim
def forward(self, x):
return x.mean(3, keepdim=self.keep_dim).mean(2, keepdim=... |
MixedLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
def dice_loss(input, target):
input = torch.sigmoid(input)
smooth = 1.0
iflat = input.view(-1)
tflat = target.view(-1)
intersection = (iflat * tflat).sum()
return (2.0 * intersection + smooth) / (iflat.sum() + tflat.sum() + smo... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | xkp793003821/kaggle-tgs-salt | MixedLoss | false | 4,586 | [
"MIT"
] | 0 | 4acd7f8b6aff914e2c8558677d6dac8b5ddc1f30 | https://github.com/xkp793003821/kaggle-tgs-salt/tree/4acd7f8b6aff914e2c8558677d6dac8b5ddc1f30 | import torch
import torch.nn as nn
import torch.nn.functional as F
def dice_loss(input, target):
input = torch.sigmoid(input)
smooth = 1.0
iflat = input.view(-1)
tflat = target.view(-1)
intersection = (iflat * tflat).sum()
return (2.0 * intersection + smooth) / (iflat.sum() + tflat.sum() + smo... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch.nn import init
from torch.nn.parameter import Parameter
class SelfAttention(torch.nn.Module):
def __init__(self, wv_dim: 'int', maxlen: 'int'):
super(SelfAttention, self).__init__()
self.wv_dim = wv_dim
self.maxlen = maxlen
self.M = Parameter(torch.empty(si... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | xlwreally/Graduation-project-ABAE | SelfAttention | false | 4,587 | [
"MIT"
] | 0 | 7c389acfff0fd207e4588b4333521e2dfbf12ec7 | https://github.com/xlwreally/Graduation-project-ABAE/tree/7c389acfff0fd207e4588b4333521e2dfbf12ec7 | import torch
from torch.nn import init
from torch.nn.parameter import Parameter
class Model(torch.nn.Module):
def __init__(self, wv_dim: 'int', maxlen: 'int'):
super().__init__()
self.wv_dim = wv_dim
self.maxlen = maxlen
self.M = Parameter(torch.empty(size=(wv_dim, wv_dim)))
... |
SoftDetectionModule | # 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
import torch.nn as nn
import torch.nn.functional as F
class SoftDetectionModule(nn.Module):
def __init__(self, soft_local_max_size=3):
super(SoftDetectionModule, self).__init__()
self.soft_local_max_size = soft_local_max_size
self.pad = self.soft_local_max_... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils
imp... | xmlyqing00/d2-net | SoftDetectionModule | false | 4,588 | [
"BSD-3-Clause-Clear"
] | 0 | 3454a2862088682a6bdb2532ff049fd6cd82729c | https://github.com/xmlyqing00/d2-net/tree/3454a2862088682a6bdb2532ff049fd6cd82729c | import torch
import torch.utils
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, soft_local_max_size=3):
super().__init__()
self.soft_local_max_size = soft_local_max_size
self.pad = self.soft_local_max_size // 2
self.scale = 1000
... |
ForwardNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | xdong73S/Match_LSTM_v2.0 | ForwardNet | false | 4,589 | [
"MIT"
] | 0 | dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | https://github.com/xdong73S/Match_LSTM_v2.0/tree/dfb8cfbc2a5dafc6655eecf151a7dbcf808cd729 | import torch
import torch.utils.data
import torch.nn.functional as F
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask
:param x:
:param m:
:param dim:
:return:
"""
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim... |
Str2MSA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super(LayerNorm, self).__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wukevin/RoseTTAFold | Str2MSA | false | 4,590 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super().__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
def ... |
LogitBinaryCrossEntropy | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class LogitBinaryCrossEntropy(nn.Module):
def __init__(self):
super(LogitBinaryCrossEntropy, self).__init__()
def forward(self, pred_score, target_score, weights=None):
loss = F.binary_cross_entropy_wi... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | xymtxwd/OSDA_with_soft_rejection | LogitBinaryCrossEntropy | false | 4,591 | [
"MIT"
] | 0 | a71394ae755c663508b33d3dddb1204ce7cb3fc0 | https://github.com/xymtxwd/OSDA_with_soft_rejection/tree/a71394ae755c663508b33d3dddb1204ce7cb3fc0 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred_score, target_score, weights=None):
loss = F.binary_cross_entropy_with_logits(pred_score, target_score,
... |
Conv2dSame | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
import torch.nn.functional as F
from typing import Optional
from typing import Tuple
import torch.nn.parallel
import torch.optim
def _calc_same_pad(input_: 'int', kernel: 'int', stride: 'int', dilation: 'int'
):
"""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 torch.utils.data
import torch.utils.data.distributed
from torch import nn... | xmyyzy123/zen_nas | Conv2dSame | false | 4,592 | [
"Apache-2.0"
] | 0 | 4870eb0a030856bd67afe8529f65af8dc3bd81dc | https://github.com/xmyyzy123/zen_nas/tree/4870eb0a030856bd67afe8529f65af8dc3bd81dc | import torch
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
import torch.nn.functional as F
from typing import Optional
from typing import Tuple
import torch.nn.parallel
import torch.optim
def _calc_same_pad(input_: 'int', kernel: 'int', stride: 'int', dilation: 'int'
):
"""c... |
DirectEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super(LayerNorm, self).__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wukevin/RoseTTAFold | DirectEncoderLayer | false | 4,593 | [
"MIT"
] | 0 | e3c15dbf4bc1e4f8726e26c63aca1625188da803 | https://github.com/wukevin/RoseTTAFold/tree/e3c15dbf4bc1e4f8726e26c63aca1625188da803 | import torch
import torch.nn as nn
import torch.nn.functional as F
class LayerNorm(nn.Module):
def __init__(self, d_model, eps=1e-05):
super().__init__()
self.a_2 = nn.Parameter(torch.ones(d_model))
self.b_2 = nn.Parameter(torch.zeros(d_model))
self.eps = eps
def forward(self... |
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
import torch.nn.functional as F
class SEModule(nn.Module):
def __init__(self, planes, compress_rate):
super(SEModule, self).__init__()
self.conv1 = nn.Conv2d(planes, planes // compress_rate, kernel_size
=1, stride=1, bias=True)
self.conv2 = n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | xuehaouwa/VGGFace2-pytorch | SEModule | false | 4,594 | [
"MIT"
] | 0 | c38e11f893e5bcc273a9b847530cd619019b636c | https://github.com/xuehaouwa/VGGFace2-pytorch/tree/c38e11f893e5bcc273a9b847530cd619019b636c | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, planes, compress_rate):
super().__init__()
self.conv1 = nn.Conv2d(planes, planes // compress_rate, kernel_size
=1, stride=1, bias=True)
self.conv2 = nn.Conv2d(planes /... |
Upsample4x | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Upsample4x(nn.Module):
def __init__(self, n_channels):
super(Upsample4x, self).__init__()
self.conv = nn.Conv2d(n_channels, n_channels, 3, 1, 1)
def forward(self, x):
x = torch.nn.functional.interpolate(x, scale_factor=4, mode=
'bil... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | xqterry/lightweight-human-pose-estimation.pytorch | Upsample4x | false | 4,595 | [
"Apache-2.0"
] | 0 | e5ec9452c9bd9683451d3b2f97c6fe9e075b2d48 | https://github.com/xqterry/lightweight-human-pose-estimation.pytorch/tree/e5ec9452c9bd9683451d3b2f97c6fe9e075b2d48 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, n_channels):
super().__init__()
self.conv = nn.Conv2d(n_channels, n_channels, 3, 1, 1)
def forward(self, x):
x = torch.nn.functional.interpolate(x, scale_factor=4, mode=
'bilinear', align_corners... |
MixPad2d | # 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 itertools import product as product
import torch.nn as nn
class MixPad2d(nn.Module):
"""Mixed padding modes for H and W dimensions
Args:
padding (tuple): the size of the padding for x and y, ie (pad_x, pad_y)
modes (tuple): the padding modes for x and y, the values of each 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 itertools import product as product
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided... | xqyzjl/face_parsing | MixPad2d | false | 4,596 | [
"MIT"
] | 0 | 3d6c7b06d67c8fbf01bce22db199bc94a13a1a7c | https://github.com/xqyzjl/face_parsing/tree/3d6c7b06d67c8fbf01bce22db199bc94a13a1a7c | import torch
from itertools import product as product
import torch.nn as nn
class Model(nn.Module):
"""Mixed padding modes for H and W dimensions
Args:
padding (tuple): the size of the padding for x and y, ie (pad_x, pad_y)
modes (tuple): the padding modes for x and y, the values of each can ... |
GraphAttentionLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 module_test_print(var_input, var_inmed, var_ouput):
for var in (var_input, var_inmed, var_ouput):
None
for key, value in var.items():
None
None
class GraphAttentionLayer(nn.Module):
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.... | xlx0010/HGNN | GraphAttentionLayer | false | 4,597 | [
"MIT"
] | 0 | 219352405db021c1f435f3aa55961adcf2a6df19 | https://github.com/xlx0010/HGNN/tree/219352405db021c1f435f3aa55961adcf2a6df19 | import torch
import torch.nn as nn
import torch.nn.functional as F
def module_test_print(var_input, var_inmed, var_ouput):
for var in (var_input, var_inmed, var_ouput):
None
for key, value in var.items():
None
None
class Model(nn.Module):
def __init__(self, dim_input... |
ReturnAsLoss | # 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 ReturnAsLoss(nn.Module):
def __init__(self):
super(ReturnAsLoss, self).__init__()
def forward(self, output, y):
"""negative logarithm return"""
return -torch.sum(torch.log(torch.sum(output * (y + 1), dim=1)))
def get_inputs():
return [to... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | yanxurui/portfolio | ReturnAsLoss | false | 4,598 | [
"MIT"
] | 0 | 032cf47ccac1c5815fd4827bf0d5f3cf43cec990 | https://github.com/yanxurui/portfolio/tree/032cf47ccac1c5815fd4827bf0d5f3cf43cec990 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, y):
"""negative logarithm return"""
return -torch.sum(torch.log(torch.sum(output * (y + 1), dim=1)))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), t... |
SqueezeExcitation | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def _make_divisible(width, divisor=8):
new_width = max(divisor, int(width + divisor / 2) // divisor * divisor)
if new_width < 0.9 * width:
new_width += divisor
return new_width
class SqueezeExcitation(torch.nn.Module):
""" [https://arxiv.org/abs/1709.0150... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
asser... | yakhyo/MobileNetV3-pt | SqueezeExcitation | false | 4,599 | [
"MIT"
] | 0 | 1fbc966036ed9f036090b3efe3e700f057aa7dde | https://github.com/yakhyo/MobileNetV3-pt/tree/1fbc966036ed9f036090b3efe3e700f057aa7dde | import torch
import torch.utils.data
def _make_divisible(width, divisor=8):
new_width = max(divisor, int(width + divisor / 2) // divisor * divisor)
if new_width < 0.9 * width:
new_width += divisor
return new_width
class Model(torch.nn.Module):
""" [https://arxiv.org/abs/1709.01507] """
... |
Binary | # 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 Binary(nn.Module):
def __init__(self):
super().__init__()
self._criteria = nn.BCELoss()
def forward(self, output, y):
y_copy = y.clone()
y_copy[y > 0] = 0.9
y_copy[y < 0] = 0
return self._criteria(output, y_copy)
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 libdevice, math as tl_math
import torc... | yanxurui/portfolio | Binary | false | 4,600 | [
"MIT"
] | 0 | 032cf47ccac1c5815fd4827bf0d5f3cf43cec990 | https://github.com/yanxurui/portfolio/tree/032cf47ccac1c5815fd4827bf0d5f3cf43cec990 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self._criteria = nn.BCELoss()
def forward(self, output, y):
y_copy = y.clone()
y_copy[y > 0] = 0.9
y_copy[y < 0] = 0
return self._criteria(output, y_copy)
def g... |
CustomizedLoss | # 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 CustomizedLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, y):
return -torch.mean(torch.sum(output * y, dim=1))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | yanxurui/portfolio | CustomizedLoss | false | 4,601 | [
"MIT"
] | 0 | 032cf47ccac1c5815fd4827bf0d5f3cf43cec990 | https://github.com/yanxurui/portfolio/tree/032cf47ccac1c5815fd4827bf0d5f3cf43cec990 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, y):
return -torch.mean(torch.sum(output * y, dim=1))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
re... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.