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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
Attention | # 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 Attention(nn.Module):
"""
several score types like dot,general and concat
"""
def __init__(self, method='dot', hidden_size=None):
super(Attention, self).__init__()
self.method = method
if self.method != '... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | CNLPT/lightNLP | Attention | false | 13,433 | [
"Apache-2.0"
] | 889 | c7f128422ba5b16f514bb294145cb3b562e95829 | https://github.com/CNLPT/lightNLP/tree/c7f128422ba5b16f514bb294145cb3b562e95829 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
several score types like dot,general and concat
"""
def __init__(self, method='dot', hidden_size=None):
super().__init__()
self.method = method
if self.method != 'dot':
s... |
MSBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MSBlock(nn.Module):
def __init__(self, c_in, rate=4):
super(MSBlock, self).__init__()
self.rate = rate
self.conv = nn.Conv2d(c_in, 32, 3, stride=1, padding=1)
self.relu = nn.ReLU(inplace=True)
dilation = self.rate * 1 if self.rate >... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | CM-BF/FeatureFlow | MSBlock | false | 13,434 | [
"MIT"
] | 161 | 06642697922f17211e5faa353e24b1a0946885b1 | https://github.com/CM-BF/FeatureFlow/tree/06642697922f17211e5faa353e24b1a0946885b1 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, c_in, rate=4):
super().__init__()
self.rate = rate
self.conv = nn.Conv2d(c_in, 32, 3, stride=1, padding=1)
self.relu = nn.ReLU(inplace=True)
dilation = self.rate * 1 if self.rate >= 1 else 1
... |
LinearBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.nn.init
import torch.optim
class Model(nn.Module):
""" Class representing sampleable neural network model """
def num_params(self):
""" Get the number of model parameters. """
return sum(p.numel() for p in self.parameters())
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | CBIIT/NCI-DOE-Collab-Pilot2-Autoencoder_MD_Simulation_Data | LinearBlock | false | 13,435 | [
"MIT"
] | 51 | 2b1213f944cf5f2c60799099a469989a1f0a6d3a | https://github.com/CBIIT/NCI-DOE-Collab-Pilot2-Autoencoder_MD_Simulation_Data/tree/2b1213f944cf5f2c60799099a469989a1f0a6d3a | import torch
import torch.nn as nn
import torch.nn
import torch.nn.init
import torch.optim
class Model(nn.Module):
""" Class representing sampleable neural network model """
def num_params(self):
""" Get the number of model parameters. """
return sum(p.numel() for p in self.parameters())
... |
CharbonnierLoss | # 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 CharbonnierLoss(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=1e-06):
super(CharbonnierLoss, self).__init__()
self.eps = eps
def forward(self, x, y):
diff = x - y
loss = torch.mean(torch.sqrt(diff * diff + self.eps... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | CM-BF/FeatureFlow | CharbonnierLoss | false | 13,436 | [
"MIT"
] | 161 | 06642697922f17211e5faa353e24b1a0946885b1 | https://github.com/CM-BF/FeatureFlow/tree/06642697922f17211e5faa353e24b1a0946885b1 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=1e-06):
super().__init__()
self.eps = eps
def forward(self, x, y):
diff = x - y
loss = torch.mean(torch.sqrt(diff * diff + self.eps))
return loss
def ge... |
down | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.functional import F
from torch.nn import functional as F
class down(nn.Module):
"""
A class for creating neural network blocks containing layers:
Average Pooling --> Convlution + Leaky ReLU --> Convolution + Leaky ReLU
Thi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | CM-BF/FeatureFlow | down | false | 13,437 | [
"MIT"
] | 161 | 06642697922f17211e5faa353e24b1a0946885b1 | https://github.com/CM-BF/FeatureFlow/tree/06642697922f17211e5faa353e24b1a0946885b1 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.functional import F
from torch.nn import functional as F
class Model(nn.Module):
"""
A class for creating neural network blocks containing layers:
Average Pooling --> Convlution + Leaky ReLU --> Convolution + Leaky ReLU
Th... |
_Residual_Block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 _Residual_Block(nn.Module):
def __init__(self, inc=64, outc=64, groups=1):
super(_Residual_Block, self).__init__()
if inc is not outc:
self.conv_expand = nn.Conv2d(in_channels=inc, out_channels=outc,
kernel_size=1, stride=1, pad... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | BradyFU/DVG | _Residual_Block | false | 13,438 | [
"MIT"
] | 102 | 53fd50cdc51d783b33394726b8f8a2b2216f157b | https://github.com/BradyFU/DVG/tree/53fd50cdc51d783b33394726b8f8a2b2216f157b | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inc=64, outc=64, groups=1):
super().__init__()
if inc is not outc:
self.conv_expand = nn.Conv2d(in_channels=inc, out_channels=outc,
kernel_size=1, stride=1, padding=0, groups=1, bias=False)
... |
RNN_net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class RNN_net(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(RNN_net, self).__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidde... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | CMOONCS/DeepLearning | RNN_net | false | 13,439 | [
"MIT"
] | 86 | 748107d27e466bb18559b828642a4cace6431dc2 | https://github.com/CMOONCS/DeepLearning/tree/748107d27e466bb18559b828642a4cace6431dc2 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_... |
TLU | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class TLU(nn.Module):
def __init__(self, num_features):
super(TLU, self).__init__()
self.num_features = num_features
self.tau = Parameter(torch.Tensor(1, num_features, 1, 1),
requires_grad=True)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from torch.nn.parameter import Parameter
assert_size_stride = torch... | COATZ/ShapeConv | TLU | false | 13,440 | [
"Apache-2.0"
] | 57 | f34f4e95ee2b69ac645fd5ba608e3c11cfadfded | https://github.com/COATZ/ShapeConv/tree/f34f4e95ee2b69ac645fd5ba608e3c11cfadfded | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, num_features):
super().__init__()
self.num_features = num_features
self.tau = Parameter(torch.Tensor(1, num_features, 1, 1),
requires_grad=True)
self.... |
PixelNormLayer | # 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 PixelNormLayer(nn.Module):
"""Implements pixel-wise feature vector normalization layer."""
def __init__(self, epsilon=1e-08):
super().__init__()
self.epsilon = epsilon
def forward(self, x):
return x / torch.sqrt(torch.mean(x ** 2, dim=1, k... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | CV-IP/interfacegan | PixelNormLayer | false | 13,441 | [
"MIT"
] | 855 | 5a556b8e693f6e1888f769f653aaafaaccca5dc2 | https://github.com/CV-IP/interfacegan/tree/5a556b8e693f6e1888f769f653aaafaaccca5dc2 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Implements pixel-wise feature vector normalization layer."""
def __init__(self, epsilon=1e-08):
super().__init__()
self.epsilon = epsilon
def forward(self, x):
return x / torch.sqrt(torch.mean(x ** 2, dim=1, keepdim=Tr... |
Upsample | # 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.parallel
class Upsample(nn.Module):
def __init__(self, n_iter):
super(Upsample, self).__init__()
self.n_iter = n_iter
def forward(self, img):
for _ in range(self.n_iter):
img = nn.functional.interpolate(img, scale_factor=... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import... | AyushExel/GANSketching | Upsample | false | 13,442 | [
"MIT"
] | 598 | c72524ac4425de898087af7a4c554b777a4e2218 | https://github.com/AyushExel/GANSketching/tree/c72524ac4425de898087af7a4c554b777a4e2218 | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, n_iter):
super().__init__()
self.n_iter = n_iter
def forward(self, img):
for _ in range(self.n_iter):
img = nn.functional.interpolate(img, scale_factor=2.0, mode=
... |
MLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class SharedDropout(nn.Module):
def __init__(self, p=0.5, batch_first=True):
super(SharedDropout, self).__init__()
self.p = p
self.batch_first = batch_first
def extra_repr(self):
info = f'p={self.p}'
if self.batch_first:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | CNLPT/lightNLP | MLP | false | 13,443 | [
"Apache-2.0"
] | 889 | c7f128422ba5b16f514bb294145cb3b562e95829 | https://github.com/CNLPT/lightNLP/tree/c7f128422ba5b16f514bb294145cb3b562e95829 | import torch
import torch.nn as nn
class SharedDropout(nn.Module):
def __init__(self, p=0.5, batch_first=True):
super().__init__()
self.p = p
self.batch_first = batch_first
def extra_repr(self):
info = f'p={self.p}'
if self.batch_first:
info += f', batch_f... |
AttentionModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class AttentionModule(nn.Module):
def __init__(self, d_model, d_k=None, device='cpu', dropout=None):
super().__init__()
if not d_k:
d_k = d_model
self.W = nn.Parameter(torch.randn(d_model, d_model, device=device... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | BruceWen120/medical-abbreviation-pretraining | AttentionModule | false | 13,444 | [
"Apache-2.0",
"MIT"
] | 125 | 333e49461f7463e97515f949f441c7ac8af7d980 | https://github.com/BruceWen120/medical-abbreviation-pretraining/tree/333e49461f7463e97515f949f441c7ac8af7d980 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, d_model, d_k=None, device='cpu', dropout=None):
super().__init__()
if not d_k:
d_k = d_model
self.W = nn.Parameter(torch.randn(d_model, d_model, device=device))
... |
Resv1Block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 conv3x3(in_channels, out_channels, stride=1, padding=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_channels, out_channels, 3, stride, padding, bias=True)
class Resv1Block(nn.Module):
"""ResNet v1 block without bn"""
def __init__(self, inplanes, pl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | CNN-NISER/lffd-pytorch | Resv1Block | false | 13,445 | [
"MIT"
] | 220 | 7d6476ece79cf75c6265c89346ddac48929ce8f6 | https://github.com/CNN-NISER/lffd-pytorch/tree/7d6476ece79cf75c6265c89346ddac48929ce8f6 | import torch
import torch.nn as nn
def conv3x3(in_channels, out_channels, stride=1, padding=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_channels, out_channels, 3, stride, padding, bias=True)
class Model(nn.Module):
"""ResNet v1 block without bn"""
def __init__(self, inplanes, planes,... |
Conv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
from torch import nn
class Conv(nn.Module):
def __init__(self, inp_dim, out_dim, kernel_size=3, stride=1, bn=False,
relu=True):
super(Conv, self).__init__()
self.inp_dim = inp_dim
self.conv = nn.Conv2d(inp_dim, out_dim, kernel_size, stride,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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
from ... | CenIII/pose-ae-train | Conv | false | 13,446 | [
"BSD-3-Clause"
] | 250 | 8780ba9f3d80ca3a724bbee7b815073adc3d3e6e | https://github.com/CenIII/pose-ae-train/tree/8780ba9f3d80ca3a724bbee7b815073adc3d3e6e | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
def __init__(self, inp_dim, out_dim, kernel_size=3, stride=1, bn=False,
relu=True):
super().__init__()
self.inp_dim = inp_dim
self.conv = nn.Conv2d(inp_dim, out_dim, kernel_size, stride,
... |
L2Norm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class L2Norm(nn.Module):
"""L2Norm layer across all channels."""
def __init__(self, in_features, scale):
super(L2Norm, self).__init__()
self.weight = nn.Parameter(torch.Tensor(in_features))
self.reset_parameters(scale)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | CVHj/torchcv | L2Norm | false | 13,447 | [
"MIT"
] | 433 | 6291f3e1e4bbf6467fd6b1e79001d34a59481bb6 | https://github.com/CVHj/torchcv/tree/6291f3e1e4bbf6467fd6b1e79001d34a59481bb6 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""L2Norm layer across all channels."""
def __init__(self, in_features, scale):
super().__init__()
self.weight = nn.Parameter(torch.Tensor(in_features))
self.reset_parameters(scale)
def res... |
BranchNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 conv1x1(in_channels, out_channels):
"""1x1 convolution"""
return nn.Conv2d(in_channels, out_channels, 1, bias=True)
class BranchNet(nn.Module):
"""
The branch of NaiveNet is the network output and
only consists of conv 1×1 and ReLU.
"""
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
import torch.nn as nn
assert_... | CNN-NISER/lffd-pytorch | BranchNet | false | 13,448 | [
"MIT"
] | 220 | 7d6476ece79cf75c6265c89346ddac48929ce8f6 | https://github.com/CNN-NISER/lffd-pytorch/tree/7d6476ece79cf75c6265c89346ddac48929ce8f6 | import torch
import torch.nn as nn
def conv1x1(in_channels, out_channels):
"""1x1 convolution"""
return nn.Conv2d(in_channels, out_channels, 1, bias=True)
class Model(nn.Module):
"""
The branch of NaiveNet is the network output and
only consists of conv 1×1 and ReLU.
"""
def __init__(s... |
Downsample | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Downsample(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
self.conv = torch.nn.Conv2d(in_channels, in_channels,
kernel_size=3, stride=2, padding=0... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | CasualGANPapers/Make-A-Scene | Downsample | false | 13,449 | [
"MIT"
] | 47 | 4457ef91ccf4a345f3178cf821f12b49df616b6d | https://github.com/CasualGANPapers/Make-A-Scene/tree/4457ef91ccf4a345f3178cf821f12b49df616b6d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
self.conv = torch.nn.Conv2d(in_channels, in_channels,
kernel_size=3, stride=2, padding=0)
... |
backWarp | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
class backWarp(nn.Module):
"""
A class for creating a backwarping object.
This is used for backwarping to an image:
Given optical flow from frame I0 to I1 --> F_0_1 and frame I1,
it generates I0 <-- backwarp(F_0_1, I1).
...
Methods
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import numpy as np
import to... | CM-BF/FeatureFlow | backWarp | false | 13,450 | [
"MIT"
] | 161 | 06642697922f17211e5faa353e24b1a0946885b1 | https://github.com/CM-BF/FeatureFlow/tree/06642697922f17211e5faa353e24b1a0946885b1 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
"""
A class for creating a backwarping object.
This is used for backwarping to an image:
Given optical flow from frame I0 to I1 --> F_0_1 and frame I1,
it generates I0 <-- backwarp(F_0_1, I1).
...
Methods
... |
Biaffine | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Biaffine(nn.Module):
def __init__(self, n_in, n_out=1, bias_x=True, bias_y=True):
super(Biaffine, self).__init__()
self.n_in = n_in
self.n_out = n_out
self.bias_x = bias_x
self.bias_y = bias_y
self.weight = nn.Parameter(torc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | CNLPT/lightNLP | Biaffine | false | 13,451 | [
"Apache-2.0"
] | 889 | c7f128422ba5b16f514bb294145cb3b562e95829 | https://github.com/CNLPT/lightNLP/tree/c7f128422ba5b16f514bb294145cb3b562e95829 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_in, n_out=1, bias_x=True, bias_y=True):
super().__init__()
self.n_in = n_in
self.n_out = n_out
self.bias_x = bias_x
self.bias_y = bias_y
self.weight = nn.Parameter(torch.Tensor(n_out, n... |
MaxPoolStride1 | # 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 MaxPoolStride1(nn.Module):
def __init__(self):
super(MaxPoolStride1, self).__init__()
def forward(self, x):
x_pad = F.pad(x, (0, 1, 0, 1), mode='replicate')
x = F.max_pool2d(x_pad, 2, stride=1)
return 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... | CharlesPikachu/YOLO | MaxPoolStride1 | false | 13,452 | [
"MIT"
] | 57 | 950b11c35517c1c3d7d7856b5768c4023c1f89eb | https://github.com/CharlesPikachu/YOLO/tree/950b11c35517c1c3d7d7856b5768c4023c1f89eb | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
x_pad = F.pad(x, (0, 1, 0, 1), mode='replicate')
x = F.max_pool2d(x_pad, 2, stride=1)
return x
def get_inputs():
retur... |
Merge | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
from torch import nn
class Conv(nn.Module):
def __init__(self, inp_dim, out_dim, kernel_size=3, stride=1, bn=False,
relu=True):
super(Conv, self).__init__()
self.inp_dim = inp_dim
self.conv = nn.Conv2d(inp_dim, out_dim, kernel_size, stride,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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
from torch import nn
assert_size_stride = torch._C._dyna... | CenIII/pose-ae-train | Merge | false | 13,453 | [
"BSD-3-Clause"
] | 250 | 8780ba9f3d80ca3a724bbee7b815073adc3d3e6e | https://github.com/CenIII/pose-ae-train/tree/8780ba9f3d80ca3a724bbee7b815073adc3d3e6e | import torch
import torch.utils.data
from torch import nn
class Conv(nn.Module):
def __init__(self, inp_dim, out_dim, kernel_size=3, stride=1, bn=False,
relu=True):
super().__init__()
self.inp_dim = inp_dim
self.conv = nn.Conv2d(inp_dim, out_dim, kernel_size, stride,
p... |
MultiHeadSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.init
import torch.nn.parallel
class MultiHeadSelfAttention(nn.Module):
"""Self-attention module by Lin, Zhouhan, et al. ICLR 2017"""
def __init__(self, n_head, d_in, d_hidden):
super(MultiHeadSelfAttention, self).__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | CLT29/pvse | MultiHeadSelfAttention | false | 13,454 | [
"MIT"
] | 119 | bf5232148396ee5051564ef68a48538de0ddbc84 | https://github.com/CLT29/pvse/tree/bf5232148396ee5051564ef68a48538de0ddbc84 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.init
import torch.nn.parallel
class Model(nn.Module):
"""Self-attention module by Lin, Zhouhan, et al. ICLR 2017"""
def __init__(self, n_head, d_in, d_hidden):
super().__init__()
self.n_head = n_head
self.w_1 = nn.L... |
LogSTFTMagnitudeLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn.functional as F
class LogSTFTMagnitudeLoss(torch.nn.Module):
"""Log STFT magnitude loss module."""
def __init__(self):
"""Initilize los STFT magnitude loss module."""
super(LogSTFTMagnitudeLoss, self).__init__()
def forward(self, x_mag... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.dat... | ChanganVR/hifigan-denoiser | LogSTFTMagnitudeLoss | false | 13,455 | [
"Apache-2.0"
] | 100 | 9bd77c53556e1372b4bbff8dce8b120297cc4e5c | https://github.com/ChanganVR/hifigan-denoiser/tree/9bd77c53556e1372b4bbff8dce8b120297cc4e5c | import torch
import torch.utils.data
import torch.nn.functional as F
class Model(torch.nn.Module):
"""Log STFT magnitude loss module."""
def __init__(self):
"""Initilize los STFT magnitude loss module."""
super().__init__()
def forward(self, x_mag, y_mag):
"""Calculate forward pr... |
GlobalAvgPool2d | # 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 GlobalAvgPool2d(nn.Module):
def __init__(self):
super(GlobalAvgPool2d, self).__init__()
def forward(self, x):
N = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.data.size(3)
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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | CharlesPikachu/YOLO | GlobalAvgPool2d | false | 13,456 | [
"MIT"
] | 57 | 950b11c35517c1c3d7d7856b5768c4023c1f89eb | https://github.com/CharlesPikachu/YOLO/tree/950b11c35517c1c3d7d7856b5768c4023c1f89eb | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
N = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.data.size(3)
x = F.avg_pool2d(x, (H, W))
... |
MatrixTree | # 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.cuda
import torch.distributed
class MatrixTree(nn.Module):
"""Implementation of the matrix-tree theorem for computing marginals
of non-projective dependency parsing. This attention layer is used
in the paper "Learning Structured Text Representations"
:ci... | 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
import torch.cuda
import torch.distributed
assert_s... | BradLin0819/kg2text | MatrixTree | false | 13,457 | [
"Apache-2.0"
] | 86 | e586eb2027c0d85db9826cbe1d9e14f2d26fc93f | https://github.com/BradLin0819/kg2text/tree/e586eb2027c0d85db9826cbe1d9e14f2d26fc93f | import torch
import torch.nn as nn
import torch.cuda
import torch.distributed
class Model(nn.Module):
"""Implementation of the matrix-tree theorem for computing marginals
of non-projective dependency parsing. This attention layer is used
in the paper "Learning Structured Text Representations"
:cite:`D... |
ResolutionScalingLayer | # 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 ResolutionScalingLayer(nn.Module):
"""Implements the resolution scaling layer.
Basically, this layer can be used to upsample or downsample feature maps from
spatial domain with nearest neighbor interpolation.
"""
def __init__(sel... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | CV-IP/interfacegan | ResolutionScalingLayer | false | 13,458 | [
"MIT"
] | 855 | 5a556b8e693f6e1888f769f653aaafaaccca5dc2 | https://github.com/CV-IP/interfacegan/tree/5a556b8e693f6e1888f769f653aaafaaccca5dc2 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Implements the resolution scaling layer.
Basically, this layer can be used to upsample or downsample feature maps from
spatial domain with nearest neighbor interpolation.
"""
def __init__(self, scale_factor=2... |
SpectralConvergengeLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
class SpectralConvergengeLoss(torch.nn.Module):
"""Spectral convergence loss module."""
def __init__(self):
"""Initilize spectral convergence loss module."""
super(SpectralConvergengeLoss, self).__init__()
def forward(self, x_mag, y_mag):
"""C... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.data
asse... | ChanganVR/hifigan-denoiser | SpectralConvergengeLoss | false | 13,459 | [
"Apache-2.0"
] | 100 | 9bd77c53556e1372b4bbff8dce8b120297cc4e5c | https://github.com/ChanganVR/hifigan-denoiser/tree/9bd77c53556e1372b4bbff8dce8b120297cc4e5c | import torch
import torch.utils.data
class Model(torch.nn.Module):
"""Spectral convergence loss module."""
def __init__(self):
"""Initilize spectral convergence loss module."""
super().__init__()
def forward(self, x_mag, y_mag):
"""Calculate forward propagation.
Args:
... |
Reorg | # 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 Reorg(nn.Module):
def __init__(self, stride=2):
super(Reorg, self).__init__()
self.stride = stride
def forward(self, x):
assert x.data.dim() == 4
B = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.da... | 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... | CharlesPikachu/YOLO | Reorg | false | 13,460 | [
"MIT"
] | 57 | 950b11c35517c1c3d7d7856b5768c4023c1f89eb | https://github.com/CharlesPikachu/YOLO/tree/950b11c35517c1c3d7d7856b5768c4023c1f89eb | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, stride=2):
super().__init__()
self.stride = stride
def forward(self, x):
assert x.data.dim() == 4
B = x.data.size(0)
C = x.data.size(1)
H = x.data.size(2)
W = x.data.size(3)
... |
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.LayerNorm):
def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True):
"""Layer Norm."""
super(LayerNorm, self).__init__(normalized_shape, eps=eps,
elementwise_affine=elementwise_affine)
def forward(self, x):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | ChavesLiu/pytorch-dc-tts | LayerNorm | false | 13,461 | [
"MIT"
] | 145 | 29a1ab11f69b2c4316ae0a8766e995b96385a29f | https://github.com/ChavesLiu/pytorch-dc-tts/tree/29a1ab11f69b2c4316ae0a8766e995b96385a29f | import torch
import torch.nn as nn
class Model(nn.LayerNorm):
def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True):
"""Layer Norm."""
super().__init__(normalized_shape, eps=eps,
elementwise_affine=elementwise_affine)
def forward(self, x):
x = x.permute... |
LayerNormConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class LayerNormConv2d(nn.Module):
def __init__(self, num_features, eps=1e-05, affine=True):
super().__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
if self.affine:
sel... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn.functional
assert_size_stride = torch._C.... | ChenFengYe/relightable-nr | LayerNormConv2d | false | 13,462 | [
"MIT"
] | 105 | 239a97406f4df01cf5786dcdde58e464395a682d | https://github.com/ChenFengYe/relightable-nr/tree/239a97406f4df01cf5786dcdde58e464395a682d | import torch
import torch.nn as nn
import torch.nn.functional
class Model(nn.Module):
def __init__(self, num_features, eps=1e-05, affine=True):
super().__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
if self.affine:
self.gamma = ... |
maxout | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class maxout(nn.Module):
"""
maxout network
"""
def __init__(self, in_feature, out_feature, pool_size):
super(maxout, self).__init__()
self.in_feature = in_feature
self.out_feature = out_feature
self.pool_size ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | ChenZhongFu/KOBE | maxout | false | 13,463 | [
"MIT"
] | 176 | 710d7556516bdbd9ad971e6ff8b8f625a1a55e5a | https://github.com/ChenZhongFu/KOBE/tree/710d7556516bdbd9ad971e6ff8b8f625a1a55e5a | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
maxout network
"""
def __init__(self, in_feature, out_feature, pool_size):
super().__init__()
self.in_feature = in_feature
self.out_feature = out_feature
self.pool_size = pool_size
... |
Down2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
class Down2d(nn.Module):
"""docstring for Down2d."""
def __init__(self, in_channel, out_channel, kernel, stride, padding):
super(Down2d, self).__init__()
self.c1 = nn.Conv2d(in_channel, out_channel, kernel_size=kernel,
str... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | ChanganVR/hifigan-denoiser | Down2d | false | 13,464 | [
"Apache-2.0"
] | 100 | 9bd77c53556e1372b4bbff8dce8b120297cc4e5c | https://github.com/ChanganVR/hifigan-denoiser/tree/9bd77c53556e1372b4bbff8dce8b120297cc4e5c | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
"""docstring for Down2d."""
def __init__(self, in_channel, out_channel, kernel, stride, padding):
super().__init__()
self.c1 = nn.Conv2d(in_channel, out_channel, kernel_size=kernel,
stride=stride, p... |
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.nn as nn
import torch.nn.functional
class Conv2dSame(torch.nn.Module):
"""2D convolution that pads to keep spatial dimensions equal.
Cannot deal with stride. Only quadratic kernels (=scalar kernel_size).
"""
def __init__(self, in_channels, out_channels, kernel_size, bias=Tru... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | ChenFengYe/relightable-nr | Conv2dSame | false | 13,465 | [
"MIT"
] | 105 | 239a97406f4df01cf5786dcdde58e464395a682d | https://github.com/ChenFengYe/relightable-nr/tree/239a97406f4df01cf5786dcdde58e464395a682d | import torch
import torch.nn as nn
import torch.nn.functional
class Model(torch.nn.Module):
"""2D convolution that pads to keep spatial dimensions equal.
Cannot deal with stride. Only quadratic kernels (=scalar kernel_size).
"""
def __init__(self, in_channels, out_channels, kernel_size, bias=True,
... |
ResidualConv1dGLU | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.utils.data
import torch.nn.functional as F
import torch.nn as nn
class ResidualConv1dGLU(nn.Module):
"""Residual dilated conv1d + Gated linear unit
Args:
residual_channels (int): Residual input / output channels
gate_channels (int): Gated activation channe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.... | ChanganVR/hifigan-denoiser | ResidualConv1dGLU | false | 13,466 | [
"Apache-2.0"
] | 100 | 9bd77c53556e1372b4bbff8dce8b120297cc4e5c | https://github.com/ChanganVR/hifigan-denoiser/tree/9bd77c53556e1372b4bbff8dce8b120297cc4e5c | import math
import torch
import torch.utils.data
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""Residual dilated conv1d + Gated linear unit
Args:
residual_channels (int): Residual input / output channels
gate_channels (int): Gated activation channels.
... |
ShapeConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
import numpy as np
from torch.nn.modules.utils import _pair
import torch.nn.functional as F
from torch.nn.parameter import Parameter
from torch.nn import init
from torch._jit_internal import Optional
from torch.nn.modules.module import Module
class ShapeConv2d(Modu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
import math
import numpy as np
from torch.nn.modules... | COATZ/ShapeConv | ShapeConv2d | false | 13,467 | [
"Apache-2.0"
] | 57 | f34f4e95ee2b69ac645fd5ba608e3c11cfadfded | https://github.com/COATZ/ShapeConv/tree/f34f4e95ee2b69ac645fd5ba608e3c11cfadfded | from torch.nn import Module
import math
import torch
import numpy as np
from torch.nn.modules.utils import _pair
import torch.nn.functional as F
from torch.nn.parameter import Parameter
from torch.nn import init
from torch._jit_internal import Optional
from torch.nn.modules.module import Module
class Model(Module):
... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
def fanin_init(size, fanin=None):
fanin = fanin or size[0]
v = 1.0 / np.sqrt(fanin)
return torch.Tensor(size).uniform_(-v, v)
class Actor(nn.Module):
def __init__(self, nb_states, nb_actions, hidden1=256, hidden2=128,
init_w=0.003):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | ChangyWen/wolpertinger_ddpg | Actor | false | 13,468 | [
"MIT"
] | 46 | 23e1dcf19dd4bed3cc48f898122c3d57cfc296d3 | https://github.com/ChangyWen/wolpertinger_ddpg/tree/23e1dcf19dd4bed3cc48f898122c3d57cfc296d3 | import torch
import numpy as np
import torch.nn as nn
def fanin_init(size, fanin=None):
fanin = fanin or size[0]
v = 1.0 / np.sqrt(fanin)
return torch.Tensor(size).uniform_(-v, v)
class Model(nn.Module):
def __init__(self, nb_states, nb_actions, hidden1=256, hidden2=128,
init_w=0.003):
... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Actor(nn.Module):
def __init__(self, state_dim, action_dim, max_action):
super(Actor, self).__init__()
self.l1 = nn.Linear(state_dim, 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, action_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.... | ChenShawn/Adapted_TD3_Robustness_Certification | Actor | false | 13,469 | [
"MIT"
] | 91 | 6b28b031b098a2f0a49f2945f8a669205f09c4fe | https://github.com/ChenShawn/Adapted_TD3_Robustness_Certification/tree/6b28b031b098a2f0a49f2945f8a669205f09c4fe | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, action_dim, max_action):
super().__init__()
self.l1 = nn.Linear(state_dim, 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, action_dim)
self.... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Critic(nn.Module):
def __init__(self, state_dim, action_dim):
super(Critic, self).__init__()
self.l1 = nn.Linear(state_dim + action_dim, 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, 1)
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._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | ChenShawn/Adapted_TD3_Robustness_Certification | Critic | false | 13,470 | [
"MIT"
] | 91 | 6b28b031b098a2f0a49f2945f8a669205f09c4fe | https://github.com/ChenShawn/Adapted_TD3_Robustness_Certification/tree/6b28b031b098a2f0a49f2945f8a669205f09c4fe | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, action_dim):
super().__init__()
self.l1 = nn.Linear(state_dim + action_dim, 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, 1)
def forward(self... |
PIENet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.init
import torch.nn.parallel
class MultiHeadSelfAttention(nn.Module):
"""Self-attention module by Lin, Zhouhan, et al. ICLR 2017"""
def __init__(self, n_head, d_in, d_hidden):
super(MultiHeadSelfAttention, self).__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | CLT29/pvse | PIENet | false | 13,471 | [
"MIT"
] | 119 | bf5232148396ee5051564ef68a48538de0ddbc84 | https://github.com/CLT29/pvse/tree/bf5232148396ee5051564ef68a48538de0ddbc84 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.init
import torch.nn.parallel
class MultiHeadSelfAttention(nn.Module):
"""Self-attention module by Lin, Zhouhan, et al. ICLR 2017"""
def __init__(self, n_head, d_in, d_hidden):
super().__init__()
self.n_head = n_head
... |
HR2O_NL | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 HR2O_NL(nn.Module):
def __init__(self, hidden_dim=512, kernel_size=3, mlp_1x1=False):
super(HR2O_NL, self).__init__()
self.hidden_dim = hidden_dim
padding = kernel_size // 2
self.conv_q = nn.Conv2d(hidden_dim, hidden_dim, kernel_size,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | AlexandreDh/ACAR-Net | HR2O_NL | false | 13,472 | [
"Apache-2.0"
] | 162 | db28009388512e31cb6ff8e86725dc9b026886b6 | https://github.com/AlexandreDh/ACAR-Net/tree/db28009388512e31cb6ff8e86725dc9b026886b6 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_dim=512, kernel_size=3, mlp_1x1=False):
super().__init__()
self.hidden_dim = hidden_dim
padding = kernel_size // 2
self.conv_q = nn.Conv2d(hidden_dim, hidden_dim, kernel_size,
padding=... |
BiAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BiAttention(nn.Module):
def __init__(self, input_size, dropout):
super().__init__()
self.dropout = nn.Dropout(p=dropout)
self.input_linear = nn.Linear(input_size, 1, bias=False)
self.m... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | ChenZhongFu/KOBE | BiAttention | false | 13,473 | [
"MIT"
] | 176 | 710d7556516bdbd9ad971e6ff8b8f625a1a55e5a | https://github.com/ChenZhongFu/KOBE/tree/710d7556516bdbd9ad971e6ff8b8f625a1a55e5a | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, input_size, dropout):
super().__init__()
self.dropout = nn.Dropout(p=dropout)
self.input_linear = nn.Linear(input_size, 1, bias=False)
self.memory_... |
RankCrossEntropyLoss | # 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 RankCrossEntropyLoss(nn.Module):
"""Creates a criterion that measures rank cross entropy loss."""
__constants__ = ['num_neg']
def __init__(self, num_neg: 'int'=1):
"""
:class:`RankCrossEntropyLoss` constructor.
... | 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
... | ChrisRBXiong/MatchZoo-py | RankCrossEntropyLoss | false | 13,474 | [
"Apache-2.0"
] | 468 | 8883d0933a62610d71fec0215dce643630e03b1c | https://github.com/ChrisRBXiong/MatchZoo-py/tree/8883d0933a62610d71fec0215dce643630e03b1c | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Creates a criterion that measures rank cross entropy loss."""
__constants__ = ['num_neg']
def __init__(self, num_neg: 'int'=1):
"""
:class:`RankCrossEntropyLoss` constructor.
:param num_... |
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.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_actions, input_len):
super(Model, self).__init__()
self.fc1 = nn.Linear(input_len, 100)
self.fc2 = nn.Linear(100, 100)
self.out_policy = nn.Linear(100, n_actions)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | ChengUVa/ptan | Model | false | 13,475 | [
"MIT"
] | 492 | f9b3ef2680ff64fad52e600d73ff2bf42eee310d | https://github.com/ChengUVa/ptan/tree/f9b3ef2680ff64fad52e600d73ff2bf42eee310d | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_actions, input_len):
super(Model, self).__init__()
self.fc1 = nn.Linear(input_len, 100)
self.fc2 = nn.Linear(100, 100)
self.out_policy = nn.Linear(100, n_actions)
... |
ConvMeanPool | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super(CustomConv2d, self).__init__()
self.residual_init = residual_init
if padding is 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ChiragCD/NR-GAN | ConvMeanPool | false | 13,476 | [
"MIT"
] | 54 | fc455c6219b09bc8bf605715504b78b2bb801e48 | https://github.com/ChiragCD/NR-GAN/tree/fc455c6219b09bc8bf605715504b78b2bb801e48 | import torch
import torch.nn as nn
class CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super().__init__()
self.residual_init = residual_init
if padding is None:
padding = int(... |
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
import torch.nn.init
class MultiHeadAttention(nn.Module):
def __init__(self, heads, d_model, dropout=0.1):
super().__init__()
self.d_model = d_model
self.d_k = d_model // heads
self.h = heads
se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Chenny0808/tatk | MultiHeadAttention | false | 13,477 | [
"Apache-2.0"
] | 81 | 1c1a3cb557ba84bbfdbd1f6d8b8ea43ed8b9d7c5 | https://github.com/Chenny0808/tatk/tree/1c1a3cb557ba84bbfdbd1f6d8b8ea43ed8b9d7c5 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init
class Model(nn.Module):
def __init__(self, heads, d_model, dropout=0.1):
super().__init__()
self.d_model = d_model
self.d_k = d_model // heads
self.h = heads
self.q_linear =... |
SoftEntropy | # 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
from torch.nn import *
from torch.optim.lr_scheduler import *
class SoftEntropy(nn.Module):
def __init__(self):
super(SoftEntropy, self).__init__()
self.logsoftmax = nn.LogSoftmax(dim=1)
def forward(self, inputs, targets):
... | 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
f... | ChienHsuan/MMT | SoftEntropy | false | 13,478 | [
"MIT"
] | 425 | fe4a559b8af3ec93242b24acb4c8e962a00a1248 | https://github.com/ChienHsuan/MMT/tree/fe4a559b8af3ec93242b24acb4c8e962a00a1248 | import torch
from torch import nn
import torch.nn.functional as F
from torch.nn import *
from torch.optim.lr_scheduler import *
class Model(nn.Module):
def __init__(self):
super().__init__()
self.logsoftmax = nn.LogSoftmax(dim=1)
def forward(self, inputs, targets):
log_probs = self.l... |
Accuracy | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class Accuracy(nn.Module):
"""
This class implements the accuracy computation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""... | 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... | ChristophReich1996/Cell-DETR | Accuracy | false | 13,479 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the accuracy computation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
... |
CustomConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super(CustomConv2d, self).__init__()
self.residual_init = residual_init
if padding is 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ChiragCD/NR-GAN | CustomConv2d | false | 13,480 | [
"MIT"
] | 54 | fc455c6219b09bc8bf605715504b78b2bb801e48 | https://github.com/ChiragCD/NR-GAN/tree/fc455c6219b09bc8bf605715504b78b2bb801e48 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super().__init__()
self.residual_init = residual_init
if padding is None:
padding = int((kernel... |
Relation | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
from torch.nn import functional as F
class Relation(nn.Module):
def __init__(self, C, H, out_size):
super(Relation, self).__init__()
self.out_size = out_size
self.M = torch.nn.Parameter(torch.randn(H, H, out_size))
self.W ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | ChenZhannnnn/chenzhan | Relation | false | 13,481 | [
"Apache-2.0"
] | 45 | b26a9512bbd1efe86c35c91a625da40b6f94dfc7 | https://github.com/ChenZhannnnn/chenzhan/tree/b26a9512bbd1efe86c35c91a625da40b6f94dfc7 | import torch
import torch.utils.data
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, C, H, out_size):
super().__init__()
self.out_size = out_size
self.M = torch.nn.Parameter(torch.randn(H, H, out_size))
self.W = torch.nn.Parame... |
TripletLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
from torch.nn import *
from torch.optim.lr_scheduler import *
def _batch_hard(mat_distance, mat_similarity, indice=False):
sorted_mat_distance, positive_indices = torch.sort(mat_distance + -
9999999.0 * (1 - mat_similarity), dim=1, descendi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | ChienHsuan/MMT | TripletLoss | false | 13,482 | [
"MIT"
] | 425 | fe4a559b8af3ec93242b24acb4c8e962a00a1248 | https://github.com/ChienHsuan/MMT/tree/fe4a559b8af3ec93242b24acb4c8e962a00a1248 | import torch
from torch import nn
import torch.nn.functional as F
from torch.nn import *
from torch.optim.lr_scheduler import *
def _batch_hard(mat_distance, mat_similarity, indice=False):
sorted_mat_distance, positive_indices = torch.sort(mat_distance + -
9999999.0 * (1 - mat_similarity), dim=1, descendi... |
MeanPoolConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super(CustomConv2d, self).__init__()
self.residual_init = residual_init
if padding is 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ChiragCD/NR-GAN | MeanPoolConv | false | 13,483 | [
"MIT"
] | 54 | fc455c6219b09bc8bf605715504b78b2bb801e48 | https://github.com/ChiragCD/NR-GAN/tree/fc455c6219b09bc8bf605715504b78b2bb801e48 | import torch
import torch.nn as nn
class CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super().__init__()
self.residual_init = residual_init
if padding is None:
padding = int(... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 32, (3, 3))
self.pool1 = nn.MaxPool2d((2, 2))
self.conv2 = nn.Conv2d(32, 32, (3, 3... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | CSCfi/machine-learning-scripts | Net | false | 13,484 | [
"MIT"
] | 59 | 005f9343fb703ca2b6b11b5c2369e19efcaa5f62 | https://github.com/CSCfi/machine-learning-scripts/tree/005f9343fb703ca2b6b11b5c2369e19efcaa5f62 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 32, (3, 3))
self.pool1 = nn.MaxPool2d((2, 2))
self.conv2 = nn.Conv2d(32, 32, (3, 3))
... |
UpSampleConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super(CustomConv2d, self).__init__()
self.residual_init = residual_init
if padding is 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ChiragCD/NR-GAN | UpSampleConv | false | 13,485 | [
"MIT"
] | 54 | fc455c6219b09bc8bf605715504b78b2bb801e48 | https://github.com/ChiragCD/NR-GAN/tree/fc455c6219b09bc8bf605715504b78b2bb801e48 | import torch
import torch.nn as nn
class CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super().__init__()
self.residual_init = residual_init
if padding is None:
padding = int(... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class DiceLoss(nn.Module):
"""
This class implements the dice loss for multiple instances
"""
def __init__(self, smooth_factor: 'float'=1.0) ->None:
super(DiceLoss, self).__init__()
self.smooth_factor = smooth_factor
def __repr__(self):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | ChristophReich1996/Cell-DETR | DiceLoss | false | 13,486 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the dice loss for multiple instances
"""
def __init__(self, smooth_factor: 'float'=1.0) ->None:
super().__init__()
self.smooth_factor = smooth_factor
def __repr__(self):
"""
Get r... |
InstancesAccuracy | # 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 InstancesAccuracy(nn.Module):
"""
This class implements the accuracy computation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
... | 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... | ChristophReich1996/Cell-DETR | InstancesAccuracy | false | 13,487 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the accuracy computation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
... |
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
class FocalLoss(nn.Module):
"""
This class implements the segmentation focal loss.
https://arxiv.org/abs/1708.02002
"""
def __init__(self, alpha: 'float'=0.25, gamma: 'float'=2.0) ->None:
"""
Constructor method
:param alpha: (float) Alpha... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | ChristophReich1996/Cell-DETR | FocalLoss | false | 13,488 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the segmentation focal loss.
https://arxiv.org/abs/1708.02002
"""
def __init__(self, alpha: 'float'=0.25, gamma: 'float'=2.0) ->None:
"""
Constructor method
:param alpha: (float) Alpha con... |
Dice | # 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 Dice(nn.Module):
"""
This class implements the dice score for validation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
""... | 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... | ChristophReich1996/Cell-DETR | Dice | false | 13,489 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the dice score for validation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"... |
IoU | # 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 IoU(nn.Module):
"""
This class implements the IoU for validation. Not gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
... | 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... | ChristophReich1996/Cell-DETR | IoU | false | 13,490 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the IoU for validation. Not gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
... |
ClassificationAccuracy | # 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 ClassificationAccuracy(nn.Module):
"""
This class implements the classification accuracy computation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Thresh... | 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... | ChristophReich1996/Cell-DETR | ClassificationAccuracy | false | 13,491 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the classification accuracy computation. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch.nn.init
class Attention(nn.Module):
def __init__(self, query_size, value_size, hid_size, init_range):
super(Attention, self).__init__()
self.value2hid = nn.Linear(value_size, hid_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.... | Chenny0808/tatk | Attention | false | 13,492 | [
"Apache-2.0"
] | 81 | 1c1a3cb557ba84bbfdbd1f6d8b8ea43ed8b9d7c5 | https://github.com/Chenny0808/tatk/tree/1c1a3cb557ba84bbfdbd1f6d8b8ea43ed8b9d7c5 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch.nn.init
class Model(nn.Module):
def __init__(self, query_size, value_size, hid_size, init_range):
super().__init__()
self.value2hid = nn.Linear(value_size, hid_size)
self.qu... |
KeyValueAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch.nn.init
class KeyValueAttention(nn.Module):
def __init__(self, query_size, key_size, value_size, hid_size, init_range):
super(KeyValueAttention, self).__init__()
self.key2hid = nn.L... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Chenny0808/tatk | KeyValueAttention | false | 13,493 | [
"Apache-2.0"
] | 81 | 1c1a3cb557ba84bbfdbd1f6d8b8ea43ed8b9d7c5 | https://github.com/Chenny0808/tatk/tree/1c1a3cb557ba84bbfdbd1f6d8b8ea43ed8b9d7c5 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch.nn.init
class Model(nn.Module):
def __init__(self, query_size, key_size, value_size, hid_size, init_range):
super().__init__()
self.key2hid = nn.Linear(key_size, hid_size)
s... |
TorchModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
class TorchLinearModule(torch.nn.Module):
def __init__(self, in_size, out_size):
super(TorchLinearModule, self).__init__()
self._linear = torch.nn.Linear(in_size, out_size)
def forward(self, x):
return self._linear(x)
class TorchModule(torch.nn.Module):... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn
ass... | Cher-B/ivy | TorchModule | false | 13,494 | [
"Apache-2.0"
] | 161 | 95273172201071ebf7b83d56bb314450ebe41071 | https://github.com/Cher-B/ivy/tree/95273172201071ebf7b83d56bb314450ebe41071 | import torch
import torch.nn
class TorchLinearModule(torch.nn.Module):
def __init__(self, in_size, out_size):
super().__init__()
self._linear = torch.nn.Linear(in_size, out_size)
def forward(self, x):
return self._linear(x)
class Model(torch.nn.Module):
def __init__(self, in_s... |
Recall | # 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 Recall(nn.Module):
"""
This class implements the recall score. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
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 import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | ChristophReich1996/Cell-DETR | Recall | false | 13,495 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the recall score. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
su... |
Precision | # 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 Precision(nn.Module):
"""
This class implements the precision score. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
... | 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... | ChristophReich1996/Cell-DETR | Precision | false | 13,496 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the precision score. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
... |
MIoU | # 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 MIoU(nn.Module):
"""
This class implements the mean IoU for validation. Not gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""... | 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... | ChristophReich1996/Cell-DETR | MIoU | false | 13,497 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
This class implements the mean IoU for validation. Not gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
""... |
EncoderImage | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
from collections import OrderedDict
import torch.nn as nn
def l2norm(X, dim=-1, eps=1e-08):
"""L2-normalize columns of X"""
norm = torch.pow(X, 2).sum(dim=dim, keepdim=True).sqrt() + eps
X = torch.div(X, norm)
return X
class EncoderImage(nn.Module):
"""
Build ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 numpy as np
... | Chris-cbc/SGRAF | EncoderImage | false | 13,498 | [
"Apache-2.0"
] | 110 | 785535168ad417dda523888f2f047359231fcbf7 | https://github.com/Chris-cbc/SGRAF/tree/785535168ad417dda523888f2f047359231fcbf7 | import torch
import numpy as np
from collections import OrderedDict
import torch.nn as nn
def l2norm(X, dim=-1, eps=1e-08):
"""L2-normalize columns of X"""
norm = torch.pow(X, 2).sum(dim=dim, keepdim=True).sqrt() + eps
X = torch.div(X, norm)
return X
class Model(nn.Module):
"""
Build local r... |
Normalize | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data.distributed
from torch.cuda.amp import autocast as autocast
class Normalize(nn.Module):
def __init__(self, p=2):
super(Normalize, self).__init__()
self.p = p
def forward(self, x):
return F.norma... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
import ... | ChongjianGE/CARE | Normalize | false | 13,499 | [
"MIT"
] | 57 | 3187afb0a2e56d40684bd5a83bf4eda145431e7b | https://github.com/ChongjianGE/CARE/tree/3187afb0a2e56d40684bd5a83bf4eda145431e7b | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data.distributed
from torch.cuda.amp import autocast as autocast
class Model(nn.Module):
def __init__(self, p=2):
super().__init__()
self.p = p
def forward(self, x):
return F.normalize(x, p=self.p, d... |
OptimizedResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super(CustomConv2d, self).__init__()
self.residual_init = residual_init
if padding is 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
import torch.nn as nn
assert_... | ChiragCD/NR-GAN | OptimizedResidualBlock | false | 13,500 | [
"MIT"
] | 54 | fc455c6219b09bc8bf605715504b78b2bb801e48 | https://github.com/ChiragCD/NR-GAN/tree/fc455c6219b09bc8bf605715504b78b2bb801e48 | import torch
import torch.nn as nn
class CustomConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=None, bias=True, residual_init=True):
super().__init__()
self.residual_init = residual_init
if padding is None:
padding = int(... |
F1 | # 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 Recall(nn.Module):
"""
This class implements the recall score. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
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 import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | ChristophReich1996/Cell-DETR | F1 | false | 13,501 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Recall(nn.Module):
"""
This class implements the recall score. No gradients supported.
"""
def __init__(self, threshold: 'float'=0.5) ->None:
"""
Constructor method
:param threshold: (float) Threshold to be applied
"""
s... |
BlendLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BlendLinear(nn.Module):
def __init__(self, dim_in, dim_out, layer_type=nn.Linear, **unused_kwargs):
super(BlendLinear, self).__init__()
self._layer0 = layer_type(dim_in, dim_out)
self._layer1 = layer_type(dim_in, dim_out)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | ClaraBing/ffjord | BlendLinear | false | 13,502 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, dim_in, dim_out, layer_type=nn.Linear, **unused_kwargs):
super().__init__()
self._layer0 = layer_type(dim_in, dim_out)
self._layer1 = layer_type(dim_in, dim_out)
def forward(self, t,... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def conv3x3(in_ch, out_ch, stride=1):
"""3x3 convolution with padding."""
return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)
class ResidualBlock(nn.Module):
"""Simple residual block with two 3x3 convolutions.
Args:
in_ch (int): number... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Chrisa142857/CompressAI | ResidualBlock | false | 13,503 | [
"Apache-2.0"
] | 62 | 75760096b9700a58d346351251d544050f3418fb | https://github.com/Chrisa142857/CompressAI/tree/75760096b9700a58d346351251d544050f3418fb | import torch
import torch.nn as nn
def conv3x3(in_ch, out_ch, stride=1):
"""3x3 convolution with padding."""
return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)
class Model(nn.Module):
"""Simple residual block with two 3x3 convolutions.
Args:
in_ch (int): number of inpu... |
ConcatSquashLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConcatSquashLinear(nn.Module):
def __init__(self, dim_in, dim_out):
super(ConcatSquashLinear, self).__init__()
self._layer = nn.Linear(dim_in, dim_out)
self._hyper_bias = nn.Linear(1, dim_out, bias=False)
self._hyper... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | ClaraBing/ffjord | ConcatSquashLinear | false | 13,504 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, dim_in, dim_out):
super().__init__()
self._layer = nn.Linear(dim_in, dim_out)
self._hyper_bias = nn.Linear(1, dim_out, bias=False)
self._hyper_gate = nn.Linear(1, dim_out)
de... |
FocalLossMultiClass | # 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 FocalLossMultiClass(nn.Module):
"""
Implementation of the multi class focal loss.
https://arxiv.org/abs/1708.02002
"""
def __init__(self, alpha: 'float'=0.25, gamma: 'float'=2.0) ->None:
"""
Constructor method
:param alpha: (float) ... | 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
... | ChristophReich1996/Cell-DETR | FocalLossMultiClass | false | 13,505 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Implementation of the multi class focal loss.
https://arxiv.org/abs/1708.02002
"""
def __init__(self, alpha: 'float'=0.25, gamma: 'float'=2.0) ->None:
"""
Constructor method
:param alpha: (float) Alpha constant... |
ConcatConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConcatConv2d(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False):
super(ConcatConv2d, self).__init__()
module = nn.ConvTranspose2d if transpose else... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | ClaraBing/ffjord | ConcatConv2d | false | 13,506 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False):
super().__init__()
module = nn.ConvTranspose2d if transpose else nn.Conv2d
self._... |
GraphReasoning | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
class GraphReasoning(nn.Module):
"""
Perform the similarity graph reasoning with a full-connected graph
Args: - sim_emb: global and local alignments, shape: (batch_size, L+1, 256)
Returns; - sim_sgr: reasoned graph nodes after several steps, shape:... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Chris-cbc/SGRAF | GraphReasoning | false | 13,507 | [
"Apache-2.0"
] | 110 | 785535168ad417dda523888f2f047359231fcbf7 | https://github.com/Chris-cbc/SGRAF/tree/785535168ad417dda523888f2f047359231fcbf7 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
"""
Perform the similarity graph reasoning with a full-connected graph
Args: - sim_emb: global and local alignments, shape: (batch_size, L+1, 256)
Returns; - sim_sgr: reasoned graph nodes after several steps, shape: (batch_s... |
LayerScaling1d | # 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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class LayerScaling1d(nn.Module):
"""Scales inputs by the root of the second moment for groups.
.. math::
y_g = \\frac{x_g}{\\sqrt{\\mathrm{E}[x_g^2] + \\epsil... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.... | ClashLuke/online-normalization | LayerScaling1d | false | 13,508 | [
"BSD-3-Clause"
] | 55 | fe08b9f8e288d628eee4f9991e562cdb4f9e997b | https://github.com/ClashLuke/online-normalization/tree/fe08b9f8e288d628eee4f9991e562cdb4f9e997b | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
"""Scales inputs by the root of the second moment for groups.
.. math::
y_g = \\frac{x_g}{\\sqrt{\\mathrm{E}[x_g^2] + \\epsilon}}
... |
ConcatSquashConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConcatSquashConv2d(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False):
super(ConcatSquashConv2d, self).__init__()
module = nn.ConvTranspose2d if tr... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | ClaraBing/ffjord | ConcatSquashConv2d | false | 13,509 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False):
super().__init__()
module = nn.ConvTranspose2d if transpose else nn.Conv2d
self._... |
BlendConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BlendConv2d(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False, **unused_kwargs):
super(BlendConv2d, self).__init__()
module = nn.ConvTranspose2d if... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | ClaraBing/ffjord | BlendConv2d | false | 13,510 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, dim_in, dim_out, ksize=3, stride=1, padding=0,
dilation=1, groups=1, bias=True, transpose=False, **unused_kwargs):
super().__init__()
module = nn.ConvTranspose2d if transpose else nn.Conv... |
ActivationClamp | # 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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class ActivationClamp(nn.Module):
"""Clips the output of CN.
.. math::
y = clip(x, -clamp_value, clamp_value)
Args:
clamp_value: the value to which a... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data... | ClashLuke/online-normalization | ActivationClamp | false | 13,511 | [
"BSD-3-Clause"
] | 55 | fe08b9f8e288d628eee4f9991e562cdb4f9e997b | https://github.com/ClashLuke/online-normalization/tree/fe08b9f8e288d628eee4f9991e562cdb4f9e997b | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
"""Clips the output of CN.
.. math::
y = clip(x, -clamp_value, clamp_value)
Args:
clamp_value: the value to which activations... |
ClippedLinearQuantization | # 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.optim.lr_scheduler import *
import torch.optim
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
import torch.onnx
def linear_dequantize(input, scale_factor, inplace=False):
if inplace:
input.div_(scale_factor)
return input
return input / scale_fact... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch.optim.lr_schedule... | Chih-Ling-Hsu/distiller | ClippedLinearQuantization | false | 13,512 | [
"Apache-2.0"
] | 94 | 33d1697298c6e3a7f7bfa615741fd0cda61d2794 | https://github.com/Chih-Ling-Hsu/distiller/tree/33d1697298c6e3a7f7bfa615741fd0cda61d2794 | import torch
from torch.optim.lr_scheduler import *
import torch.optim
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
import torch.onnx
def linear_dequantize(input, scale_factor, inplace=False):
if inplace:
input.div_(scale_factor)
return input
return input / scale_fact... |
MultiClassSegmentationLoss | # 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.autograd import Variable
class DiceLoss(nn.Module):
"""
This class implements the dice loss for multiple instances
"""
def __init__(self, smooth_factor: 'float'=1.0) ->None:
super(DiceLoss, self).__init__()
self.smooth_factor = smooth_fact... | 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
... | ChristophReich1996/Cell-DETR | MultiClassSegmentationLoss | false | 13,513 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import torch.nn as nn
from torch.autograd import Variable
class DiceLoss(nn.Module):
"""
This class implements the dice loss for multiple instances
"""
def __init__(self, smooth_factor: 'float'=1.0) ->None:
super().__init__()
self.smooth_factor = smooth_factor
def __... |
GatedConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GatedConv(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, groups=1):
super(GatedConv, self).__init__()
self.layer_f = nn.Conv2d(in_channels, out_channels, kernel_size,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | ClaraBing/ffjord | GatedConv | false | 13,514 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, groups=1):
super().__init__()
self.layer_f = nn.Conv2d(in_channels, out_channels, kernel_size,
stride=stride, padd... |
LayerScaling | # 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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class LayerScaling(nn.Module):
"""Scales inputs by the root of the second moment for groups of channels.
.. math::
y_g = \\frac{x_g}{\\sqrt{\\mathrm{E}[x_g^2]... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.... | ClashLuke/online-normalization | LayerScaling | false | 13,515 | [
"BSD-3-Clause"
] | 55 | fe08b9f8e288d628eee4f9991e562cdb4f9e997b | https://github.com/ClashLuke/online-normalization/tree/fe08b9f8e288d628eee4f9991e562cdb4f9e997b | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
"""Scales inputs by the root of the second moment for groups of channels.
.. math::
y_g = \\frac{x_g}{\\sqrt{\\mathrm{E}[x_g^2] + \\ep... |
HyperConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Linear') != -1 or classname.find('Conv') != -1:
nn.init.constant_(m.weight, 0)
nn.init.normal_(m.bias, 0, 0.01)
class HyperConv2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
as... | ClaraBing/ffjord | HyperConv2d | false | 13,516 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Linear') != -1 or classname.find('Conv') != -1:
nn.init.constant_(m.weight, 0)
nn.init.normal_(m.bias, 0, 0.01)
class Model(nn.M... |
QuickGELU | # 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 QuickGELU(nn.Module):
def forward(self, x: 'torch.Tensor'):
return x * torch.sigmoid(1.702 * x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | CryhanFang/CLIP2Video | QuickGELU | false | 13,517 | [
"MIT"
] | 113 | e94131800a3a1434f6d00b89b7301d741db8ba06 | https://github.com/CryhanFang/CLIP2Video/tree/e94131800a3a1434f6d00b89b7301d741db8ba06 | import torch
from torch import nn
class Model(nn.Module):
def forward(self, x: 'torch.Tensor'):
return x * torch.sigmoid(1.702 * x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
Snake | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Snake(nn.Module):
""" Implementation of the snake activation function as a torch nn module
The result of the activation function a(x) is calculated by a(x) = x + sin^2(x)
With alpha is a trainab
"""
def __init__(self, frequency=10):
"""Constructor... | 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... | ComputationalRadiationPhysics/NeuralSolvers | Snake | false | 13,518 | [
"MIT"
] | 59 | cc62b5a91d9eb70ffafdcca6d1fbba16d3bf588d | https://github.com/ComputationalRadiationPhysics/NeuralSolvers/tree/cc62b5a91d9eb70ffafdcca6d1fbba16d3bf588d | import torch
import torch.nn as nn
class Model(nn.Module):
""" Implementation of the snake activation function as a torch nn module
The result of the activation function a(x) is calculated by a(x) = x + sin^2(x)
With alpha is a trainab
"""
def __init__(self, frequency=10):
"""Constructor... |
PADEACTIVATION_Function_based | # 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
from numpy.random.mtrand import RandomState
def get_constants_for_inits(name, seed=17):
if name == 'pade_sigmoid_3':
return (1 / 2, 1 / 4, 1 / 20, 1 / 240), (0.0, 1 / 10), (0,)
elif name == 'pade_sigmoid_5':
return (1 / 2, 1 / 4, 17 / 336, ... | 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 numpy as np
import torch.nn as nn
from numpy.random.mtrand import ... | ChristophReich1996/Cell-DETR | PADEACTIVATION_Function_based | false | 13,519 | [
"MIT"
] | 55 | 4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | https://github.com/ChristophReich1996/Cell-DETR/tree/4d0c3a2d3ffd19184c8443e5b3a6dccc053c77ea | import torch
import numpy as np
import torch.nn as nn
from numpy.random.mtrand import RandomState
def get_constants_for_inits(name, seed=17):
if name == 'pade_sigmoid_3':
return (1 / 2, 1 / 4, 1 / 20, 1 / 240), (0.0, 1 / 10), (0,)
elif name == 'pade_sigmoid_5':
return (1 / 2, 1 / 4, 17 / 336, ... |
GatedConvTranspose | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GatedConvTranspose(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, output_padding=0, groups=1):
super(GatedConvTranspose, self).__init__()
self.layer_f = nn.ConvTranspose2d(in_chan... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | ClaraBing/ffjord | GatedConvTranspose | false | 13,520 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, output_padding=0, groups=1):
super().__init__()
self.layer_f = nn.ConvTranspose2d(in_channels, out_channels,
kerne... |
GatedLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GatedLinear(nn.Module):
def __init__(self, in_features, out_features):
super(GatedLinear, self).__init__()
self.layer_f = nn.Linear(in_features, out_features)
self.layer_g = nn.Linear(in_features, out_features)
def forw... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | ClaraBing/ffjord | GatedLinear | false | 13,521 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_features, out_features):
super().__init__()
self.layer_f = nn.Linear(in_features, out_features)
self.layer_g = nn.Linear(in_features, out_features)
def forward(self, x):
f... |
BasicBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BasicBlock(nn.Module):
expansion = 1
def __init__(self, dim):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, padding=1, bias=False)
self.bn1 = nn.GroupNorm(2, dim, eps=0.0001)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | ClaraBing/ffjord | BasicBlock | false | 13,522 | [
"MIT"
] | 518 | a97c34ff546a063316828f53bd041555e663428d | https://github.com/ClaraBing/ffjord/tree/a97c34ff546a063316828f53bd041555e663428d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
expansion = 1
def __init__(self, dim):
super().__init__()
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, padding=1, bias=False)
self.bn1 = nn.GroupNorm(2, dim, eps=0.0001)
self.relu = nn.ReLU(i... |
ConvModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def kaiming_init(module, mode='fan_out', nonlinearity='relu', bias=0,
distribution='normal'):
assert distribution in ['uniform', 'normal']
if distribution == 'uniform':
nn.init.kaiming_uniform_(module.weight, mode=mode, nonlinearity=
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 warnings
import torch.... | CrazySherman/mmdetection | ConvModule | false | 13,523 | [
"Apache-2.0"
] | 82 | 3ba66ef0d377086996d2765f1cec3aa3577039aa | https://github.com/CrazySherman/mmdetection/tree/3ba66ef0d377086996d2765f1cec3aa3577039aa | import torch
import warnings
import torch.nn as nn
def kaiming_init(module, mode='fan_out', nonlinearity='relu', bias=0,
distribution='normal'):
assert distribution in ['uniform', 'normal']
if distribution == 'uniform':
nn.init.kaiming_uniform_(module.weight, mode=mode, nonlinearity=
n... |
PriorDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class PriorDiscriminator(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.l0 = nn.Linear(input_dim, input_dim)
self.l1 = nn.Linear(input_dim, input_dim)
self.l2 = nn.Linear(input_dim, 1)
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._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Crazy-Jack/HCL | PriorDiscriminator | false | 13,524 | [
"MIT"
] | 275 | dd2aae0c525859c8498205a791058287f86ab111 | https://github.com/Crazy-Jack/HCL/tree/dd2aae0c525859c8498205a791058287f86ab111 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.l0 = nn.Linear(input_dim, input_dim)
self.l1 = nn.Linear(input_dim, input_dim)
self.l2 = nn.Linear(input_dim, 1)
def forward(self,... |
ArgsNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ArgsNet(nn.Module):
def __init__(self, input_size, hidden_size):
super(ArgsNet, self).__init__()
self.hidden_size = hidden_size
self.input_size = input_size
self.gru = nn.GRUCell(self.input_size, self.hidden_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | ConstantinHvber/ilf | ArgsNet | false | 13,525 | [
"Apache-2.0"
] | 84 | b706f81191508998d443c1c89e8d10028ce4e5d8 | https://github.com/ConstantinHvber/ilf/tree/b706f81191508998d443c1c89e8d10028ce4e5d8 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size, hidden_size):
super().__init__()
self.hidden_size = hidden_size
self.input_size = input_size
self.gru = nn.GRUCell(self.input_size, self.hidden_size)
s... |
_BoundaryRefineModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 _BoundaryRefineModule(nn.Module):
def __init__(self, dim):
super(_BoundaryRefineModule, self).__init__()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(dim, dim, kernel_siz... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | CuthbertCai/pytorch-semantic-segmentation | _BoundaryRefineModule | false | 13,526 | [
"MIT"
] | 1,328 | aa2a47b73c1aa14555e1421e2366275254ea5376 | https://github.com/CuthbertCai/pytorch-semantic-segmentation/tree/aa2a47b73c1aa14555e1421e2366275254ea5376 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(dim, dim, kernel_size=3, padding=1)
def forward(self, x):
... |
CrossEn | # 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 CrossEn(nn.Module):
"""cross entroy loss"""
def __init__(self):
super(CrossEn, self).__init__()
def forward(self, sim_matrix):
logpt = F.log_softmax(sim_matrix, dim=-1)
logpt = torch.diag(logpt)
nce_l... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | CryhanFang/CLIP2Video | CrossEn | false | 13,527 | [
"MIT"
] | 113 | e94131800a3a1434f6d00b89b7301d741db8ba06 | https://github.com/CryhanFang/CLIP2Video/tree/e94131800a3a1434f6d00b89b7301d741db8ba06 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""cross entroy loss"""
def __init__(self):
super().__init__()
def forward(self, sim_matrix):
logpt = F.log_softmax(sim_matrix, dim=-1)
logpt = torch.diag(logpt)
nce_loss = -logpt
... |
Unfold | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class Unfold(torch.nn.Module):
"""Module for unfolding tensor.
Performs strided crops on 2d (image) tensors. Stride is assumed to be half the crop size.
"""
def __init__(self, img_size, fold_size):
"""
Args:
img_size: Input size.
fold_size: Crop... | 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
reinterpret... | Crazy-Jack/HCL | Unfold | false | 13,528 | [
"MIT"
] | 275 | dd2aae0c525859c8498205a791058287f86ab111 | https://github.com/Crazy-Jack/HCL/tree/dd2aae0c525859c8498205a791058287f86ab111 | import torch
class Model(torch.nn.Module):
"""Module for unfolding tensor.
Performs strided crops on 2d (image) tensors. Stride is assumed to be half the crop size.
"""
def __init__(self, img_size, fold_size):
"""
Args:
img_size: Input size.
fold_size: Crop ... |
Vgg16 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Vgg16(nn.Module):
def __init__(self):
super(Vgg16, self).__init__()
self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
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_... | Boyiliee/PONO | Vgg16 | false | 13,529 | [
"MIT"
] | 133 | b9108e8bf8ba0228635532ba5bdc973b7393d045 | https://github.com/Boyiliee/PONO/tree/b9108e8bf8ba0228635532ba5bdc973b7393d045 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
self.conv2_1 =... |
ImgLayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
import torch.nn
import torch.utils.data
class ImgLayerNorm(Module):
"""
LayerNorm for images with channel axis 1
(this is necessary because PyTorch's LayerNorm operates on the last axis)
"""
def __init__(self, in_dim, eps=1e-05):
super().__init__()... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch.nn import Module
import torch.nn
import torch.utils.data
assert_size... | CrhistyanSilva/localbitsback | ImgLayerNorm | false | 13,530 | [
"MIT"
] | 100 | bdf66b41b2120c5b35edac4e4efda0fda3f2db4d | https://github.com/CrhistyanSilva/localbitsback/tree/bdf66b41b2120c5b35edac4e4efda0fda3f2db4d | from torch.nn import Module
import torch
import torch.nn
import torch.utils.data
class Model(Module):
"""
LayerNorm for images with channel axis 1
(this is necessary because PyTorch's LayerNorm operates on the last axis)
"""
def __init__(self, in_dim, eps=1e-05):
super().__init__()
... |
L1Loss | # 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 functools
import torch
import torch.nn.functional as F
import torch.nn as nn
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss ten... | 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 functools
impor... | CvlabAssignment/AlignPS | L1Loss | false | 13,531 | [
"Apache-2.0"
] | 144 | 297f4166921d2095f9381e38e04129a103069406 | https://github.com/CvlabAssignment/AlignPS/tree/297f4166921d2095f9381e38e04129a103069406 | import functools
import torch
import torch.nn.functional as F
import torch.nn as nn
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss ten... |
Fusion | # 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 Fusion(nn.Module):
""" Crazy multi-modal fusion: negative squared difference minus relu'd sum
"""
def __init__(self):
super().__init__()
def forward(self, x, y):
return -(x - y) ** 2 + F.... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | Cyanogenoid/vqa-counting | Fusion | false | 13,532 | [
"MIT"
] | 205 | 4042b1295ae2f648670e8c1baef8581be0346da2 | https://github.com/Cyanogenoid/vqa-counting/tree/4042b1295ae2f648670e8c1baef8581be0346da2 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
""" Crazy multi-modal fusion: negative squared difference minus relu'd sum
"""
def __init__(self):
super().__init__()
def forward(self, x, y):
return -(x - y) ** 2 + F.r... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.