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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
RepresentationSubspaceDistance | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class RepresentationSubspaceDistance(nn.Module):
"""
`Representation Subspace Distance (ICML 2021) <http://ise.thss.tsinghua.edu.cn/~mlong/doc/Representation-Subspace-Distance-for-Domain-Adaptation-Regression-icml21.pdf>`_
Args:
trade_off... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
im... | neka-nat/Transfer-Learning-Library | RepresentationSubspaceDistance | false | 16,161 | [
"MIT"
] | 1,474 | a3b27b0d7562fa90a02e914140b37ab438469e6c | https://github.com/neka-nat/Transfer-Learning-Library/tree/a3b27b0d7562fa90a02e914140b37ab438469e6c | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
`Representation Subspace Distance (ICML 2021) <http://ise.thss.tsinghua.edu.cn/~mlong/doc/Representation-Subspace-Distance-for-Domain-Adaptation-Regression-icml21.pdf>`_
Args:
trade_off (float): The trade-off ... |
CMul | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn
import torch.nn as nn
import torch.nn.parallel
class CMul(nn.Module):
"""
nn.CMul in Torch7.
"""
def __init__(self):
super(CMul, self).__init__()
def forward(self, x):
return x[0] * x[1]
def __repr__(self):
return self.__class__.__name__
... | 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
import torch.nn as nn
import torch.nn.parallel
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided... | nhonth/DeLF-pytorch | CMul | false | 16,162 | [
"MIT"
] | 315 | 5577a447a0330b9e976cff56a10fc91669216b8c | https://github.com/nhonth/DeLF-pytorch/tree/5577a447a0330b9e976cff56a10fc91669216b8c | import torch
import torch.nn
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
"""
nn.CMul in Torch7.
"""
def __init__(self):
super().__init__()
def forward(self, x):
return x[0] * x[1]
def __repr__(self):
return self.__class__.__name__
def get... |
BesselBasis | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.jit
import torch.nn.functional
from torch import nn
import torch.nn
import torch.utils.data
class BesselBasis(nn.Module):
r_max: 'float'
prefactor: 'float'
def __init__(self, r_max, num_basis=8, trainable=True):
"""Radial Bessel Basis, as proposed in DimeNet:... | 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 math
import torch.jit
import torch.nn.functional
from torch import... | mir-group/nequip | BesselBasis | false | 16,163 | [
"MIT"
] | 153 | 4e6a0914a289cf000da57a6b6e79678efdf3347f | https://github.com/mir-group/nequip/tree/4e6a0914a289cf000da57a6b6e79678efdf3347f | import math
import torch
import torch.jit
import torch.nn.functional
from torch import nn
import torch.nn
import torch.utils.data
class Model(nn.Module):
r_max: 'float'
prefactor: 'float'
def __init__(self, r_max, num_basis=8, trainable=True):
"""Radial Bessel Basis, as proposed in DimeNet: https... |
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 as nn
import torch.nn.functional as F
import torch.optim
class PriorDiscriminator(nn.Module):
"""The prior discriminator class.
This discriminate between a vector drawn from random uniform,
and the vector y obtained as output of the encoder.
It enforces y to be close to a... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | neuralsyn/self-supervised-relational-reasoning | PriorDiscriminator | false | 16,164 | [
"MIT"
] | 130 | 6ecfafcf4a36c2eacef7ddd5bd1b23c28fbb14c8 | https://github.com/neuralsyn/self-supervised-relational-reasoning/tree/6ecfafcf4a36c2eacef7ddd5bd1b23c28fbb14c8 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
"""The prior discriminator class.
This discriminate between a vector drawn from random uniform,
and the vector y obtained as output of the encoder.
It enforces y to be close to a uniform dist... |
MaskedMSE | # 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 MaskedMSE(nn.Module):
def __init__(self):
super(MaskedMSE, self).__init__()
self.criterion = nn.MSELoss()
def forward(self, input, target, mask):
self.loss = self.criterion(input, target * mask)
return self.loss
def get_inputs():
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | ngerstle/soccerontable | MaskedMSE | false | 16,165 | [
"BSD-2-Clause"
] | 465 | 25426ff0f8fe0ce008b99c5c0fdbb35091d8d92c | https://github.com/ngerstle/soccerontable/tree/25426ff0f8fe0ce008b99c5c0fdbb35091d8d92c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.criterion = nn.MSELoss()
def forward(self, input, target, mask):
self.loss = self.criterion(input, target * mask)
return self.loss
def get_inputs():
return [torch.rand... |
MaskedBCE | # 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 MaskedBCE(nn.Module):
def __init__(self):
super(MaskedBCE, self).__init__()
self.criterion = nn.BCELoss()
def forward(self, input, target, mask):
self.loss = self.criterion(input, target * mask)
return self.loss
def get_inputs():
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | ngerstle/soccerontable | MaskedBCE | false | 16,166 | [
"BSD-2-Clause"
] | 465 | 25426ff0f8fe0ce008b99c5c0fdbb35091d8d92c | https://github.com/ngerstle/soccerontable/tree/25426ff0f8fe0ce008b99c5c0fdbb35091d8d92c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.criterion = nn.BCELoss()
def forward(self, input, target, mask):
self.loss = self.criterion(input, target * mask)
return self.loss
def get_inputs():
return [torch.rand... |
PSAModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1,
dilation=1, groups=1):
"""standard convolution with padding"""
return nn.Conv2d(in_planes, out_plane... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | murufeng/EPSANet | PSAModule | false | 16,167 | [
"MIT"
] | 120 | 9955041a1db4591fae080d2e6edb25e2a2914d47 | https://github.com/murufeng/EPSANet/tree/9955041a1db4591fae080d2e6edb25e2a2914d47 | import torch
from torch import nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1,
dilation=1, groups=1):
"""standard convolution with padding"""
return nn.Conv2d(in_planes, out_plane... |
TripletLossXBM | # 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 torchvision.transforms.functional as F
import torch.utils.data
def hard_examples_mining(dist_mat, identity_mat, return_idxes=False):
"""Select hard positives and hard negatives according to `In defense of the Triplet Loss for Person
Re-... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | neka-nat/Transfer-Learning-Library | TripletLossXBM | false | 16,168 | [
"MIT"
] | 1,474 | a3b27b0d7562fa90a02e914140b37ab438469e6c | https://github.com/neka-nat/Transfer-Learning-Library/tree/a3b27b0d7562fa90a02e914140b37ab438469e6c | import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms.functional as F
import torch.utils.data
def hard_examples_mining(dist_mat, identity_mat, return_idxes=False):
"""Select hard positives and hard negatives according to `In defense of the Triplet Loss for Person
Re-... |
FeatExemplarAvgBlock | # 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.optim
import torch.nn.parallel
class FeatExemplarAvgBlock(nn.Module):
def __init__(self, nFeat):
super(FeatExemplarAvgBlock, self).__init__()
def forward(self, features_train, labels_train):
labels_train_transposed = labels_train.transpose(1, 2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.optim
import torch.nn.parallel
assert_size_st... | nikran1/Few_shot | FeatExemplarAvgBlock | false | 16,169 | [
"MIT"
] | 497 | 5298c98e208411e44ee7767e6f4d457006d373cb | https://github.com/nikran1/Few_shot/tree/5298c98e208411e44ee7767e6f4d457006d373cb | import torch
import torch.nn as nn
import torch.optim
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, nFeat):
super().__init__()
def forward(self, features_train, labels_train):
labels_train_transposed = labels_train.transpose(1, 2)
weight_novel = torch.bmm(labels... |
ResidualConnection | # 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 ResidualConnection(nn.Module):
def __init__(self, alpha=0.5):
super(ResidualConnection, self).__init__()
self.alpha = alpha
def forward(self, Xs: 'list'):
assert len(Xs) >= 1
return Xs[-1] if len(Xs) == 1 else (1 - self.alpha) * Xs[-1
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | ngohienduong/Deep_GCN_Benchmarking | ResidualConnection | false | 16,170 | [
"MIT"
] | 70 | 3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | https://github.com/ngohienduong/Deep_GCN_Benchmarking/tree/3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, alpha=0.5):
super().__init__()
self.alpha = alpha
def forward(self, Xs: 'list'):
assert len(Xs) >= 1
return Xs[-1] if len(Xs) == 1 else (1 - self.alpha) * Xs[-1
] + self.alpha * Xs[-2]
... |
mean_norm | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class mean_norm(torch.nn.Module):
def __init__(self):
super(mean_norm, self).__init__()
def forward(self, x):
col_mean = x.mean(dim=0)
x = x - col_mean
return x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | ngohienduong/Deep_GCN_Benchmarking | mean_norm | false | 16,171 | [
"MIT"
] | 70 | 3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | https://github.com/ngohienduong/Deep_GCN_Benchmarking/tree/3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
col_mean = x.mean(dim=0)
x = x - col_mean
return x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
LocalDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class LocalDiscriminator(nn.Module):
"""The local discriminator class.
A network that analyses the relation between the
output of the encoder y, and the feature map M.
It is called "local" because it compares y with... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | neuralsyn/self-supervised-relational-reasoning | LocalDiscriminator | false | 16,172 | [
"MIT"
] | 130 | 6ecfafcf4a36c2eacef7ddd5bd1b23c28fbb14c8 | https://github.com/neuralsyn/self-supervised-relational-reasoning/tree/6ecfafcf4a36c2eacef7ddd5bd1b23c28fbb14c8 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
"""The local discriminator class.
A network that analyses the relation between the
output of the encoder y, and the feature map M.
It is called "local" because it compares y with
each one... |
LinearDiag | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.optim
import torch.nn.parallel
class LinearDiag(nn.Module):
def __init__(self, num_features, bias=False):
super(LinearDiag, self).__init__()
weight = torch.FloatTensor(num_features).fill_(1)
self.weight = nn.Parameter(weight, requires_grad=T... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.optim
import torch.nn.parallel
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_stri... | nikran1/Few_shot | LinearDiag | false | 16,173 | [
"MIT"
] | 497 | 5298c98e208411e44ee7767e6f4d457006d373cb | https://github.com/nikran1/Few_shot/tree/5298c98e208411e44ee7767e6f4d457006d373cb | import torch
import torch.nn as nn
import torch.optim
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, num_features, bias=False):
super().__init__()
weight = torch.FloatTensor(num_features).fill_(1)
self.weight = nn.Parameter(weight, requires_grad=True)
if bias:... |
node_norm | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class node_norm(torch.nn.Module):
def __init__(self, node_norm_type='n', unbiased=False, eps=1e-05,
power_root=2, **kwargs):
super(node_norm, self).__init__()
self.unbiased = unbiased
self.eps = eps
self.node_norm_type = node_norm_type
self.power = 1 /... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | ngohienduong/Deep_GCN_Benchmarking | node_norm | false | 16,174 | [
"MIT"
] | 70 | 3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | https://github.com/ngohienduong/Deep_GCN_Benchmarking/tree/3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | import torch
class Model(torch.nn.Module):
def __init__(self, node_norm_type='n', unbiased=False, eps=1e-05,
power_root=2, **kwargs):
super().__init__()
self.unbiased = unbiased
self.eps = eps
self.node_norm_type = node_norm_type
self.power = 1 / power_root
de... |
InitialConnection | # 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 InitialConnection(nn.Module):
def __init__(self, alpha=0.5):
super(InitialConnection, self).__init__()
self.alpha = alpha
def forward(self, Xs: 'list'):
assert len(Xs) >= 1
return Xs[-1] if len(Xs) == 1 else (1 - self.alpha) * Xs[-1
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | ngohienduong/Deep_GCN_Benchmarking | InitialConnection | false | 16,175 | [
"MIT"
] | 70 | 3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | https://github.com/ngohienduong/Deep_GCN_Benchmarking/tree/3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, alpha=0.5):
super().__init__()
self.alpha = alpha
def forward(self, Xs: 'list'):
assert len(Xs) >= 1
return Xs[-1] if len(Xs) == 1 else (1 - self.alpha) * Xs[-1
] + self.alpha * Xs[0]
d... |
MaskedSmoothL1 | # 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 MaskedSmoothL1(nn.Module):
def __init__(self):
super(MaskedSmoothL1, self).__init__()
self.criterion = nn.SmoothL1Loss(size_average=True)
def forward(self, input, target, mask):
self.loss = self.criterion(input, target * mask)
return 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
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | ngerstle/soccerontable | MaskedSmoothL1 | false | 16,176 | [
"BSD-2-Clause"
] | 465 | 25426ff0f8fe0ce008b99c5c0fdbb35091d8d92c | https://github.com/ngerstle/soccerontable/tree/25426ff0f8fe0ce008b99c5c0fdbb35091d8d92c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.criterion = nn.SmoothL1Loss(size_average=True)
def forward(self, input, target, mask):
self.loss = self.criterion(input, target * mask)
return self.loss
def get_inputs():
... |
Unet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, dropout=False, norm=
'batch', residual=True, activation='leakyrelu', transpose=False):
super(ConvBlock, self).__init__()
self.dropout = dropout
self.residual = residual
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | mlepori1/noise2self | Unet | false | 16,177 | [
"MIT"
] | 257 | 78cbda2d0f62973f1ba0232bd48a941307cf78f9 | https://github.com/mlepori1/noise2self/tree/78cbda2d0f62973f1ba0232bd48a941307cf78f9 | import torch
import torch.nn as nn
class ConvBlock(nn.Module):
def __init__(self, in_channels, out_channels, dropout=False, norm=
'batch', residual=True, activation='leakyrelu', transpose=False):
super().__init__()
self.dropout = dropout
self.residual = residual
self.activ... |
AconC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 AconC(nn.Module):
""" ACON activation (activate or not).
# AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
# according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
"""
def... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | nmaac/acon | AconC | false | 16,178 | [
"MIT"
] | 163 | 99fd67928a6ffb0543b54614303caada96c756f5 | https://github.com/nmaac/acon/tree/99fd67928a6ffb0543b54614303caada96c756f5 | import torch
import torch.nn as nn
class Model(nn.Module):
""" ACON activation (activate or not).
# AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
# according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
"""
def... |
Keypoint2DLoss | # 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 Keypoint2DLoss(nn.Module):
def __init__(self, loss_type: 'str'='l1'):
"""
2D keypoint loss module.
Args:
loss_type (str): Choose between l1 and l2 losses.
"""
super(Keypoint2DLoss, self).__init__()
if loss_type =... | 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... | nkolot/ProHMR | Keypoint2DLoss | false | 16,179 | [
"BSD-3-Clause"
] | 120 | dac2409c0b451b6dd5d91f03cbe7132aa495792f | https://github.com/nkolot/ProHMR/tree/dac2409c0b451b6dd5d91f03cbe7132aa495792f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, loss_type: 'str'='l1'):
"""
2D keypoint loss module.
Args:
loss_type (str): Choose between l1 and l2 losses.
"""
super().__init__()
if loss_type == 'l1':
self.loss... |
MatchingNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.optim
import torch.nn.functional as F
import torch.nn.parallel
class MatchingNetwork(nn.Module):
def __init__(self, opt):
super(MatchingNetwork, self).__init__()
scale_cls = opt['scale_cls'] if 'scale_cl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | nikran1/Few_shot | MatchingNetwork | false | 16,180 | [
"MIT"
] | 497 | 5298c98e208411e44ee7767e6f4d457006d373cb | https://github.com/nikran1/Few_shot/tree/5298c98e208411e44ee7767e6f4d457006d373cb | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.optim
import torch.nn.functional as F
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, opt):
super().__init__()
scale_cls = opt['scale_cls'] if 'scale_cls' in opt else 10.0
sel... |
NormalizeScaleController | # 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 ScaleControllerBase(torch.nn.Module):
"""
The base class for ScaleController.
ScaleController is a callable class that re-scale input tensor's value.
Traditional scale method may include:
soft-max, L2 normalize, relu and so on.
Advanced method:
Learnable scale pa... | 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
assert_size_stride = t... | niloofar17/MetaDialog | NormalizeScaleController | false | 16,181 | [
"Apache-2.0"
] | 204 | d75b84a02807d53d9596e72c2f698e5a4f180369 | https://github.com/niloofar17/MetaDialog/tree/d75b84a02807d53d9596e72c2f698e5a4f180369 | import torch
class ScaleControllerBase(torch.nn.Module):
"""
The base class for ScaleController.
ScaleController is a callable class that re-scale input tensor's value.
Traditional scale method may include:
soft-max, L2 normalize, relu and so on.
Advanced method:
Learnable scale pa... |
ParameterLoss | # 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 ParameterLoss(nn.Module):
def __init__(self):
"""
SMPL parameter loss module.
"""
super(ParameterLoss, self).__init__()
self.loss_fn = nn.MSELoss(reduction='none')
def forward(self, pred_param: 'torch.Tensor', gt_param: 'torch.... | 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... | nkolot/ProHMR | ParameterLoss | false | 16,182 | [
"BSD-3-Clause"
] | 120 | dac2409c0b451b6dd5d91f03cbe7132aa495792f | https://github.com/nkolot/ProHMR/tree/dac2409c0b451b6dd5d91f03cbe7132aa495792f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
"""
SMPL parameter loss module.
"""
super().__init__()
self.loss_fn = nn.MSELoss(reduction='none')
def forward(self, pred_param: 'torch.Tensor', gt_param: 'torch.Tensor',
has_param:... |
Keypoint3DLoss | # 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 Keypoint3DLoss(nn.Module):
def __init__(self, loss_type: 'str'='l1'):
"""
3D keypoint loss module.
Args:
loss_type (str): Choose between l1 and l2 losses.
"""
super(Keypoint3DLoss, self).__init__()
if loss_type =... | 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... | nkolot/ProHMR | Keypoint3DLoss | false | 16,183 | [
"BSD-3-Clause"
] | 120 | dac2409c0b451b6dd5d91f03cbe7132aa495792f | https://github.com/nkolot/ProHMR/tree/dac2409c0b451b6dd5d91f03cbe7132aa495792f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, loss_type: 'str'='l1'):
"""
3D keypoint loss module.
Args:
loss_type (str): Choose between l1 and l2 losses.
"""
super().__init__()
if loss_type == 'l1':
self.loss... |
pair_norm | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class pair_norm(torch.nn.Module):
def __init__(self):
super(pair_norm, self).__init__()
def forward(self, x):
col_mean = x.mean(dim=0)
x = x - col_mean
rownorm_mean = (1e-06 + x.pow(2).sum(dim=1).mean()).sqrt()
x = x / rownorm_mean
return x
def ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | ngohienduong/Deep_GCN_Benchmarking | pair_norm | false | 16,184 | [
"MIT"
] | 70 | 3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | https://github.com/ngohienduong/Deep_GCN_Benchmarking/tree/3ee57a265bbfd62d8e6f3ee6e3e9062dd5a44633 | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
col_mean = x.mean(dim=0)
x = x - col_mean
rownorm_mean = (1e-06 + x.pow(2).sum(dim=1).mean()).sqrt()
x = x / rownorm_mean
return x
def get_inputs():
r... |
PrototypicalNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.optim
import torch.nn.parallel
def L2SquareDist(A, B, average=True):
assert A.dim() == 3
assert B.dim() == 3
assert A.size(0) == B.size(0) and A.size(2) == B.size(2)
nB = A.size(0)
Na = A.size(1)
Nb =... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.optim
import torch.nn.parallel
assert_size_st... | nikran1/Few_shot | PrototypicalNetwork | false | 16,185 | [
"MIT"
] | 497 | 5298c98e208411e44ee7767e6f4d457006d373cb | https://github.com/nikran1/Few_shot/tree/5298c98e208411e44ee7767e6f4d457006d373cb | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.optim
import torch.nn.parallel
def L2SquareDist(A, B, average=True):
assert A.dim() == 3
assert B.dim() == 3
assert A.size(0) == B.size(0) and A.size(2) == B.size(2)
nB = A.size(0)
Na = A.size(1)
Nb =... |
FixedScaleController | # 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 ScaleControllerBase(torch.nn.Module):
"""
The base class for ScaleController.
ScaleController is a callable class that re-scale input tensor's value.
Traditional scale method may include:
soft-max, L2 normalize, relu and so on.
Advanced method:
Learnable scale pa... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | niloofar17/MetaDialog | FixedScaleController | false | 16,186 | [
"Apache-2.0"
] | 204 | d75b84a02807d53d9596e72c2f698e5a4f180369 | https://github.com/niloofar17/MetaDialog/tree/d75b84a02807d53d9596e72c2f698e5a4f180369 | import torch
class ScaleControllerBase(torch.nn.Module):
"""
The base class for ScaleController.
ScaleController is a callable class that re-scale input tensor's value.
Traditional scale method may include:
soft-max, L2 normalize, relu and so on.
Advanced method:
Learnable scale pa... |
UpsampleNet | # 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 SqueezeLayer(nn.Module):
def __init__(self, factor):
super(SqueezeLayer, self).__init__()
self.factor = factor
def forward(self, input, logdet=None, reverse=False, **kwargs):
if not reverse:
assert input.size(-1)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import numpy as np
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dyna... | npuichigo/waveglow | UpsampleNet | false | 16,187 | [
"Apache-2.0"
] | 214 | 44e5cae59842ddb5f692085472b5e09fa18cce42 | https://github.com/npuichigo/waveglow/tree/44e5cae59842ddb5f692085472b5e09fa18cce42 | import torch
import numpy as np
import torch.nn as nn
class SqueezeLayer(nn.Module):
def __init__(self, factor):
super().__init__()
self.factor = factor
def forward(self, input, logdet=None, reverse=False, **kwargs):
if not reverse:
assert input.size(-1) % self.factor == ... |
encoder_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 encoder_block(nn.Module):
def __init__(self, input_feature, output_feature, use_dropout):
super(encoder_block, self).__init__()
self.conv_input = nn.Conv3d(input_feature, output_feature, 3, 1, 1, 1)
self.conv_inblock1 = nn.Conv3d(output_feature, ou... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | ninamiolane/quicksilver | encoder_block | false | 16,188 | [
"Apache-2.0"
] | 126 | 1baf251360dadea0afa3daaa09942d9d2d7c71fb | https://github.com/ninamiolane/quicksilver/tree/1baf251360dadea0afa3daaa09942d9d2d7c71fb | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_feature, output_feature, use_dropout):
super().__init__()
self.conv_input = nn.Conv3d(input_feature, output_feature, 3, 1, 1, 1)
self.conv_inblock1 = nn.Conv3d(output_feature, output_feature, 3, 1,
... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.distributions
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It has projection layer for getting keys, queries and values. Followed by attention.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | nmrenyi/ReChorus | MultiHeadAttention | false | 16,189 | [
"MIT"
] | 314 | 9ab632579d0464b0aaf365539f87b04866920b66 | https://github.com/nmrenyi/ReChorus/tree/9ab632579d0464b0aaf365539f87b04866920b66 | import torch
import numpy as np
import torch.nn as nn
import torch.distributions
class Model(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It has projection layer for getting keys, queries and values. Followed by attention.
"""
... |
ViTStemPatchify | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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.utils.data
import torch.nn as nn
def patchify2d(w_in, w_out, k, *, bias=True):
"""Helper for building a patchify layer as used by ViT models."""
return nn.Conv2d(w_in, w_out, k, stride=k, padding=0, bias=bias)
def patchify2d_cx(cx, w_in, w_out, k, *, bia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
import torch.utils.data
import torch.nn as nn
assert... | om00839/pycls | ViTStemPatchify | false | 16,190 | [
"MIT"
] | 1,975 | 8c79a8e2adfffa7cae3a88aace28ef45e52aa7e5 | https://github.com/om00839/pycls/tree/8c79a8e2adfffa7cae3a88aace28ef45e52aa7e5 | from torch.nn import Module
import torch
import torch.utils.data
import torch.nn as nn
def patchify2d(w_in, w_out, k, *, bias=True):
"""Helper for building a patchify layer as used by ViT models."""
return nn.Conv2d(w_in, w_out, k, stride=k, padding=0, bias=bias)
def patchify2d_cx(cx, w_in, w_out, k, *, bia... |
GAT | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class GraphAttention(nn.Module):
"""
Simple GAT layer, similar to https://arxiv.org/abs/1710.10903
"""
def __init__(self, in_features, out_features, dropout, alpha, concat=True):
super(GraphAttention, self).... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | new2scala/graph-cnn.pytorch | GAT | false | 16,191 | [
"MIT"
] | 330 | 8bee0c2ed687dcfdb277c71b70c8ea747b6ca9c7 | https://github.com/new2scala/graph-cnn.pytorch/tree/8bee0c2ed687dcfdb277c71b70c8ea747b6ca9c7 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class GraphAttention(nn.Module):
"""
Simple GAT layer, similar to https://arxiv.org/abs/1710.10903
"""
def __init__(self, in_features, out_features, dropout, alpha, concat=True):
super().__init__()
s... |
SpatialAttention2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.nn as nn
import torch.nn.parallel
class SpatialAttention2d(nn.Module):
"""
SpatialAttention2d
2-layer 1x1 conv network with softplus activation.
<!!!> attention score normalization will be added for experiment.
"""
def __init__(self, in_c, act_fn='rel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | nhonth/DeLF-pytorch | SpatialAttention2d | false | 16,192 | [
"MIT"
] | 315 | 5577a447a0330b9e976cff56a10fc91669216b8c | https://github.com/nhonth/DeLF-pytorch/tree/5577a447a0330b9e976cff56a10fc91669216b8c | import torch
import torch.nn
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
"""
SpatialAttention2d
2-layer 1x1 conv network with softplus activation.
<!!!> attention score normalization will be added for experiment.
"""
def __init__(self, in_c, act_fn='relu'):
... |
Discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Discriminator(nn.Module):
def __init__(self, state_dim, action_dim):
super(Discriminator, self).__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, sta... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | nikhilbarhate99/Deterministic-GAIL-PyTorch | Discriminator | false | 16,193 | [
"MIT"
] | 64 | 36843739dd7b0ca58e9fcaf923cc6735a5d7ffef | https://github.com/nikhilbarhate99/Deterministic-GAIL-PyTorch/tree/36843739dd7b0ca58e9fcaf923cc6735a5d7ffef | import torch
import torch.nn as nn
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, state, action):
state_... |
MLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
from torch.utils.data import *
class MLP(nn.Module):
def __init__(self):
super(MLP, self).__init__()
self.fc1 = nn.Linear(784, 512)
self.fc2 = nn.Linear(512, 128)
self.fc3 = nn.Linear(128, 10)
def forward(self,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | nox-410/nnfusion | MLP | false | 16,194 | [
"MIT"
] | 639 | 0777e297299c4e7a5071dc2ee97b87adcd22840e | https://github.com/nox-410/nnfusion/tree/0777e297299c4e7a5071dc2ee97b87adcd22840e | import torch
from torch import nn
import torch.nn.functional as F
from torch.utils.data import *
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(784, 512)
self.fc2 = nn.Linear(512, 128)
self.fc3 = nn.Linear(128, 10)
def forward(self, x):
... |
TrTimeInvFIRFilter | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class TrTimeInvFIRFilter(nn.Conv1d):
"""Trainable Time-invatiant FIR filter implementation
H(z) = \\sigma_{k=0}^{filt_dim} b_{k}z_{-k}
Note that b_{0} is fixed to 1 if fixed_0th is True.
Args:
channels (int): input chann... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | oatsu-gh/nnsvs | TrTimeInvFIRFilter | false | 16,195 | [
"MIT"
] | 298 | 510f37bc1d1f15282646e4d34435b5d63686cf40 | https://github.com/oatsu-gh/nnsvs/tree/510f37bc1d1f15282646e4d34435b5d63686cf40 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Conv1d):
"""Trainable Time-invatiant FIR filter implementation
H(z) = \\sigma_{k=0}^{filt_dim} b_{k}z_{-k}
Note that b_{0} is fixed to 1 if fixed_0th is True.
Args:
channels (int): input channels
f... |
SoftmaxScaleController | # 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 ScaleControllerBase(torch.nn.Module):
"""
The base class for ScaleController.
ScaleController is a callable class that re-scale input tensor's value.
Traditional scale method may include:
soft-max, L2 normalize, relu and so on.
Advanced method:
Learnable scale pa... | 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
assert_size_stride = t... | niloofar17/MetaDialog | SoftmaxScaleController | false | 16,196 | [
"Apache-2.0"
] | 204 | d75b84a02807d53d9596e72c2f698e5a4f180369 | https://github.com/niloofar17/MetaDialog/tree/d75b84a02807d53d9596e72c2f698e5a4f180369 | import torch
class ScaleControllerBase(torch.nn.Module):
"""
The base class for ScaleController.
ScaleController is a callable class that re-scale input tensor's value.
Traditional scale method may include:
soft-max, L2 normalize, relu and so on.
Advanced method:
Learnable scale pa... |
TimeIntervalMultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.distributions
class TimeIntervalMultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It also needs position and interaction (time interval) key/value input.
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | nmrenyi/ReChorus | TimeIntervalMultiHeadAttention | false | 16,197 | [
"MIT"
] | 314 | 9ab632579d0464b0aaf365539f87b04866920b66 | https://github.com/nmrenyi/ReChorus/tree/9ab632579d0464b0aaf365539f87b04866920b66 | import torch
import numpy as np
import torch.nn as nn
import torch.distributions
class Model(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It also needs position and interaction (time interval) key/value input.
"""
self.... |
MaxPooling | # 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 as nn
import torch as torch
class MaxPooling(nn.Module):
def __init__(self):
super(MaxPooling, self).__init__()
def forward(self, input):
_b, _c, h, _w = input.size()
f_pool = nn.MaxPool2d((h, 1), (1, 1))
conv = f_pool(inpu... | 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.utils.data
import torch.nn as nn
import torch as torch
assert_size_stride = ... | olivernina/nephi | MaxPooling | false | 16,198 | [
"MIT"
] | 50 | a25e74e58c24edb7dc051b79d106b3bc51c7a998 | https://github.com/olivernina/nephi/tree/a25e74e58c24edb7dc051b79d106b3bc51c7a998 | import torch
import torch.utils.data
import torch.nn as nn
import torch as torch
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input):
_b, _c, h, _w = input.size()
f_pool = nn.MaxPool2d((h, 1), (1, 1))
conv = f_pool(input)
_b, _c, h,... |
Baseline | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Baseline(nn.Module):
"""Baseline
"""
def __init__(self, hid_dim, x_dim, binary_dim, inp_dim):
super(Baseline, self).__init__()
self.x_dim = x_dim
self.binary_dim = binary_dim
self.inp_dim = inp_dim
self.hid_dim = hid_dim
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | nyu-dl/MultimodalGame | Baseline | false | 16,199 | [
"BSD-3-Clause"
] | 54 | 0782a7bf3cf5125cd7c35a243e97f0e9e016fca3 | https://github.com/nyu-dl/MultimodalGame/tree/0782a7bf3cf5125cd7c35a243e97f0e9e016fca3 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Baseline
"""
def __init__(self, hid_dim, x_dim, binary_dim, inp_dim):
super().__init__()
self.x_dim = x_dim
self.binary_dim = binary_dim
self.inp_dim = inp_dim
self.hid_dim = hid_dim
self.linear1... |
TVLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn import functional as F
class TVLoss(nn.Module):
"""L2 total variation loss, as in Mahendran et al."""
def forward(self, input):
input = F.pad(input, (0, 1, 0, 1), 'replicate')
x_diff = input[..., :-1, 1:] - input[..., :-1, :-1]
y_diff = ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | olaviinha/style-transfer-pytorch | TVLoss | false | 16,200 | [
"MIT"
] | 290 | 9bdb2d932a31b6cf0ac7b651dc38b740c3e37fe8 | https://github.com/olaviinha/style-transfer-pytorch/tree/9bdb2d932a31b6cf0ac7b651dc38b740c3e37fe8 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""L2 total variation loss, as in Mahendran et al."""
def forward(self, input):
input = F.pad(input, (0, 1, 0, 1), 'replicate')
x_diff = input[..., :-1, 1:] - input[..., :-1, :-1]
y_diff = i... |
Conv3dMaxPool | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Conv3dMaxPool(nn.Module):
def __init__(self, out_channels: 'int', in_channels: 'int'):
super().__init__()
self.sat_conv3d = nn.Conv3d(in_channels=in_channels, out_channels=
out_channels, kernel_size=(3, 3, 3), padding=(1, 1, 1))
self.sat... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | openclimatefix/predict_pv_yield | Conv3dMaxPool | false | 16,201 | [
"MIT"
] | 47 | 83f27bd392190f1771221e92bfebb879bf562f5d | https://github.com/openclimatefix/predict_pv_yield/tree/83f27bd392190f1771221e92bfebb879bf562f5d | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, out_channels: 'int', in_channels: 'int'):
super().__init__()
self.sat_conv3d = nn.Conv3d(in_channels=in_channels, out_channels=
out_channels, kernel_size=(3, 3, 3), padding=(1, 1, 1))
self.sat_maxpool... |
Conv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Conv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
relu=True, same_padding=False):
super(Conv2d, self).__init__()
padding = int((kernel_size - 1) / 2) if same_padding else 0
self.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dyn... | ojasjoshi/Selective_Deblur_GANs | Conv2d | false | 16,202 | [
"MIT"
] | 1,663 | 9ac256b41b62c50c8b967f7e6fa7ecb4c7305889 | https://github.com/ojasjoshi/Selective_Deblur_GANs/tree/9ac256b41b62c50c8b967f7e6fa7ecb4c7305889 | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
relu=True, same_padding=False):
super().__init__()
padding = int((kernel_size - 1) / 2) if same_padding else 0
self.conv = nn.Con... |
PartitionLoss | # 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 PartitionLoss(nn.Module):
def __init__(self):
super(PartitionLoss, self).__init__()
def forward(self, x):
num_head = x.size(1)
if num_head > 1:
var = x.var(dim=1).mean()
loss = torch.log(1 + num_head / var)
else... | 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... | orena1/DAN | PartitionLoss | false | 16,203 | [
"MIT"
] | 50 | 49247ad0cad2a67057d184fa92d15fe2e7bb2cb6 | https://github.com/orena1/DAN/tree/49247ad0cad2a67057d184fa92d15fe2e7bb2cb6 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
num_head = x.size(1)
if num_head > 1:
var = x.var(dim=1).mean()
loss = torch.log(1 + num_head / var)
else:
loss = 0
... |
ActivationLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
class ActivationLoss(nn.Module):
def __init__(self):
super(ActivationLoss, self).__init__()
def forward(self, zero, one, labels):
loss_act = torch.abs(one - labels.data) + torch.abs(zero - (1.0 -
labels.data))
retu... | 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... | nviable/ClassNSeg | ActivationLoss | false | 16,204 | [
"BSD-3-Clause"
] | 68 | 87e506fddb9f36ef14f9bd1f6496f86d7faef0fd | https://github.com/nviable/ClassNSeg/tree/87e506fddb9f36ef14f9bd1f6496f86d7faef0fd | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, zero, one, labels):
loss_act = torch.abs(one - labels.data) + torch.abs(zero - (1.0 -
labels.data))
return 1 / labels.shape[0] * loss... |
IPDFeature | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch as th
import torch.nn as nn
class IPDFeature(nn.Module):
"""
Compute inter-channel phase difference
"""
def __init__(self, ipd_index='1,0;2,0;3,0;4,0;5,0;6,0', cos=True, sin=False
):
super(IPDFeature, self).__init__()
def split_index(sstr... | 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... | oucxlw/ConferencingSpeech2021 | IPDFeature | false | 16,205 | [
"Apache-2.0"
] | 98 | 617df8116c0510b2addadb1de374d7b50eea4f2b | https://github.com/oucxlw/ConferencingSpeech2021/tree/617df8116c0510b2addadb1de374d7b50eea4f2b | import math
import torch
import torch as th
import torch.nn as nn
class Model(nn.Module):
"""
Compute inter-channel phase difference
"""
def __init__(self, ipd_index='1,0;2,0;3,0;4,0;5,0;6,0', cos=True, sin=False
):
super().__init__()
def split_index(sstr):
return... |
MDNLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class MDNLayer(nn.Module):
""" Mixture Density Network layer
The input maps to the parameters of a Mixture of Gaussians (MoG) probability
distribution, where each Gaussian has out_dim dimensions and diagonal covariance.
If dim_wis... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | oatsu-gh/nnsvs | MDNLayer | false | 16,206 | [
"MIT"
] | 298 | 510f37bc1d1f15282646e4d34435b5d63686cf40 | https://github.com/oatsu-gh/nnsvs/tree/510f37bc1d1f15282646e4d34435b5d63686cf40 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
""" Mixture Density Network layer
The input maps to the parameters of a Mixture of Gaussians (MoG) probability
distribution, where each Gaussian has out_dim dimensions and diagonal covariance.
If dim_wise i... |
L1Norm | # 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
import torch.nn.init
class L1Norm(nn.Module):
def __init__(self):
super(L1Norm, self).__init__()
self.eps = 1e-10
def forward(self, x):
norm = to... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import ... | oskyhn/CNNs-Without-Borders | L1Norm | false | 16,207 | [
"BSD-3-Clause"
] | 74 | 4fae1d8fd64c3c917f5c78c3513a60572af961b1 | https://github.com/oskyhn/CNNs-Without-Borders/tree/4fae1d8fd64c3c917f5c78c3513a60572af961b1 | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.init
class Model(nn.Module):
def __init__(self):
super().__init__()
self.eps = 1e-10
def forward(self, x):
norm = torch.sum(torch... |
TimeIntervalTransformerLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.distributions
class TimeIntervalMultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It also needs position and interaction (time interval) key/value input.
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | nmrenyi/ReChorus | TimeIntervalTransformerLayer | false | 16,208 | [
"MIT"
] | 314 | 9ab632579d0464b0aaf365539f87b04866920b66 | https://github.com/nmrenyi/ReChorus/tree/9ab632579d0464b0aaf365539f87b04866920b66 | import torch
import numpy as np
import torch.nn as nn
import torch.distributions
class TimeIntervalMultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It also needs position and interaction (time interval) key/value input.
... |
SpatialSoftmax | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
class SpatialSoftmax(nn.Module):
def __init__(self, temperature=1, device='cpu'):
super(SpatialSoftmax, self).__init__()
if temperature:
self.temperature = Parameter(torch.ones(... | 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
... | ozcell/ENet-SAD_Pytorch | SpatialSoftmax | false | 16,209 | [
"MIT"
] | 53 | aaa79b5e96316e1bf24d3c2147ee622d4f17bc24 | https://github.com/ozcell/ENet-SAD_Pytorch/tree/aaa79b5e96316e1bf24d3c2147ee622d4f17bc24 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, temperature=1, device='cpu'):
super().__init__()
if temperature:
self.temperature = Parameter(torch.ones(1) * temperature)
els... |
GoodDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MyConvo2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, he_init=True,
stride=1, bias=True):
super(MyConvo2d, self).__init__()
self.he_init = he_init
self.padding = int((kernel_size - 1) / 2)
self.conv = nn.Conv2d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | justaboutlola/improved-wgan-pytorch | GoodDiscriminator | false | 16,210 | [
"MIT"
] | 412 | 5bb0b729809152d9129ef72a9dd28b3ff83021a2 | https://github.com/justaboutlola/improved-wgan-pytorch/tree/5bb0b729809152d9129ef72a9dd28b3ff83021a2 | import torch
from torch import nn
class MyConvo2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, he_init=True,
stride=1, bias=True):
super().__init__()
self.he_init = he_init
self.padding = int((kernel_size - 1) / 2)
self.conv = nn.Conv2d(input_dim, out... |
DQNLoss | # 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.functional as F
from torch.nn.modules.loss import _Loss
class DQNLoss(_Loss):
def __init__(self, mode='huber', size_average=None, reduce=None,
reduction='mean'):
super().__init__(size_average, reduce, reduction)
self.mode = mode
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.triton_helpers import math as tl_math
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
a... | opium-sh/prl | DQNLoss | false | 16,211 | [
"MIT"
] | 51 | 3e21f8c7c87cfc7aee84d9e264c3a8b2bc549076 | https://github.com/opium-sh/prl/tree/3e21f8c7c87cfc7aee84d9e264c3a8b2bc549076 | import torch
import numpy as np
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def __init__(self, mode='huber', size_average=None, reduce=None,
reduction='mean'):
super().__init__(size_average, reduce, reduction)
self.mode = mode
self.l... |
PositionwiseFeedForwardNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PositionwiseFeedForwardNet(nn.Module):
"""
It's position-wise because this feed forward net will be independently applied to every token's representation.
Representations batch is of the shape (batch size, max token sequence length, model dimension).
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | ozzieba/pytorch-original-transformer | PositionwiseFeedForwardNet | false | 16,212 | [
"MIT"
] | 654 | 4c1e17a701fae050e362e962284fb99547636f75 | https://github.com/ozzieba/pytorch-original-transformer/tree/4c1e17a701fae050e362e962284fb99547636f75 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
It's position-wise because this feed forward net will be independently applied to every token's representation.
Representations batch is of the shape (batch size, max token sequence length, model dimension).
This net will basi... |
BertAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
class BertLayerNorm(nn.Module):
def __init__(self, config, variance_epsilon=1e-12):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super(BertLayerNorm, self)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | GingerNg/SDNet | BertAttention | false | 16,213 | [
"MIT"
] | 112 | 48ad8cc57c9a02aaad10e34d0c91a174ac68f056 | https://github.com/GingerNg/SDNet/tree/48ad8cc57c9a02aaad10e34d0c91a174ac68f056 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
class BertLayerNorm(nn.Module):
def __init__(self, config, variance_epsilon=1e-12):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super().__init__()
... |
PolicyGradientLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
class PolicyGradientLoss(_Loss):
def __init__(self, size_average=None, reduce=None, reduction='mean'):
super().__init__(size_average, reduce, reduction)
def forward(self, nn_outputs, actions, returns):
outpu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch.nn.modules.... | opium-sh/prl | PolicyGradientLoss | false | 16,214 | [
"MIT"
] | 51 | 3e21f8c7c87cfc7aee84d9e264c3a8b2bc549076 | https://github.com/opium-sh/prl/tree/3e21f8c7c87cfc7aee84d9e264c3a8b2bc549076 | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def __init__(self, size_average=None, reduce=None, reduction='mean'):
super().__init__(size_average, reduce, reduction)
def forward(self, nn_outputs, actions, returns):
output_log_probs =... |
CorrelationPenaltyLoss | # 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
import torch.nn.init
class CorrelationPenaltyLoss(nn.Module):
def __init__(self):
super(CorrelationPenaltyLoss, self).__init__()
def forward(self, input):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | oskyhn/CNNs-Without-Borders | CorrelationPenaltyLoss | false | 16,215 | [
"BSD-3-Clause"
] | 74 | 4fae1d8fd64c3c917f5c78c3513a60572af961b1 | https://github.com/oskyhn/CNNs-Without-Borders/tree/4fae1d8fd64c3c917f5c78c3513a60572af961b1 | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.init
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input):
mean1 = torch.mean(input, dim=0)
ze... |
mIoULoss | # 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 mIoULoss(nn.Module):
def __init__(self, weight=None, size_average=True, n_classes=4):
super(mIoULoss, self).__init__()
self.classes = n_classes
def forward(self, inputs, target_oneHot):
"""
IoU Loss for ... | 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
... | ozcell/ENet-SAD_Pytorch | mIoULoss | false | 16,216 | [
"MIT"
] | 53 | aaa79b5e96316e1bf24d3c2147ee622d4f17bc24 | https://github.com/ozcell/ENet-SAD_Pytorch/tree/aaa79b5e96316e1bf24d3c2147ee622d4f17bc24 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, weight=None, size_average=True, n_classes=4):
super().__init__()
self.classes = n_classes
def forward(self, inputs, target_oneHot):
"""
IoU Loss for individual exampl... |
TransformerLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.distributions
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It has projection layer for getting keys, queries and values. Followed by attention.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | nmrenyi/ReChorus | TransformerLayer | false | 16,217 | [
"MIT"
] | 314 | 9ab632579d0464b0aaf365539f87b04866920b66 | https://github.com/nmrenyi/ReChorus/tree/9ab632579d0464b0aaf365539f87b04866920b66 | import torch
import numpy as np
import torch.nn as nn
import torch.distributions
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, kq_same=False, bias=True):
super().__init__()
"""
It has projection layer for getting keys, queries and values. Followed by attention.... |
PositionEmbeddingLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseLayer(nn.Module, ABC):
"""
Base Layer for the torecsys module
"""
def __init__(self, **kwargs):
"""
Initializer for ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractm... | p768lwy3/torecsys | PositionEmbeddingLayer | false | 16,218 | [
"MIT"
] | 92 | 2251366268b4fbe6f8c3ab1628fa72a0db043dcd | https://github.com/p768lwy3/torecsys/tree/2251366268b4fbe6f8c3ab1628fa72a0db043dcd | import torch
import torch.nn as nn
import torch.utils.data
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseLayer(nn.Module, ABC):
"""
Base Layer for the torecsys module
"""
def __init__(self, **kwargs):
"""
Initializer for ... |
UniformBatchMiner | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
from typing import Any
from typing import Dict
from typing import List
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseMiner(nn.Module, ABC):
def __init__(self, *args: List[Any], **kwargs: Dict[str, Any]):
su... | import torch
from torch import device
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
from typing import Any
from typing import Dict
from typing import Lis... | p768lwy3/torecsys | UniformBatchMiner | false | 16,219 | [
"MIT"
] | 92 | 2251366268b4fbe6f8c3ab1628fa72a0db043dcd | https://github.com/p768lwy3/torecsys/tree/2251366268b4fbe6f8c3ab1628fa72a0db043dcd | import torch
import torch.nn as nn
import torch.utils.data
from typing import Any
from typing import Dict
from typing import List
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseMiner(nn.Module, ABC):
def __init__(self, *args: List[Any], **kwargs: Dict[str, Any]):
su... |
ModulatedConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
rest_dim = [1] * (input.ndim - bias.ndim - 1)
input = input
if input.ndim == 3:
return F.leaky_relu(input + bias.view(1, *rest_dim, bias.shape[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
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | ozmig77/StyleCLIP-1 | ModulatedConv2d | false | 16,220 | [
"MIT"
] | 2,732 | 57b887bba971ef86c107f4805785ce44fca3efef | https://github.com/ozmig77/StyleCLIP-1/tree/57b887bba971ef86c107f4805785ce44fca3efef | import math
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
rest_dim = [1] * (input.ndim - bias.ndim - 1)
input = input
if input.ndim == 3:
return F.leaky_relu(input + bias.view(1, *rest_dim, bias.shape[0... |
Policy | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Policy(nn.Module):
def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.action_head = nn.Linear(128, 2)
self.value_head = nn.Linear(128, 1)
self.saved_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.... | nosyndicate/PyTorchRL | Policy | false | 16,221 | [
"MIT"
] | 48 | c4fb69ffebaa7f56b4210388f9eea7d42ca853e4 | https://github.com/nosyndicate/PyTorchRL/tree/c4fb69ffebaa7f56b4210388f9eea7d42ca853e4 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.affine1 = nn.Linear(4, 128)
self.action_head = nn.Linear(128, 2)
self.value_head = nn.Linear(128, 1)
self.saved_actions = []
self.... |
FieldEachTypeBilinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.utils.data
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseLayer(nn.Module, ABC):
"""
Base Layer for the torecsys module
"""
def __init__(self, **kwargs):
"""
Init... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
import torch.utils.data
from typing import Dic... | p768lwy3/torecsys | FieldEachTypeBilinear | false | 16,222 | [
"MIT"
] | 92 | 2251366268b4fbe6f8c3ab1628fa72a0db043dcd | https://github.com/p768lwy3/torecsys/tree/2251366268b4fbe6f8c3ab1628fa72a0db043dcd | import math
import torch
import torch.nn as nn
import torch.utils.data
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseLayer(nn.Module, ABC):
"""
Base Layer for the torecsys module
"""
def __init__(self, **kwargs):
"""
Init... |
ToRGB | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
rest_dim = [1] * (input.ndim - bias.ndim - 1)
input = input
if input.ndim == 3:
return F.leaky_relu(input + bias.view(1, *rest_dim, bias.shape[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 math
from torch import nn
from torch.nn import functional as F
assert_siz... | ozmig77/StyleCLIP-1 | ToRGB | false | 16,223 | [
"MIT"
] | 2,732 | 57b887bba971ef86c107f4805785ce44fca3efef | https://github.com/ozmig77/StyleCLIP-1/tree/57b887bba971ef86c107f4805785ce44fca3efef | import math
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
rest_dim = [1] * (input.ndim - bias.ndim - 1)
input = input
if input.ndim == 3:
return F.leaky_relu(input + bias.view(1, *rest_dim, bias.shape[0... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
def mask_(matrices, maskval=0.0, mask_diagonal=True):
_b, h, w = matrices.size()
indices = torch.triu_indices(h, w, offset=0 if mask_diagonal else 1)
matrices[:, indices[0], indices[1]] = maskval
class SelfAttention(nn.Module):
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
from torch._inductor.runtime.... | ouyangshixiong/UPDeT | SelfAttention | false | 16,224 | [
"MIT"
] | 90 | e6010ff8a8a3ce064900f3f040a9a34218c97e0e | https://github.com/ouyangshixiong/UPDeT/tree/e6010ff8a8a3ce064900f3f040a9a34218c97e0e | import torch
import torch.nn as nn
import torch.nn.functional as F
def mask_(matrices, maskval=0.0, mask_diagonal=True):
_b, h, w = matrices.size()
indices = torch.triu_indices(h, w, offset=0 if mask_diagonal else 1)
matrices[:, indices[0], indices[1]] = maskval
class Model(nn.Module):
def __init__... |
BertOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn
import torch.nn as nn
class BertOutput(nn.Module):
"""BERT output layer.
Based on: BERT (pytorch-transformer)
https://github.com/huggingface/transformers
"""
def __init__(self, config) ->None:
super().__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn
imp... | Project-MONAI/MONAI | BertOutput | false | 16,225 | [
"Apache-2.0"
] | 2,971 | 2bab12c67c3cc1d54a4847628ce1e879064be11c | https://github.com/Project-MONAI/MONAI/tree/2bab12c67c3cc1d54a4847628ce1e879064be11c | from _paritybench_helpers import _mock_config
import torch
import torch.nn
import torch.nn as nn
class Model(nn.Module):
"""BERT output layer.
Based on: BERT (pytorch-transformer)
https://github.com/huggingface/transformers
"""
def __init__(self, config) ->None:
super().__init__()
... |
StyledConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
rest_dim = [1] * (input.ndim - bias.ndim - 1)
input = input
if input.ndim == 3:
return F.leaky_relu(input + bias.view(1, *rest_dim, bias.shape[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
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | ozmig77/StyleCLIP-1 | StyledConv | false | 16,226 | [
"MIT"
] | 2,732 | 57b887bba971ef86c107f4805785ce44fca3efef | https://github.com/ozmig77/StyleCLIP-1/tree/57b887bba971ef86c107f4805785ce44fca3efef | import math
import torch
from torch import nn
from torch.nn import functional as F
def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
rest_dim = [1] * (input.ndim - bias.ndim - 1)
input = input
if input.ndim == 3:
return F.leaky_relu(input + bias.view(1, *rest_dim, bias.shape[0... |
FieldAllTypeBilinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.utils.data
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseLayer(nn.Module, ABC):
"""
Base Layer for the torecsys module
"""
def __init__(self, **kwargs):
"""
Init... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
import torch.utils.data
from typing import Dic... | p768lwy3/torecsys | FieldAllTypeBilinear | false | 16,227 | [
"MIT"
] | 92 | 2251366268b4fbe6f8c3ab1628fa72a0db043dcd | https://github.com/p768lwy3/torecsys/tree/2251366268b4fbe6f8c3ab1628fa72a0db043dcd | import math
import torch
import torch.nn as nn
import torch.utils.data
from typing import Dict
from typing import Tuple
from abc import ABC
from abc import abstractmethod
class BaseLayer(nn.Module, ABC):
"""
Base Layer for the torecsys module
"""
def __init__(self, **kwargs):
"""
Init... |
ComplexCnnQAHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ComplexCnnQAHead(nn.Module):
def __init__(self, input_size):
super().__init__()
self.relu = nn.ReLU()
self.conv_1 = nn.Conv1d(in_channels=input_size, out_channels=256,
kernel_size=1, padding=0)
self.conv_3 = nn.Conv1d(in_channels... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | park-sungmoo/odqa_baseline_code | ComplexCnnQAHead | false | 16,228 | [
"Apache-2.0"
] | 67 | 45954be766e5f987bef18e5b8a2e47f1508742cd | https://github.com/park-sungmoo/odqa_baseline_code/tree/45954be766e5f987bef18e5b8a2e47f1508742cd | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_size):
super().__init__()
self.relu = nn.ReLU()
self.conv_1 = nn.Conv1d(in_channels=input_size, out_channels=256,
kernel_size=1, padding=0)
self.conv_3 = nn.Conv1d(in_channels=input_size... |
GlobalDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class GlobalDiscriminator(nn.Module):
def __init__(self, y_size, M_channels):
super().__init__()
self.c0 = nn.Conv2d(M_channels, 64, kernel_size=3)
self.c1 = nn.Conv2d(64, 32, kernel_size=3)
self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | neuralsyn/self-supervised-relational-reasoning | GlobalDiscriminator | false | 16,229 | [
"MIT"
] | 130 | 6ecfafcf4a36c2eacef7ddd5bd1b23c28fbb14c8 | https://github.com/neuralsyn/self-supervised-relational-reasoning/tree/6ecfafcf4a36c2eacef7ddd5bd1b23c28fbb14c8 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
def __init__(self, y_size, M_channels):
super().__init__()
self.c0 = nn.Conv2d(M_channels, 64, kernel_size=3)
self.c1 = nn.Conv2d(64, 32, kernel_size=3)
self.avgpool = nn.... |
AE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
import torch.nn.modules.loss
class AE(nn.Module):
""" Autoencoder for dimensional reduction"""
def __init__(self, dim):
super(AE, self).__init__()
self.dim = dim
self.fc1 = nn.Linear(dim, 512)
self.fc2 = nn.Lin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.functional as... | peterfeifanchen/scGNN | AE | false | 16,230 | [
"MIT"
] | 60 | 4ef9013ad0f44f9f51708e9bb60e5138f5706593 | https://github.com/peterfeifanchen/scGNN/tree/4ef9013ad0f44f9f51708e9bb60e5138f5706593 | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.modules.loss
class Model(nn.Module):
""" Autoencoder for dimensional reduction"""
def __init__(self, dim):
super().__init__()
self.dim = dim
self.fc1 = nn.Linear(dim, 512)
self.fc2 = nn.Linear(5... |
MaskL1Loss | # 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 MaskL1Loss(nn.Module):
"""
Loss from paper <Pose Guided Person Image Generation> Sec3.1 pose mask loss
"""
def __init__(self, ratio=1):
super(MaskL1Loss, self).__init__()
self.criterion = nn.L1Loss()
self.ratio = ratio
def forward(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | pasan1992/Human-Pose-Transfer | MaskL1Loss | false | 16,231 | [
"MIT"
] | 64 | a7febc632d4fbf627ba05740d2048accb25575f2 | https://github.com/pasan1992/Human-Pose-Transfer/tree/a7febc632d4fbf627ba05740d2048accb25575f2 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Loss from paper <Pose Guided Person Image Generation> Sec3.1 pose mask loss
"""
def __init__(self, ratio=1):
super().__init__()
self.criterion = nn.L1Loss()
self.ratio = ratio
def forward(self, generated_img, ... |
BertMixedLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn
import torch.nn as nn
class BertAttention(nn.Module):
"""BERT attention layer.
Based on: BERT (pytorch-transformer)
https://github.com/huggingface/transformers
"""
def __init__(self, config) ->None:
sup... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Project-MONAI/MONAI | BertMixedLayer | false | 16,232 | [
"Apache-2.0"
] | 2,971 | 2bab12c67c3cc1d54a4847628ce1e879064be11c | https://github.com/Project-MONAI/MONAI/tree/2bab12c67c3cc1d54a4847628ce1e879064be11c | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn
import torch.nn as nn
class BertAttention(nn.Module):
"""BERT attention layer.
Based on: BERT (pytorch-transformer)
https://github.com/huggingface/transformers
"""
def __init__(self, config) ->None:
sup... |
CBOWClassifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 CBOWClassifier(nn.Module):
"""
Continuous bag of words classifier.
"""
def __init__(self, hidden_size, input_size, max_pool, dropout=0.5):
"""
:param hidden_size:
:param input_size:
:param max_pool: if true then max pool over wor... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | nyu-mll/CoLA-baselines | CBOWClassifier | false | 16,233 | [
"MIT"
] | 54 | dd095d3646ed05a315280aaa8ed4ec84ba435b3e | https://github.com/nyu-mll/CoLA-baselines/tree/dd095d3646ed05a315280aaa8ed4ec84ba435b3e | import torch
from torch import nn
class Model(nn.Module):
"""
Continuous bag of words classifier.
"""
def __init__(self, hidden_size, input_size, max_pool, dropout=0.5):
"""
:param hidden_size:
:param input_size:
:param max_pool: if true then max pool over word embeddi... |
DHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 math import *
class DHead(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(256, 1, 4)
def forward(self, x):
output = torch.sigmoid(self.conv(x))
return output
def get_inputs():
return [torch.rand([4, 256, 6... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from math import *
assert_size_stride = torch._C._dynamo.g... | pengyuzhang97/NIID-Bench | DHead | false | 16,234 | [
"MIT"
] | 124 | 235b6f5c2bf218a587f9effae346a2f616de1855 | https://github.com/pengyuzhang97/NIID-Bench/tree/235b6f5c2bf218a587f9effae346a2f616de1855 | import torch
import torch.nn as nn
from math import *
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(256, 1, 4)
def forward(self, x):
output = torch.sigmoid(self.conv(x))
return output
def get_inputs():
return [torch.rand([4, 256, 6... |
IcosahedronUnpool | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
from torch import nn
import torch.nn.functional as F
class IcosahedronUnpool(nn.Module):
"""Isocahedron Unpooling, consists in adding 1 values to match the desired un pooling size
"""
def forward(self, x):
"""Forward calculates the subset of pixels that will result from t... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | phil-hawkins/deepsphere-pytorch | IcosahedronUnpool | false | 16,235 | [
"MIT"
] | 99 | f23c531445b3ddf234c7e98cdadb010163051e6d | https://github.com/phil-hawkins/deepsphere-pytorch/tree/f23c531445b3ddf234c7e98cdadb010163051e6d | import math
import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""Isocahedron Unpooling, consists in adding 1 values to match the desired un pooling size
"""
def forward(self, x):
"""Forward calculates the subset of pixels that will result from the unpooling... |
MultiHeadedAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from typing import Optional
from typing import Tuple
from torch import nn
class MultiHeadedAttention(nn.Module):
"""Multi-Head Attention layer.
Args:
n_head (int): The number of heads.
n_feat (int): The number of features.
dropout_rate (float): Dropout 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
from torch._inductor.runtime.... | pengchengguo/wenet | MultiHeadedAttention | false | 16,236 | [
"Apache-2.0"
] | 1,166 | 940dc164e5cfa9b8c0131688f0f9457af9563892 | https://github.com/pengchengguo/wenet/tree/940dc164e5cfa9b8c0131688f0f9457af9563892 | import math
import torch
from typing import Optional
from typing import Tuple
from torch import nn
class Model(nn.Module):
"""Multi-Head Attention layer.
Args:
n_head (int): The number of heads.
n_feat (int): The number of features.
dropout_rate (float): Dropout rate.
"""
de... |
AppendCLSToken | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import Tensor
import torch.nn as nn
class BaseEmbeddingLayer(nn.Module):
def _apply_initialization(self, x: 'Tensor', d: 'int', method: 'str'
) ->None:
d_sqrt_inv = 1 / math.sqrt(d)
if method == 'uniform':
nn.init.uniform_(x, a=-d_sqrt_inv, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
from torch import Tensor
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cud... | pfnet-research/deep-table | AppendCLSToken | false | 16,237 | [
"MIT"
] | 48 | a19c0c3048484017d5f24806604c3b3470bcf550 | https://github.com/pfnet-research/deep-table/tree/a19c0c3048484017d5f24806604c3b3470bcf550 | import math
import torch
from torch import Tensor
import torch.nn as nn
class BaseEmbeddingLayer(nn.Module):
def _apply_initialization(self, x: 'Tensor', d: 'int', method: 'str'
) ->None:
d_sqrt_inv = 1 / math.sqrt(d)
if method == 'uniform':
nn.init.uniform_(x, a=-d_sqrt_inv, ... |
CnnQAHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 CnnQAHead(nn.Module):
def __init__(self, input_size):
super().__init__()
self.conv_1 = nn.Conv1d(in_channels=input_size, out_channels=2,
kernel_size=1, padding=0)
self.conv_3 = nn.Conv1d(in_channels=input_size, out_channels=2,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | park-sungmoo/odqa_baseline_code | CnnQAHead | false | 16,238 | [
"Apache-2.0"
] | 67 | 45954be766e5f987bef18e5b8a2e47f1508742cd | https://github.com/park-sungmoo/odqa_baseline_code/tree/45954be766e5f987bef18e5b8a2e47f1508742cd | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_size):
super().__init__()
self.conv_1 = nn.Conv1d(in_channels=input_size, out_channels=2,
kernel_size=1, padding=0)
self.conv_3 = nn.Conv1d(in_channels=input_size, out_channels=2,
ke... |
CoverageAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.nn.functional as F
class CoverageAttention(nn.Module):
def __init__(self, config: 'SARGConfig'):
super(CoverageAttention, self).__init__()
self.linear_h = nn.Linear(config.hidden_size, config.hidden_size)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | NetEase-GameAI/SARG | CoverageAttention | false | 16,239 | [
"BSD-3-Clause"
] | 53 | 037085794f10439c4e52f57ab0fa042f35d03f62 | https://github.com/NetEase-GameAI/SARG/tree/037085794f10439c4e52f57ab0fa042f35d03f62 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, config: 'SARGConfig'):
super().__init__()
self.linear_h = nn.Linear(config.hidden_size, config.hidden_size)
self.linear_K = nn.Linear(... |
HealpixAvgPool | # 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 HealpixAvgPool(nn.AvgPool1d):
"""Healpix Average pooling module
"""
def __init__(self):
"""initialization
"""
super().__init__(kernel_size=4)
def forward(self, x):
"""forward call the 1d Averagepo... | 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... | phil-hawkins/deepsphere-pytorch | HealpixAvgPool | false | 16,240 | [
"MIT"
] | 99 | f23c531445b3ddf234c7e98cdadb010163051e6d | https://github.com/phil-hawkins/deepsphere-pytorch/tree/f23c531445b3ddf234c7e98cdadb010163051e6d | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.AvgPool1d):
"""Healpix Average pooling module
"""
def __init__(self):
"""initialization
"""
super().__init__(kernel_size=4)
def forward(self, x):
"""forward call the 1d Averagepooling of ... |
RBFExpansion | # 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 RBFExpansion(nn.Module):
"""Expand distances between nodes by radial basis functions.
.. math::
\\exp(- \\gamma * ||d - \\mu||^2)
where :math:`d` is the distance between two nodes and :math:`\\mu` helps centralizes
the distances. We... | 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
assert_size_stride = torch._C._d... | padr31/dgl-lifesci | RBFExpansion | false | 16,241 | [
"Apache-2.0"
] | 390 | 932581468b330862836c0f050077fa33d0eb9405 | https://github.com/padr31/dgl-lifesci/tree/932581468b330862836c0f050077fa33d0eb9405 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
"""Expand distances between nodes by radial basis functions.
.. math::
\\exp(- \\gamma * ||d - \\mu||^2)
where :math:`d` is the distance between two nodes and :math:`\\mu` helps centralizes
the distances. We use mu... |
InfoNCELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
from torch.nn.modules.loss import _Loss
def cos_sim_matrix(a: 'Tensor', b: 'Tensor', eps: 'float'=1e-08) ->Tensor:
a_n, b_n = a.norm(dim=1), b.norm(dim=1)
a_norm = a / torch.clamp(a_n.unsqueeze(1), min=eps)
b_norm = b / torch.clamp(b_n.unsqueeze(1), min=eps)
sim_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.... | pfnet-research/deep-table | InfoNCELoss | false | 16,242 | [
"MIT"
] | 48 | a19c0c3048484017d5f24806604c3b3470bcf550 | https://github.com/pfnet-research/deep-table/tree/a19c0c3048484017d5f24806604c3b3470bcf550 | import torch
from torch import Tensor
from torch.nn.modules.loss import _Loss
def cos_sim_matrix(a: 'Tensor', b: 'Tensor', eps: 'float'=1e-08) ->Tensor:
a_n, b_n = a.norm(dim=1), b.norm(dim=1)
a_norm = a / torch.clamp(a_n.unsqueeze(1), min=eps)
b_norm = b / torch.clamp(b_n.unsqueeze(1), min=eps)
sim_m... |
ChamferLoss | # 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 ChamferLoss(nn.Module):
def __init__(self, input_channels, reduction='mean'):
super(ChamferLoss, self).__init__()
self.input_channels = input_channels
def forward(self, x, y):
x.shape[0]
num_points = x.shape[1]
x = x[:, :, :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_... | pfe-everis/lcd | ChamferLoss | false | 16,243 | [
"BSD-3-Clause"
] | 76 | 25f3fe7dc7e0c8ba02fb380dbcbe7752747b3fb5 | https://github.com/pfe-everis/lcd/tree/25f3fe7dc7e0c8ba02fb380dbcbe7752747b3fb5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_channels, reduction='mean'):
super().__init__()
self.input_channels = input_channels
def forward(self, x, y):
x.shape[0]
num_points = x.shape[1]
x = x[:, :, :self.input_channels]
... |
EquiangularAvgUnpool | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
from torch import nn
import torch.nn.functional as F
def equiangular_bandwidth(nodes):
"""Calculate the equiangular bandwidth based on input nodes
Args:
nodes (int): the number of nodes should be a power of 4
Returns:
int: the corresponding bandwidth
"""
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guard... | phil-hawkins/deepsphere-pytorch | EquiangularAvgUnpool | false | 16,244 | [
"MIT"
] | 99 | f23c531445b3ddf234c7e98cdadb010163051e6d | https://github.com/phil-hawkins/deepsphere-pytorch/tree/f23c531445b3ddf234c7e98cdadb010163051e6d | import math
import torch
from torch import nn
import torch.nn.functional as F
def equiangular_bandwidth(nodes):
"""Calculate the equiangular bandwidth based on input nodes
Args:
nodes (int): the number of nodes should be a power of 4
Returns:
int: the corresponding bandwidth
"""
... |
HealpixMaxPool | # 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 HealpixMaxPool(nn.MaxPool1d):
"""Healpix Maxpooling module
"""
def __init__(self, return_indices=False):
"""Initialization
"""
super().__init__(kernel_size=4, return_indices=return_indices)
def forward(se... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | phil-hawkins/deepsphere-pytorch | HealpixMaxPool | false | 16,245 | [
"MIT"
] | 99 | f23c531445b3ddf234c7e98cdadb010163051e6d | https://github.com/phil-hawkins/deepsphere-pytorch/tree/f23c531445b3ddf234c7e98cdadb010163051e6d | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.MaxPool1d):
"""Healpix Maxpooling module
"""
def __init__(self, return_indices=False):
"""Initialization
"""
super().__init__(kernel_size=4, return_indices=return_indices)
def forward(self, x):
... |
Normalization | # 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 numbers
import torch
import torch.nn as nn
class Normalization(nn.Module):
"""A normalization layer."""
def __init__(self, eps: 'numbers.Real'=1e-15):
"""Creates a new instance of ``Normalization``.
Args:
eps (numbers.Real, optional): A tiny number to be added to t... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import numbers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guar... | phohenecker/pytorch-transformer | Normalization | false | 16,246 | [
"BSD-2-Clause"
] | 50 | 211406d82ac04a7b473bcdebda77cc3c2e9af0cf | https://github.com/phohenecker/pytorch-transformer/tree/211406d82ac04a7b473bcdebda77cc3c2e9af0cf | import numbers
import torch
import torch.nn as nn
class Model(nn.Module):
"""A normalization layer."""
def __init__(self, eps: 'numbers.Real'=1e-15):
"""Creates a new instance of ``Normalization``.
Args:
eps (numbers.Real, optional): A tiny number to be added to the stand... |
VAE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.modules.loss
class VAE(nn.Module):
""" Variational Autoencoder for dimensional reduction"""
def __init__(self, dim):
super(VAE, self).__init__()
self.dim = dim
self.fc1 = nn.Linear(dim, 400)
sel... | import torch
from torch import device
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from... | peterfeifanchen/scGNN | VAE | false | 16,247 | [
"MIT"
] | 60 | 4ef9013ad0f44f9f51708e9bb60e5138f5706593 | https://github.com/peterfeifanchen/scGNN/tree/4ef9013ad0f44f9f51708e9bb60e5138f5706593 | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.modules.loss
class Model(nn.Module):
""" Variational Autoencoder for dimensional reduction"""
def __init__(self, dim):
super().__init__()
self.dim = dim
self.fc1 = nn.Linear(dim, 400)
self.fc21 ... |
HardTripletLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def _pairwise_distance_squared(x, y):
xx = torch.sum(torch.pow(x, 2), 1).view(-1, 1)
yy = torch.sum(torch.pow(y, 2), 1).view(1, -1)
pdist = xx + yy - 2.0 * torch.mm(x, torch.t(y))
return pdist
class HardTripletLoss(nn.Module):
def __init__(self, margin=0.2, ha... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | pfe-everis/lcd | HardTripletLoss | false | 16,248 | [
"BSD-3-Clause"
] | 76 | 25f3fe7dc7e0c8ba02fb380dbcbe7752747b3fb5 | https://github.com/pfe-everis/lcd/tree/25f3fe7dc7e0c8ba02fb380dbcbe7752747b3fb5 | import torch
import torch.nn as nn
def _pairwise_distance_squared(x, y):
xx = torch.sum(torch.pow(x, 2), 1).view(-1, 1)
yy = torch.sum(torch.pow(y, 2), 1).view(1, -1)
pdist = xx + yy - 2.0 * torch.mm(x, torch.t(y))
return pdist
class Model(nn.Module):
def __init__(self, margin=0.2, hardest=Fals... |
Normalize | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class Normalize(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, x):
norm = torch.norm(x, p=2, dim=self.dim, keepdim=True)
return x / norm
def get_inputs():
return [torch.rand([4, 4, 4, 4, 4])]
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | phuochieu212/PointGLR | Normalize | false | 16,249 | [
"MIT"
] | 104 | 37017b1af31486aa9d516a3762725a650dca9ad1 | https://github.com/phuochieu212/PointGLR/tree/37017b1af31486aa9d516a3762725a650dca9ad1 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
def forward(self, x):
norm = torch.norm(x, p=2, dim=self.dim, keepdim=True)
return x / norm
def get_inputs():
return [torch.rand([4, 4, 4, 4, 4])]
def... |
BertSelfOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.utils.checkpoint
class BertSelfOutput(nn.Module):
def __init__(self, config, twin=False, merge=False):
super().__init__()
self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.
layer_n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | igor0/BLIP | BertSelfOutput | false | 16,250 | [
"BSD-3-Clause"
] | 473 | 6d8c3f1e381ed23acb84c55b4adb80e74c08117a | https://github.com/igor0/BLIP/tree/6d8c3f1e381ed23acb84c55b4adb80e74c08117a | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, config, twin=False, merge=False):
super().__init__()
self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.
layer_norm_eps)
... |
N0reparameterize | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class N0reparameterize(nn.Module):
"""Reparametrize zero mean Gaussian Variable."""
def __init__(self, input_dim, z_dim, fixed_sigma=None):
super().__init__()
self.input_dim = input_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
fr... | pimdh/lie-vae | N0reparameterize | false | 16,251 | [
"MIT"
] | 83 | 0e0cc4d533c064fcfc405e8a75449f8b2f6cf8cf | https://github.com/pimdh/lie-vae/tree/0e0cc4d533c064fcfc405e8a75449f8b2f6cf8cf | import torch
from torch import nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class Model(nn.Module):
"""Reparametrize zero mean Gaussian Variable."""
def __init__(self, input_dim, z_dim, fixed_sigma=None):
super().__init__()
self.input_dim = input_dim
... |
ChamferLoss | # 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 ChamferLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
"""
:param x: (bs, np, 3)
:param y: (bs, np, 3)
:return: loss
"""
x = x.unsqueeze(1)
y = y.unsqueeze(2)
dis... | 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... | phuochieu212/PointGLR | ChamferLoss | false | 16,252 | [
"MIT"
] | 104 | 37017b1af31486aa9d516a3762725a650dca9ad1 | https://github.com/phuochieu212/PointGLR/tree/37017b1af31486aa9d516a3762725a650dca9ad1 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
"""
:param x: (bs, np, 3)
:param y: (bs, np, 3)
:return: loss
"""
x = x.unsqueeze(1)
y = y.unsqueeze(2)
dist = to... |
QuaternionMean | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn as nn
def quaternions_to_group_matrix(q):
"""Normalises q and maps to group matrix."""
q = q / q.norm(p=2, dim=-1, keepdim=True)
r, i, j, k = q[..., 0], q[..., 1], q[..., 2], q[..., 3]
return torch.stack([r * r - i * i - j * j + k * k, 2 * (r * i + j * k),
2 *... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | pimdh/lie-vae | QuaternionMean | false | 16,253 | [
"MIT"
] | 83 | 0e0cc4d533c064fcfc405e8a75449f8b2f6cf8cf | https://github.com/pimdh/lie-vae/tree/0e0cc4d533c064fcfc405e8a75449f8b2f6cf8cf | import torch
from torch import nn as nn
def quaternions_to_group_matrix(q):
"""Normalises q and maps to group matrix."""
q = q / q.norm(p=2, dim=-1, keepdim=True)
r, i, j, k = q[..., 0], q[..., 1], q[..., 2], q[..., 3]
return torch.stack([r * r - i * i - j * j + k * k, 2 * (r * i + j * k),
2 *... |
RelPositionMultiHeadedAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from typing import Optional
from typing import Tuple
from torch import nn
class MultiHeadedAttention(nn.Module):
"""Multi-Head Attention layer.
Args:
n_head (int): The number of heads.
n_feat (int): The number of features.
dropout_rate (float): Dropout 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
from torch._inductor.runtime.... | pengchengguo/wenet | RelPositionMultiHeadedAttention | false | 16,254 | [
"Apache-2.0"
] | 1,166 | 940dc164e5cfa9b8c0131688f0f9457af9563892 | https://github.com/pengchengguo/wenet/tree/940dc164e5cfa9b8c0131688f0f9457af9563892 | import math
import torch
from typing import Optional
from typing import Tuple
from torch import nn
class MultiHeadedAttention(nn.Module):
"""Multi-Head Attention layer.
Args:
n_head (int): The number of heads.
n_feat (int): The number of features.
dropout_rate (float): Dropout rate.
... |
ClampExp | # 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 ClampExp(torch.nn.Module):
"""
Nonlinearity min(exp(lam * x), 1)
"""
def __init__(self):
"""
Constructor
:param lam: Lambda parameter
"""
super(ClampExp, self).__init__()
def forward(self, x):
one = torch.... | 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... | pkulwj1994/normalizing-flows | ClampExp | false | 16,255 | [
"MIT"
] | 96 | 326321c4aea4a3f6ab703f82e21277a79cd7d9e4 | https://github.com/pkulwj1994/normalizing-flows/tree/326321c4aea4a3f6ab703f82e21277a79cd7d9e4 | import torch
import torch.utils.data
class Model(torch.nn.Module):
"""
Nonlinearity min(exp(lam * x), 1)
"""
def __init__(self):
"""
Constructor
:param lam: Lambda parameter
"""
super().__init__()
def forward(self, x):
one = torch.tensor(1.0, devic... |
TVLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import Tuple
from torch.nn.modules.loss import _Loss
from typing import List
from typing import Optional
def _reduce(x: 'torch.Tensor', reduction: 'str'='mean') ->torch.Tensor:
"""Reduce input in batch dimension if needed.
Args:
x: Tensor with shape (N, *).
reduction:... | 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 typing import Tuple
from torch.nn.modules.loss import _Loss
from typing im... | photosynthesis-team/piq | TVLoss | false | 16,256 | [
"Apache-2.0"
] | 471 | 79cccf887dd28ce57dea461972cda3648a79165a | https://github.com/photosynthesis-team/piq/tree/79cccf887dd28ce57dea461972cda3648a79165a | import torch
from typing import Tuple
from torch.nn.modules.loss import _Loss
from typing import List
from typing import Optional
def _reduce(x: 'torch.Tensor', reduction: 'str'='mean') ->torch.Tensor:
"""Reduce input in batch dimension if needed.
Args:
x: Tensor with shape (N, *).
reduction:... |
Nreparameterize | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class Nreparameterize(nn.Module):
"""Reparametrize Gaussian variable."""
def __init__(self, input_dim, z_dim):
super().__init__()
self.input_dim = input_dim
self.z_dim = z_di... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
fr... | pimdh/lie-vae | Nreparameterize | false | 16,257 | [
"MIT"
] | 83 | 0e0cc4d533c064fcfc405e8a75449f8b2f6cf8cf | https://github.com/pimdh/lie-vae/tree/0e0cc4d533c064fcfc405e8a75449f8b2f6cf8cf | import torch
from torch import nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class Model(nn.Module):
"""Reparametrize Gaussian variable."""
def __init__(self, input_dim, z_dim):
super().__init__()
self.input_dim = input_dim
self.z_dim = z_dim
... |
MAPELoss | # 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 MAPELoss(nn.Module):
def forward(self, estimation: 'torch.Tensor', target: 'torch.Tensor'):
AER = torch.abs((target - estimation) / (target + 1e-10))
MAPE = AER.mean() * 100
return MAPE
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torc... | 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
... | pmq20/gde | MAPELoss | false | 16,258 | [
"MIT"
] | 131 | fa4d4dacbcf00727bef76c4a641c72b94d5f8126 | https://github.com/pmq20/gde/tree/fa4d4dacbcf00727bef76c4a641c72b94d5f8126 | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, estimation: 'torch.Tensor', target: 'torch.Tensor'):
AER = torch.abs((target - estimation) / (target + 1e-10))
MAPE = AER.mean() * 100
return MAPE
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.r... |
ContrastiveEmbeddingLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch.nn.modules.loss import *
import torch.nn as nn
from torch.nn import *
from torch.optim import *
from torch.optim.lr_scheduler import *
class ContrastiveEmbeddingLoss(nn.Module):
"""
Contrastive embedding loss
paper: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch.nn.modules.loss i... | pokidyshev/catalyst | ContrastiveEmbeddingLoss | false | 16,259 | [
"Apache-2.0"
] | 46 | bfe2cc2af7b02bd954fb0b4a0cae8b350f56789a | https://github.com/pokidyshev/catalyst/tree/bfe2cc2af7b02bd954fb0b4a0cae8b350f56789a | import torch
from torch.nn.modules.loss import *
import torch.nn as nn
from torch.nn import *
from torch.optim import *
from torch.optim.lr_scheduler import *
class Model(nn.Module):
"""
Contrastive embedding loss
paper: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def _... |
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
class Upsample(nn.Module):
"""PyTorch upsampling implementation.
This module upsamples by inserting <i-1> zeros in between samples in the time
dimension. It does not low pass filter after this and assumes that the filter is a
separate module if desired.
.. see... | 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... | plexixx/rfml | Upsample | false | 16,260 | [
"BSD-3-Clause"
] | 61 | c00633b2c2005d38f991c6b9e3fd855ca25166c4 | https://github.com/plexixx/rfml/tree/c00633b2c2005d38f991c6b9e3fd855ca25166c4 | import torch
import torch.nn as nn
class Model(nn.Module):
"""PyTorch upsampling implementation.
This module upsamples by inserting <i-1> zeros in between samples in the time
dimension. It does not low pass filter after this and assumes that the filter is a
separate module if desired.
.. seeals... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.