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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
TonemappedMSE | # 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
def _tonemap(im):
"""Helper Reinhards tonemapper.
Args:
im(torch.Tensor): image to tonemap.
Returns:
(torch.Tensor) tonemaped image.
"""
im = torch.clamp(im, min=0)
return im / (1 + im)
class TonemappedMSE(torch.nn.Module):
"""Mean-squared error on tonemaped ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | Mephisto405/WCMC-Public | TonemappedMSE | false | 8,551 | [
"BSD-2-Clause"
] | 19 | bd54f218d5239db84f404fbe1b465f9497bcf9e4 | https://github.com/Mephisto405/WCMC-Public/tree/bd54f218d5239db84f404fbe1b465f9497bcf9e4 | import torch
def _tonemap(im):
"""Helper Reinhards tonemapper.
Args:
im(torch.Tensor): image to tonemap.
Returns:
(torch.Tensor) tonemaped image.
"""
im = torch.clamp(im, min=0)
return im / (1 + im)
class Model(torch.nn.Module):
"""Mean-squared error on tonemaped images.
... |
EncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
def matmul(x, y):
if x.dim() == y.dim():
return x @ y
if x.dim() == y.dim() - 1:
return (x.unsqueeze(-2) @ y).squeeze(-2)
return (x @ y.unsqueeze(-2)).squeeze(-2)
class Line... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | MichiganCOG/Video-Grounding | EncoderLayer | false | 8,552 | [
"MIT"
] | 41 | 3e0ec0b69578a59be583911590354fe77d357cab | https://github.com/MichiganCOG/Video-Grounding/tree/3e0ec0b69578a59be583911590354fe77d357cab | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
def matmul(x, y):
if x.dim() == y.dim():
return x @ y
if x.dim() == y.dim() - 1:
return (x.unsqueeze(-2) @ y).squeeze(-2)
return (x @ y.unsqueeze(-2)).squeeze(-2)
class Line... |
A | # 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
class A(torch.nn.Module):
def forward(self, x):
return x + 1
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
import torch.nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_... | ModECI/MDF | A | false | 8,553 | [
"Apache-2.0"
] | 12 | 76d5db6a1c9f691ca5be36d60d28e6e529762e7e | https://github.com/ModECI/MDF/tree/76d5db6a1c9f691ca5be36d60d28e6e529762e7e | import torch
import torch.nn
class Model(torch.nn.Module):
def forward(self, x):
return x + 1
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
TripletMarginLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.autograd import Function
import torch
class PairwiseDistance(Function):
def __init__(self, p):
super(PairwiseDistance, self).__init__()
self.norm = p
def forward(self, x1, x2):
assert x1.size() == x2.size()
eps = 0.0001 / x1.size(1)
diff = torch.abs(x1 - x2... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.autograd import Function
assert_size_stride = torch._C._dynamo.guards.assert_s... | Mikexu007/AS_CAL | TripletMarginLoss | false | 8,554 | [
"MIT"
] | 14 | 966328ae65bb16ba9b7aab153d8150c08c26c81f | https://github.com/Mikexu007/AS_CAL/tree/966328ae65bb16ba9b7aab153d8150c08c26c81f | from torch.autograd import Function
import torch
class PairwiseDistance(Function):
def __init__(self, p):
super().__init__()
self.norm = p
def forward(self, x1, x2):
assert x1.size() == x2.size()
eps = 0.0001 / x1.size(1)
diff = torch.abs(x1 - x2)
out = torch.... |
ResNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResNet(nn.Module):
"""Modified ResNet model class"""
def __init__(self, block, num_blocks, depth, width=1):
super(ResNet, self).__init__()
self.iters = int((depth - 4) // 4)
self.in_planes = int(width * 64)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Maosef/easy-to-hard | ResNet | false | 8,555 | [
"MIT"
] | 44 | 711ec0965229444a6c51b1b06a4e2cad3e32d02e | https://github.com/Maosef/easy-to-hard/tree/711ec0965229444a6c51b1b06a4e2cad3e32d02e | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Modified ResNet model class"""
def __init__(self, block, num_blocks, depth, width=1):
super().__init__()
self.iters = int((depth - 4) // 4)
self.in_planes = int(width * 64)
self.conv1... |
CA_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 CA_Block(nn.Module):
def __init__(self, in_dim):
super(CA_Block, self).__init__()
self.chanel_in = in_dim
self.gamma = nn.Parameter(torch.ones(1))
self.softmax = nn.Softmax(dim=-1)
def forward(self, x):
"""
inputs :... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | Mhaiyang/CVPR2021_PFNet | CA_Block | false | 8,556 | [
"BSD-3-Clause"
] | 24 | 2c4cab0730e6a0619fad79092f0b34f71c3b56c4 | https://github.com/Mhaiyang/CVPR2021_PFNet/tree/2c4cab0730e6a0619fad79092f0b34f71c3b56c4 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_dim):
super().__init__()
self.chanel_in = in_dim
self.gamma = nn.Parameter(torch.ones(1))
self.softmax = nn.Softmax(dim=-1)
def forward(self, x):
"""
inputs :
... |
MlpAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Self_Attn1D(nn.Module):
""" Self attention Layer """
def __init__(self, in_dim, activation, k=8):
super(Self_Attn1D, self).__init__()
self.chanel_in = in_dim
self.activation = activation
self.query_conv = nn.Conv1d(in_channels=in_dim, o... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.... | Malta-Lab/IUPE | MlpAttention | false | 8,557 | [
"MIT"
] | 10 | 44ddf119917538f02bb69509fec7a8314eed419f | https://github.com/Malta-Lab/IUPE/tree/44ddf119917538f02bb69509fec7a8314eed419f | import torch
import torch.nn as nn
class Self_Attn1D(nn.Module):
""" Self attention Layer """
def __init__(self, in_dim, activation, k=8):
super().__init__()
self.chanel_in = in_dim
self.activation = activation
self.query_conv = nn.Conv1d(in_channels=in_dim, out_channels=in_di... |
SquadDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SquadDiscriminator(nn.Module):
def __init__(self, feature_size):
super(SquadDiscriminator, self).__init__()
self.bilinear = nn.Bilinear(feature_size, feature_size, 1)
for m in self.modules():
self.weights_init(m)
def weights_init(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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | MiuLab/QAInfomax | SquadDiscriminator | false | 8,558 | [
"MIT"
] | 19 | 0985bc1df68d21c93de1bd6038d69f9792a9f62a | https://github.com/MiuLab/QAInfomax/tree/0985bc1df68d21c93de1bd6038d69f9792a9f62a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, feature_size):
super().__init__()
self.bilinear = nn.Bilinear(feature_size, feature_size, 1)
for m in self.modules():
self.weights_init(m)
def weights_init(self, m):
if isinstance(m, nn.... |
IOU | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class IOU(torch.nn.Module):
def __init__(self):
super(IOU, self).__init__()
def _iou(self, pred, target):
pred = torch.sigmoid(pred)
inter = (pred * target).sum(dim=(2, 3))
union = (pred + target).sum(dim=(2, 3)) - inter
iou = 1 - inter / union
re... | 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... | Mhaiyang/CVPR2021_PFNet | IOU | false | 8,559 | [
"BSD-3-Clause"
] | 24 | 2c4cab0730e6a0619fad79092f0b34f71c3b56c4 | https://github.com/Mhaiyang/CVPR2021_PFNet/tree/2c4cab0730e6a0619fad79092f0b34f71c3b56c4 | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def _iou(self, pred, target):
pred = torch.sigmoid(pred)
inter = (pred * target).sum(dim=(2, 3))
union = (pred + target).sum(dim=(2, 3)) - inter
iou = 1 - inter / union
return io... |
GaussianGenerator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
class GaussianGenerator(nn.Module):
def __init__(self, dims):
super(GaussianGenerator, self).__init__()
self.z_dim = dims[0]
self.linear_var = nn.Parameter(1.0 * torch.ones([self.z_dim]))
self.bias = nn.Parameter(torch.zeros([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
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... | MichaelArbel/GeneralizedEBM | GaussianGenerator | false | 8,560 | [
"BSD-3-Clause"
] | 40 | b2fb244bacef23a7347aecc0e8ff4863153f94f0 | https://github.com/MichaelArbel/GeneralizedEBM/tree/b2fb244bacef23a7347aecc0e8ff4863153f94f0 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dims):
super().__init__()
self.z_dim = dims[0]
self.linear_var = nn.Parameter(1.0 * torch.ones([self.z_dim]))
self.bias = nn.Parameter(torch.zeros([self.z_dim]))
self.lmbda = 0... |
ResBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResBlock(nn.Module):
def __init__(self, in_c):
super(ResBlock, self).__init__()
self.conv1 = nn.Conv2d(in_c, in_c, kernel_size=3, stride=1, padding
=1, bias=True)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(in_c, in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | MohitLamba94/LLPackNet | ResBlock | false | 8,561 | [
"MIT"
] | 15 | 440e20ac48aed0beca5f473358ec85d24d477575 | https://github.com/MohitLamba94/LLPackNet/tree/440e20ac48aed0beca5f473358ec85d24d477575 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_c):
super().__init__()
self.conv1 = nn.Conv2d(in_c, in_c, kernel_size=3, stride=1, padding
=1, bias=True)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(in_c, in_c, kernel_size=3... |
Summarize | # 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 Summarize(nn.Module):
def __init__(self):
super(Summarize, self).__init__()
self.sigmoid = nn.Sigmoid()
def forward(self, vec):
return self.sigmoid(torch.mean(vec, dim=1))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_ini... | 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... | MiuLab/QAInfomax | Summarize | false | 8,562 | [
"MIT"
] | 19 | 0985bc1df68d21c93de1bd6038d69f9792a9f62a | https://github.com/MiuLab/QAInfomax/tree/0985bc1df68d21c93de1bd6038d69f9792a9f62a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.sigmoid = nn.Sigmoid()
def forward(self, vec):
return self.sigmoid(torch.mean(vec, dim=1))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
ret... |
make_dense | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 make_dense(nn.Module):
def __init__(self, nChannels=64, growthRate=32, kernel_size=3):
super(make_dense, self).__init__()
self.conv = nn.Conv2d(nChannels, growthRate, kernel_size=
kernel_size, padding=(kernel_siz... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | MohitLamba94/LLPackNet | make_dense | false | 8,563 | [
"MIT"
] | 15 | 440e20ac48aed0beca5f473358ec85d24d477575 | https://github.com/MohitLamba94/LLPackNet/tree/440e20ac48aed0beca5f473358ec85d24d477575 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, nChannels=64, growthRate=32, kernel_size=3):
super().__init__()
self.conv = nn.Conv2d(nChannels, growthRate, kernel_size=
kernel_size, padding=(kernel_size - 1) // 2, bias=Fal... |
ScaledDotProductAttention | # 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 ScaledDotProductAttention(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | MinkiJ/SnaTCHer | ScaledDotProductAttention | false | 8,564 | [
"MIT"
] | 12 | 335c42469f0a7ad72c5c3480c8effc8c293823e0 | https://github.com/MinkiJ/SnaTCHer/tree/335c42469f0a7ad72c5c3480c8effc8c293823e0 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
""" Scaled Dot-Product Attention """
def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)
self.sof... |
SafeLog | # 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 SafeLog(nn.Module):
def __init__(self, eps=1e-06):
super(SafeLog, self).__init__()
self.eps = eps
def forward(self, X):
return torch.log(torch.clamp(X, min=self.eps))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inp... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | Mrswolf/brainda | SafeLog | false | 8,565 | [
"MIT"
] | 24 | cbd2fa6334d9e6243324dbaf086be4eb4047e801 | https://github.com/Mrswolf/brainda/tree/cbd2fa6334d9e6243324dbaf086be4eb4047e801 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps=1e-06):
super().__init__()
self.eps = eps
def forward(self, X):
return torch.log(torch.clamp(X, min=self.eps))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
retu... |
ScaledTanh | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
import torch.nn as nn
from torch import tanh
class ScaledTanh(nn.Module):
def __init__(self, factor):
super(ScaledTanh, self).__init__()
self.factor = factor
def forward(self, inputs: 'Tensor') ->Tensor:
return tanh(inputs) * self.factor
def ge... | 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_... | MhmdSyd/celldetection | ScaledTanh | false | 8,566 | [
"Apache-2.0"
] | 26 | 93e706953dc32eb694345179d5dcca5cfd9ff41b | https://github.com/MhmdSyd/celldetection/tree/93e706953dc32eb694345179d5dcca5cfd9ff41b | import torch
from torch import Tensor
import torch.nn as nn
from torch import tanh
class Model(nn.Module):
def __init__(self, factor):
super().__init__()
self.factor = factor
def forward(self, inputs: 'Tensor') ->Tensor:
return tanh(inputs) * self.factor
def get_inputs():
retur... |
MaxNormConstraintLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MaxNormConstraintLinear(nn.Linear):
def __init__(self, *args, max_norm_value=1, norm_axis=0, **kwargs):
self.max_norm_value = max_norm_value
self.norm_axis = norm_axis
super().__init__(*args, **kwargs)
def forward(self, input):
self.we... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Mrswolf/brainda | MaxNormConstraintLinear | false | 8,567 | [
"MIT"
] | 24 | cbd2fa6334d9e6243324dbaf086be4eb4047e801 | https://github.com/Mrswolf/brainda/tree/cbd2fa6334d9e6243324dbaf086be4eb4047e801 | import torch
import torch.nn as nn
class Model(nn.Linear):
def __init__(self, *args, max_norm_value=1, norm_axis=0, **kwargs):
self.max_norm_value = max_norm_value
self.norm_axis = norm_axis
super().__init__(*args, **kwargs)
def forward(self, input):
self.weight.data = self._... |
CNN3dModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class CNN3dModel(torch.nn.ModuleDict):
def __init__(self, D_in=1, D_out=1):
super(CNN3dModel, self).__init__()
self.conv3d = torch.nn.Conv3d(D_in, D_in * 2, kernel_size=2, stride
=2, padding=1)
self.conv3d2 = torch.nn.Conv3d(D_in * 2, D_in * 2, kernel_size=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
assert_size_stride = torch._C... | MilesCranmer/Sapsan | CNN3dModel | false | 8,568 | [
"BSD-3-Clause"
] | 11 | 4d21954baf196ede2d4dafc765aed98a0cfca21b | https://github.com/MilesCranmer/Sapsan/tree/4d21954baf196ede2d4dafc765aed98a0cfca21b | import torch
class Model(torch.nn.ModuleDict):
def __init__(self, D_in=1, D_out=1):
super().__init__()
self.conv3d = torch.nn.Conv3d(D_in, D_in * 2, kernel_size=2, stride
=2, padding=1)
self.conv3d2 = torch.nn.Conv3d(D_in * 2, D_in * 2, kernel_size=2,
stride=2, pad... |
LabelSmoothingCrossEntropy | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
class LabelSmoothingCrossEntropy(nn.Module):
""" NLL loss with label smoothing.
"""
def __init__(self, smoothing=0.1, loss_weight=1.0, loss_name='loss_ce'):
super(LabelSmoothingCrossEntrop... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch._C
import... | Molly6/segmentation_shengteng2021 | LabelSmoothingCrossEntropy | false | 8,569 | [
"Apache-2.0"
] | 21 | 33dfefa80193586f504069793d9e141944549e99 | https://github.com/Molly6/segmentation_shengteng2021/tree/33dfefa80193586f504069793d9e141944549e99 | import torch
import torch._C
import torch.serialization
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
""" NLL loss with label smoothing.
"""
def __init__(self, smoothing=0.1, loss_weight=1.0, loss_name='loss_ce'):
super().__init__()
assert smoothing < 1.0
... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class ResidualBlock(nn.Module):
"""
Residual block from R2D3/IMPALA
Taken from [1,2]
"""
def __init__(self, num_channels, first_conv_weight_scale):
super().__init__()
self.conv1 = nn.Conv2d(num_channels, num_channe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | Miffyli/minecraft-bc-2020 | ResidualBlock | false | 8,570 | [
"MIT"
] | 11 | 94f8706e547474a2ed8cacd41bb20e59f672215f | https://github.com/Miffyli/minecraft-bc-2020/tree/94f8706e547474a2ed8cacd41bb20e59f672215f | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Residual block from R2D3/IMPALA
Taken from [1,2]
"""
def __init__(self, num_channels, first_conv_weight_scale):
super().__init__()
self.conv1 = nn.Conv2d(num_channels, num_channels, kern... |
Square | # 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 Square(nn.Module):
def __init__(self):
super(Square, self).__init__()
def forward(self, X):
return torch.square(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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | Mrswolf/brainda | Square | false | 8,571 | [
"MIT"
] | 24 | cbd2fa6334d9e6243324dbaf086be4eb4047e801 | https://github.com/Mrswolf/brainda/tree/cbd2fa6334d9e6243324dbaf086be4eb4047e801 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, X):
return torch.square(X)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
SpatialAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class SpatialAttention(nn.Module):
def __init__(self, kernel_size=7):
super(SpatialAttention, self).__init__()
self.conv1 = nn.Conv1d(2, 1, kernel_size, padding=kernel_size // 2,
bias=False)
self.sigmoid = nn.Sigmoid()
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
import torch.nn as nn
assert_... | Ming-er/NeuralNILM_Pytorch | SpatialAttention | false | 8,572 | [
"MIT"
] | 22 | 90123a3cf7d8dedc7f513ff784a45f178aa10a9d | https://github.com/Ming-er/NeuralNILM_Pytorch/tree/90123a3cf7d8dedc7f513ff784a45f178aa10a9d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, kernel_size=7):
super().__init__()
self.conv1 = nn.Conv1d(2, 1, kernel_size, padding=kernel_size // 2,
bias=False)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
avg_out = torch.mean(... |
weightedLoss | # 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 weightedLoss(nn.Module):
def __init__(self):
super().__init__()
self.thresholds = [0.5, 2, 5, 10, 30]
self.weights = [1, 1, 2, 5, 10, 30]
def forward(self, pred, label):
weights = torch.ones_like(pred) * 3
for i, threshold in en... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_... | Mikubill/GAN-ConvLSTM | weightedLoss | false | 8,573 | [
"MIT"
] | 16 | 943525f62a3ab462a625c72534b3188cd583d839 | https://github.com/Mikubill/GAN-ConvLSTM/tree/943525f62a3ab462a625c72534b3188cd583d839 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.thresholds = [0.5, 2, 5, 10, 30]
self.weights = [1, 1, 2, 5, 10, 30]
def forward(self, pred, label):
weights = torch.ones_like(pred) * 3
for i, threshold in enumerate... |
Scaled_Dot_Product_Attention | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Scaled_Dot_Product_Attention(nn.Module):
"""Scaled Dot-Product Attention """
def __init__(self):
super(Scaled_Dot_Product_Attention, self).__init__()
def forward(self, Q, K, V, scale=None):
"""
Args:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | NTDXYG/Text-Classify-based-pytorch | Scaled_Dot_Product_Attention | false | 8,574 | [
"Apache-2.0"
] | 20 | b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | https://github.com/NTDXYG/Text-Classify-based-pytorch/tree/b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Scaled Dot-Product Attention """
def __init__(self):
super().__init__()
def forward(self, Q, K, V, scale=None):
"""
Args:
Q: [batch_size, len_Q, dim_Q]
K: [batch_... |
ResBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResBlock(nn.Module):
def __init__(self, in_channel, out_channel, ker_size, stri, pad):
super(ResBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channel, out_channel, 3, 1, 1)
self.conv2 = nn.Conv2d(out_channel, out... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | NJUVISION/AWnet | ResBlock | false | 8,575 | [
"MIT"
] | 16 | f47a1692819a778b513b882d36ed727f7732d37b | https://github.com/NJUVISION/AWnet/tree/f47a1692819a778b513b882d36ed727f7732d37b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channel, out_channel, ker_size, stri, pad):
super().__init__()
self.conv1 = nn.Conv2d(in_channel, out_channel, 3, 1, 1)
self.conv2 = nn.Conv2d(out_channel, out_channel, 3, 1, 1... |
AdaptiveInstanceNorm_H | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.utils.data
import torch.utils.data.distributed
class AdaptiveInstanceNorm_H(nn.Module):
def __init__(self, in_channel, map_size):
super().__init__()
self.norm = nn.LayerNorm([map_size, map_size])
self.weight = nn.Parameter(1000.0 + torch.rand... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
import torch.utils.data
import torch.utils.data.distribute... | MiaoyunZhao/GANTransferLimitedData | AdaptiveInstanceNorm_H | false | 8,576 | [
"MIT"
] | 41 | 5545bc37a1d7d4f28a9c3588aaa12a616bbddd88 | https://github.com/MiaoyunZhao/GANTransferLimitedData/tree/5545bc37a1d7d4f28a9c3588aaa12a616bbddd88 | import torch
from torch import nn
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, in_channel, map_size):
super().__init__()
self.norm = nn.LayerNorm([map_size, map_size])
self.weight = nn.Parameter(1000.0 + torch.randn(1, in_channel, ... |
Position_wise_Feed_Forward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Position_wise_Feed_Forward(nn.Module):
def __init__(self, dim_model, hidden, dropout=0.0):
super(Position_wise_Feed_Forward, self).__init__()
self.fc1 = nn.Linear(dim_model, hidden)
self.fc2 = nn.Linear(hidden, dim_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.... | NTDXYG/Text-Classify-based-pytorch | Position_wise_Feed_Forward | false | 8,577 | [
"Apache-2.0"
] | 20 | b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | https://github.com/NTDXYG/Text-Classify-based-pytorch/tree/b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim_model, hidden, dropout=0.0):
super().__init__()
self.fc1 = nn.Linear(dim_model, hidden)
self.fc2 = nn.Linear(hidden, dim_model)
self.dropout = nn.Dropout(dropout)
... |
CopyChannels | # 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 CopyChannels(torch.nn.Module):
def __init__(self, multiple=3, dim=1):
super(CopyChannels, self).__init__()
self.multiple = multiple
self.dim = dim
def forward(self, x):
return torch.cat([x for _ in range(self.multiple)], dim=self.dim)
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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
reinterpret... | NehzUx/autodl | CopyChannels | false | 8,578 | [
"Apache-2.0"
] | 25 | c80fdc4b297ed1ec2b9e6911d313f1fe31d83cb9 | https://github.com/NehzUx/autodl/tree/c80fdc4b297ed1ec2b9e6911d313f1fe31d83cb9 | import torch
class Model(torch.nn.Module):
def __init__(self, multiple=3, dim=1):
super().__init__()
self.multiple = multiple
self.dim = dim
def forward(self, x):
return torch.cat([x for _ in range(self.multiple)], dim=self.dim)
def get_inputs():
return [torch.rand([4, ... |
BBoxTransform | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class BBoxTransform(nn.Module):
def forward(self, anchors, regression):
"""
decode_box_outputs adapted from https://github.com/google/automl/blob/master/effic... | 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 ... | NHERI-SimCenter/BRAILS | BBoxTransform | false | 8,579 | [
"BSD-3-Clause"
] | 22 | ec17bcd000b15cb8c2933728fe2fd1fb190cd852 | https://github.com/NHERI-SimCenter/BRAILS/tree/ec17bcd000b15cb8c2933728fe2fd1fb190cd852 | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def forward(self, anchors, regression):
"""
decode_box_outputs adapted from https://github.com/google/automl/blob/master/efficientdet/... |
BinaryCrossEntropyLabelSmooth | # 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 BinaryCrossEntropyLabelSmooth(torch.nn.BCEWithLogitsLoss):
def __init__(self, num_classes, epsilon=0.1, weight=None, size_average=
None, reduce=None, reduction='mean', pos_weight=None):
super(BinaryCrossEntropyLabelSmooth, self).__init__(weight,
size_average, reduce... | 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
assert_size... | NehzUx/autodl | BinaryCrossEntropyLabelSmooth | false | 8,580 | [
"Apache-2.0"
] | 25 | c80fdc4b297ed1ec2b9e6911d313f1fe31d83cb9 | https://github.com/NehzUx/autodl/tree/c80fdc4b297ed1ec2b9e6911d313f1fe31d83cb9 | import torch
class Model(torch.nn.BCEWithLogitsLoss):
def __init__(self, num_classes, epsilon=0.1, weight=None, size_average=
None, reduce=None, reduction='mean', pos_weight=None):
super().__init__(weight,
size_average, reduce, reduction, pos_weight)
self.num_classes = num_cla... |
Conv2dStaticSamePadding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torchvision.transforms import functional as F
class Conv2dStaticSamePadding(nn.Module):
"""
created by Zylo117
The real keras/tensorflow conv2d with same padding
"""
def __init__(self, in_channels, out_channel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | NaCl-Ocean/Anchor_free_detection_rotation | Conv2dStaticSamePadding | false | 8,581 | [
"MIT"
] | 12 | 358d9f5df1beabc7a05a352d2cfa2283b17825a9 | https://github.com/NaCl-Ocean/Anchor_free_detection_rotation/tree/358d9f5df1beabc7a05a352d2cfa2283b17825a9 | import math
import torch
from torch import nn
from torch.nn import functional as F
from torchvision.transforms import functional as F
class Model(nn.Module):
"""
created by Zylo117
The real keras/tensorflow conv2d with same padding
"""
def __init__(self, in_channels, out_channels, kernel_size, st... |
TestTimeIN | # 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
import torch.utils.data
import torch.utils.data.distributed
class TestTimeIN(nn.BatchNorm2d):
def __init__(self, num_features: 'int', eps: 'float'=1e-05, momentum:
'float'=1, affine: 'bool'=True, track_running_stats: 'bool'=Tr... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import... | MosyMosy/Pytorch_ImaneNet_With_wandb | TestTimeIN | false | 8,582 | [
"MIT"
] | 30 | b7b6e245e29ec342212025b8164e5053d4197fa1 | https://github.com/MosyMosy/Pytorch_ImaneNet_With_wandb/tree/b7b6e245e29ec342212025b8164e5053d4197fa1 | import torch
import torch.nn as nn
import torch.optim
import torch.nn.parallel
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.BatchNorm2d):
def __init__(self, num_features: 'int', eps: 'float'=1e-05, momentum:
'float'=1, affine: 'bool'=True, track_running_stats: 'bool'=True):
... |
MaxNormConstraintConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MaxNormConstraintConv2d(nn.Conv2d):
def __init__(self, *args, max_norm_value=1, norm_axis=2, **kwargs):
self.max_norm_value = max_norm_value
self.norm_axis = norm_axis
super().__init__(*args, **kwargs)
def forward(self, input):
self.we... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Mrswolf/brainda | MaxNormConstraintConv2d | false | 8,583 | [
"MIT"
] | 24 | cbd2fa6334d9e6243324dbaf086be4eb4047e801 | https://github.com/Mrswolf/brainda/tree/cbd2fa6334d9e6243324dbaf086be4eb4047e801 | import torch
import torch.nn as nn
class Model(nn.Conv2d):
def __init__(self, *args, max_norm_value=1, norm_axis=2, **kwargs):
self.max_norm_value = max_norm_value
self.norm_axis = norm_axis
super().__init__(*args, **kwargs)
def forward(self, input):
self.weight.data = self._... |
FeedForwardBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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
import torch.nn.functional as F
class PositionwiseFeedForward(nn.Module):
def __init__(self, config):
super(PositionwiseFeedForward, self).__init__()
self.w_1 = nn.Linear(config.d_model, config.d_f... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | MSU-MLSys-Lab/CATE | FeedForwardBlock | false | 8,584 | [
"Apache-2.0"
] | 15 | 654c393d7df888d2c3f3b90f9e6752faa061157e | https://github.com/MSU-MLSys-Lab/CATE/tree/654c393d7df888d2c3f3b90f9e6752faa061157e | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.utils
import torch.nn.functional as F
class PositionwiseFeedForward(nn.Module):
def __init__(self, config):
super().__init__()
self.w_1 = nn.Linear(config.d_model, config.d_ff)
self.w_2 = nn.Line... |
SmoothL1loss_with_weight | # 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 SmoothL1loss_with_weight(nn.Module):
def __init__(self):
super(SmoothL1loss_with_weight, self).__init__()
def forward(self, pred, targets, weights):
assert pred.shape[0] == targets.shape[0] == weights.shape[0]
loss = nn.SmoothL1Loss(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 import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | NaCl-Ocean/Anchor_free_detection_rotation | SmoothL1loss_with_weight | false | 8,585 | [
"MIT"
] | 12 | 358d9f5df1beabc7a05a352d2cfa2283b17825a9 | https://github.com/NaCl-Ocean/Anchor_free_detection_rotation/tree/358d9f5df1beabc7a05a352d2cfa2283b17825a9 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, targets, weights):
assert pred.shape[0] == targets.shape[0] == weights.shape[0]
loss = nn.SmoothL1Loss(reduction='none')(pred, targets)
loss = loss.sum(dim... |
SoftHistogram | # 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 SoftHistogram(torch.nn.Module):
"""
Motivated by https://discuss.pytorch.org/t/differentiable-torch-histc/25865/3
"""
def __init__(self, bins, min_bin_edge, max_bin_edge, sigma):
super(SoftHistogram, self).__init__()
self.sigma = sigma
self.delta = float(max... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | NiallJeffrey/DeepMass | SoftHistogram | false | 8,586 | [
"MIT"
] | 13 | 6bf11bd08082562161a2f91cd40dc57abba12396 | https://github.com/NiallJeffrey/DeepMass/tree/6bf11bd08082562161a2f91cd40dc57abba12396 | import torch
class Model(torch.nn.Module):
"""
Motivated by https://discuss.pytorch.org/t/differentiable-torch-histc/25865/3
"""
def __init__(self, bins, min_bin_edge, max_bin_edge, sigma):
super().__init__()
self.sigma = sigma
self.delta = float(max_bin_edge - min_bin_edge) /... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch
import torch._utils
import torch.nn as nn
class FocalLoss(nn.Module):
def __init__(self, gamma=0, eps=1e-07):
super(FocalLoss, self).__init__()
self.gamma = gamma
self.eps = eps
self.ce = torch.nn.CrossEntropyLoss()
def forwar... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.dat... | Mukosame/AODA | FocalLoss | false | 8,587 | [
"BSD-3-Clause"
] | 43 | c187e5ff0a6502a9166da37a213ee259afa60903 | https://github.com/Mukosame/AODA/tree/c187e5ff0a6502a9166da37a213ee259afa60903 | import torch
import torch.utils.data
import torch
import torch._utils
import torch.nn as nn
class Model(nn.Module):
def __init__(self, gamma=0, eps=1e-07):
super().__init__()
self.gamma = gamma
self.eps = eps
self.ce = torch.nn.CrossEntropyLoss()
def forward(self, input, targ... |
ConvEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class ConvEncoder(nn.Module):
def __init__(self, input_dim=512, output_dim=512, kernel_size=1,
init_scale=1.0, no_weight_init=False):
super(ConvEncoder, self).__init__()
self.conv = nn.Conv1d(input_dim, output_dim, kernel_s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | KH-Kyle/rmp_nav | ConvEncoder | false | 8,588 | [
"MIT"
] | 30 | d598fe70664a4cdc0e9b9dd4b52e84aa3de1b551 | https://github.com/KH-Kyle/rmp_nav/tree/d598fe70664a4cdc0e9b9dd4b52e84aa3de1b551 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_dim=512, output_dim=512, kernel_size=1,
init_scale=1.0, no_weight_init=False):
super().__init__()
self.conv = nn.Conv1d(input_dim, output_dim, kernel_size=kernel_size)
... |
CrossEntropyLoss | # 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 CrossEntropyLoss
import torch.nn.functional as F
def _is_long(x):
if hasattr(x, 'data'):
x = x.data
return isinstance(x, torch.LongTensor) or isinstance(x, torch.LongTensor)
def cross_entropy(inputs, target, weight=None, ignore_index=-100, reduc... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
i... | MutualMarkets/gap | CrossEntropyLoss | false | 8,589 | [
"MIT"
] | 29 | 328b0b7bee1aad8738ddb0f94b4fe49b2e250034 | https://github.com/MutualMarkets/gap/tree/328b0b7bee1aad8738ddb0f94b4fe49b2e250034 | import torch
from torch import nn
from torch.nn import CrossEntropyLoss
import torch.nn.functional as F
def _is_long(x):
if hasattr(x, 'data'):
x = x.data
return isinstance(x, torch.LongTensor) or isinstance(x, torch.LongTensor)
def cross_entropy(inputs, target, weight=None, ignore_index=-100, reduc... |
DaiNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DaiNet(nn.Module):
def __init__(self):
super(DaiNet, self).__init__()
self.conv1 = nn.Conv2d(3, 12, 5)
self.dp = nn.Dropout(0.5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(12, 24, 3)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | MaxChanger/pytorch-cifar | DaiNet | false | 8,590 | [
"MIT"
] | 20 | 217fd2cf7e603fe9a8d3d97f2085606bc43a356a | https://github.com/MaxChanger/pytorch-cifar/tree/217fd2cf7e603fe9a8d3d97f2085606bc43a356a | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 12, 5)
self.dp = nn.Dropout(0.5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(12, 24, 3)
self.dp = n... |
LayerNormGRUCell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class LayerNormGRUCell(torch.nn.Module):
def __init__(self, input_size, hidden_size, bias=True):
super(LayerNormGRUCell, self).__init__()
self.ln_i2h = torch.nn.LayerNorm(2 * hidden_size,
elementwise_affine=False)
self.ln_h2h = torch.nn.LayerNorm(2 * h... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
assert_... | NeuroAI-PI/AI-Grand-Challenge-2021 | LayerNormGRUCell | false | 8,591 | [
"MIT"
] | 21 | aed2c31ce90cafe15895a11fadb9d88abd0c8765 | https://github.com/NeuroAI-PI/AI-Grand-Challenge-2021/tree/aed2c31ce90cafe15895a11fadb9d88abd0c8765 | import math
import torch
class Model(torch.nn.Module):
def __init__(self, input_size, hidden_size, bias=True):
super().__init__()
self.ln_i2h = torch.nn.LayerNorm(2 * hidden_size,
elementwise_affine=False)
self.ln_h2h = torch.nn.LayerNorm(2 * hidden_size,
elementwi... |
PositionalEncoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.init
class PositionalEncoding(nn.Module):
def __init__(self, emb_size: 'int', spatial_size: 'int'):
super(PositionalEncoding, self).__init__()
self.emb_size = emb_size
self.spatial_size = spatial_size
self.posit... | 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.init
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_... | NimrodShabtay/transformers-dip | PositionalEncoding | false | 8,592 | [
"MIT"
] | 25 | 61bc3008114ca950e7ea6341ae8ff317d9353f40 | https://github.com/NimrodShabtay/transformers-dip/tree/61bc3008114ca950e7ea6341ae8ff317d9353f40 | import torch
import torch.nn as nn
import torch.optim
import torch.nn.init
class Model(nn.Module):
def __init__(self, emb_size: 'int', spatial_size: 'int'):
super().__init__()
self.emb_size = emb_size
self.spatial_size = spatial_size
self.positions = nn.Parameter(torch.randn(self.... |
Multi_Head_Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Scaled_Dot_Product_Attention(nn.Module):
"""Scaled Dot-Product Attention """
def __init__(self):
super(Scaled_Dot_Product_Attention, self).__init__()
def forward(self, Q, K, V, scale=None):
"""
Args:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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... | NTDXYG/Text-Classify-based-pytorch | Multi_Head_Attention | false | 8,593 | [
"Apache-2.0"
] | 20 | b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | https://github.com/NTDXYG/Text-Classify-based-pytorch/tree/b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Scaled_Dot_Product_Attention(nn.Module):
"""Scaled Dot-Product Attention """
def __init__(self):
super().__init__()
def forward(self, Q, K, V, scale=None):
"""
Args:
Q: [batch_size, len_Q, dim_Q]... |
Mul | # 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 Mul(torch.nn.Module):
def __init__(self, weight):
super(Mul, self).__init__()
self.weight = weight
def forward(self, x):
return x * self.weight
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {'weight': 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | NehzUx/autodl | Mul | false | 8,594 | [
"Apache-2.0"
] | 25 | c80fdc4b297ed1ec2b9e6911d313f1fe31d83cb9 | https://github.com/NehzUx/autodl/tree/c80fdc4b297ed1ec2b9e6911d313f1fe31d83cb9 | import torch
class Model(torch.nn.Module):
def __init__(self, weight):
super().__init__()
self.weight = weight
def forward(self, x):
return x * self.weight
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [4]
|
DeepSVDDLoss | # 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 functools import reduce
import torch.nn as nn
class BaseModule(nn.Module):
"""
Implements the basic module.
All other modules inherit from this one
"""
def load_w(self, checkpoint_path):
"""
Loads a checkpoint into the state_dict.
:param checkpoint_path:... | 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 functools import reduce
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | NjuHaoZhang/AutoregressModel-AE_VAD_CVPR2019 | DeepSVDDLoss | false | 8,595 | [
"MIT"
] | 12 | b9843f34ecb59f908d78ddf977ee4670e0ed6cb4 | https://github.com/NjuHaoZhang/AutoregressModel-AE_VAD_CVPR2019/tree/b9843f34ecb59f908d78ddf977ee4670e0ed6cb4 | import torch
from functools import reduce
import torch.nn as nn
class BaseModule(nn.Module):
"""
Implements the basic module.
All other modules inherit from this one
"""
def load_w(self, checkpoint_path):
"""
Loads a checkpoint into the state_dict.
:param checkpoint_path:... |
FFNLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def gelu(x):
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
class FFNLayer(nn.Module):
def __init__(self, input_dim, intermediate_dim, output_dim, dropout,
layer_norm=True):
super(FFNLayer, self).__init__()
self.fc1 = nn.Linear(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
import ... | NExTplusplus/tat-qa | FFNLayer | false | 8,596 | [
"MIT"
] | 23 | 4ce5d8e637b80143de0d2492ecd4b861d6ba9a89 | https://github.com/NExTplusplus/tat-qa/tree/4ce5d8e637b80143de0d2492ecd4b861d6ba9a89 | import math
import torch
import torch.nn as nn
def gelu(x):
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
class Model(nn.Module):
def __init__(self, input_dim, intermediate_dim, output_dim, dropout,
layer_norm=True):
super().__init__()
self.fc1 = nn.Linear(input_dim, interm... |
MessagePassing | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch._C
import torch.serialization
from torch import nn
from torch.nn import Parameter
def make_onehot_kernel(kernel_size, index):
"""
Make 2D one hot square kernel, i.e. h=w
k[kernel_size, kernel_size] = 0 except k.view(-1)[index] = 1
"""
kernel = torch.zeros(kernel_size, ker... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | Molly6/segmentation_shengteng2021 | MessagePassing | false | 8,597 | [
"Apache-2.0"
] | 21 | 33dfefa80193586f504069793d9e141944549e99 | https://github.com/Molly6/segmentation_shengteng2021/tree/33dfefa80193586f504069793d9e141944549e99 | import torch
import torch._C
import torch.serialization
from torch import nn
from torch.nn import Parameter
def make_onehot_kernel(kernel_size, index):
"""
Make 2D one hot square kernel, i.e. h=w
k[kernel_size, kernel_size] = 0 except k.view(-1)[index] = 1
"""
kernel = torch.zeros(kernel_size, ker... |
MlpWithAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Self_Attn1D(nn.Module):
""" Self attention Layer """
def __init__(self, in_dim, activation, k=8):
super(Self_Attn1D, self).__init__()
self.chanel_in = in_dim
self.activation = activation
self.query_conv = nn.Conv1d(in_channels=in_dim, o... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.... | Malta-Lab/IUPE | MlpWithAttention | false | 8,600 | [
"MIT"
] | 10 | 44ddf119917538f02bb69509fec7a8314eed419f | https://github.com/Malta-Lab/IUPE/tree/44ddf119917538f02bb69509fec7a8314eed419f | import torch
import torch.nn as nn
class Self_Attn1D(nn.Module):
""" Self attention Layer """
def __init__(self, in_dim, activation, k=8):
super().__init__()
self.chanel_in = in_dim
self.activation = activation
self.query_conv = nn.Conv1d(in_channels=in_dim, out_channels=in_di... |
IWEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 IWConv2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, he_init=True,
stride=1, bias=True):
super(IWConv2d, self).__init__()
self.he_init = he_init
self.padding = int((kernel_size - 1) / 2)
self.conv = nn.Conv2d(i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | MIC-DKFZ/mood | IWEncoder | false | 8,601 | [
"Apache-2.0"
] | 42 | a01303adb4256653b133e2f7cd4741d366b681f7 | https://github.com/MIC-DKFZ/mood/tree/a01303adb4256653b133e2f7cd4741d366b681f7 | import torch
from torch import nn
class IWConv2d(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, outp... |
ReconstructionLoss | # 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 functools import reduce
import torch.nn as nn
class BaseModule(nn.Module):
"""
Implements the basic module.
All other modules inherit from this one
"""
def load_w(self, checkpoint_path):
"""
Loads a checkpoint into the state_dict.
:param checkpoint_path:... | 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 functools import reduce
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | NjuHaoZhang/AutoregressModel-AE_VAD_CVPR2019 | ReconstructionLoss | false | 8,607 | [
"MIT"
] | 12 | b9843f34ecb59f908d78ddf977ee4670e0ed6cb4 | https://github.com/NjuHaoZhang/AutoregressModel-AE_VAD_CVPR2019/tree/b9843f34ecb59f908d78ddf977ee4670e0ed6cb4 | import torch
from functools import reduce
import torch.nn as nn
class BaseModule(nn.Module):
"""
Implements the basic module.
All other modules inherit from this one
"""
def load_w(self, checkpoint_path):
"""
Loads a checkpoint into the state_dict.
:param checkpoint_path:... |
Mish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
import torch.optim
class Mish(Module):
"""
Mish Activation Layer
Applies a Mish activation function to the input
Inherits from:
Module (nn.module.Module)
"""
def __init__(self) ->None:
super().... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch.nn import Module
import torch.optim
assert_size_str... | PABannier/nanograd | Mish | false | 8,609 | [
"MIT"
] | 18 | 5acd355c638885cbfc0fd0f1c4903964e7fb7de9 | https://github.com/PABannier/nanograd/tree/5acd355c638885cbfc0fd0f1c4903964e7fb7de9 | from torch.nn import Module
import torch
from torch import Tensor
import torch.optim
class Model(Module):
"""
Mish Activation Layer
Applies a Mish activation function to the input
Inherits from:
Module (nn.module.Module)
"""
def __init__(self) ->None:
super()... |
EdgeLoss | # 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 EdgeLoss(nn.Module):
def __init__(self):
"""
Return Binary Entropy Loss with mean of all losses in each mini-batch
"""
super(EdgeLoss, self).__init__()
self.cross_entropy = nn.BCELoss(reduction='mean')
def forward(self, y, y_pr... | 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... | Nikronic/EdgeNet | EdgeLoss | false | 8,610 | [
"MIT"
] | 12 | ec649af303bd7d5397fd3d4cbf8736bd83756abb | https://github.com/Nikronic/EdgeNet/tree/ec649af303bd7d5397fd3d4cbf8736bd83756abb | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
"""
Return Binary Entropy Loss with mean of all losses in each mini-batch
"""
super().__init__()
self.cross_entropy = nn.BCELoss(reduction='mean')
def forward(self, y, y_pred):
loss... |
CNNEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn import functional as F
class CNNEncoder(nn.Module):
def __init__(self, out_channels: 'int', kernel_size: 'tuple'):
super(CNNEncoder, self).__init__()
self.cnn_encoder = nn.Conv2d(in_channels=1, out_channels=
out_channels, kernel_size=ke... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | OwenLeng/Early-Detection-of-Fake-News-on-Social-Media-Through-Propagation-Path-Classification-with-pytorch- | CNNEncoder | false | 8,612 | [
"MIT"
] | 38 | 39f8b7508240ebf58a3cdcf69fbb838a4239e0e5 | https://github.com/OwenLeng/Early-Detection-of-Fake-News-on-Social-Media-Through-Propagation-Path-Classification-with-pytorch-/tree/39f8b7508240ebf58a3cdcf69fbb838a4239e0e5 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, out_channels: 'int', kernel_size: 'tuple'):
super().__init__()
self.cnn_encoder = nn.Conv2d(in_channels=1, out_channels=
out_channels, kernel_size=kernel_size)
def f... |
_Mean | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.jit
class _Mean(nn.Module):
def forward(self, input: 'torch.Tensor') ->torch.Tensor:
return input.mean()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.jit
assert_size_stride = torch._C._dynamo.guards.asser... | One-sixth/ms_ssim_pytorch | _Mean | false | 8,615 | [
"MIT"
] | 42 | 6269c62e0dd29c91fa38e4ba73d906d0c84ca966 | https://github.com/One-sixth/ms_ssim_pytorch/tree/6269c62e0dd29c91fa38e4ba73d906d0c84ca966 | import torch
import torch.nn as nn
import torch.jit
class Model(nn.Module):
def forward(self, input: 'torch.Tensor') ->torch.Tensor:
return input.mean()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
NetTan2018 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 NetTan2018(nn.Module):
def __init__(self, in_channels=3, out_classes=2):
super(NetTan2018, self).__init__()
oc = 16
self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=oc,
kernel_size=(3, 3), pad... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Nicolik/SimpleCNNClassifier | NetTan2018 | false | 8,616 | [
"MIT"
] | 11 | e5cd37fbde90f4096183658abe3f8836be92a8f2 | https://github.com/Nicolik/SimpleCNNClassifier/tree/e5cd37fbde90f4096183658abe3f8836be92a8f2 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels=3, out_classes=2):
super().__init__()
oc = 16
self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=oc,
kernel_size=(3, 3), padding=0)
self.... |
CRFRNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch._C
import torch.serialization
from torch import nn
from torch.nn import init
from torch.nn import Parameter
def make_onehot_kernel(kernel_size, index):
"""
Make 2D one hot square kernel, i.e. h=w
k[kernel_size, kernel_size] = 0 except k.view(-1)[index] = 1
"""
kernel = to... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Molly6/segmentation_shengteng2021 | CRFRNN | false | 8,617 | [
"Apache-2.0"
] | 21 | 33dfefa80193586f504069793d9e141944549e99 | https://github.com/Molly6/segmentation_shengteng2021/tree/33dfefa80193586f504069793d9e141944549e99 | import torch
import torch._C
import torch.serialization
from torch import nn
from torch.nn import init
from torch.nn import Parameter
def make_onehot_kernel(kernel_size, index):
"""
Make 2D one hot square kernel, i.e. h=w
k[kernel_size, kernel_size] = 0 except k.view(-1)[index] = 1
"""
kernel = to... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self, in_channels=3, out_features=2):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=32,
kernel_size=(3, 3), padding=1)
self.pool1 = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | Nicolik/SimpleCNNClassifier | Net | false | 8,618 | [
"MIT"
] | 11 | e5cd37fbde90f4096183658abe3f8836be92a8f2 | https://github.com/Nicolik/SimpleCNNClassifier/tree/e5cd37fbde90f4096183658abe3f8836be92a8f2 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels=3, out_features=2):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=32,
kernel_size=(3, 3), padding=1)
self.pool1 = nn.MaxP... |
CELoss | # 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 CELoss(nn.Module):
def __init__(self):
super(CELoss, self).__init__()
def forward(self, y_pred, y_true):
return -torch.mean(torch.sum(y_true * torch.log(F.softmax(y_pred,
dim=1)), dim=1))
def get_inputs():... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | PARMAGroup/UNet-Instance-Cell-Segmentation | CELoss | false | 8,620 | [
"MIT"
] | 30 | 79655a2c5781d2e20c7d5760f631fbb0be392292 | https://github.com/PARMAGroup/UNet-Instance-Cell-Segmentation/tree/79655a2c5781d2e20c7d5760f631fbb0be392292 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, y_pred, y_true):
return -torch.mean(torch.sum(y_true * torch.log(F.softmax(y_pred,
dim=1)), dim=1))
def get_inputs():
return [... |
PositionalEncoder | # 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
class PositionalEncoder(torch.nn.Module):
def __init__(self, max_freq, feat_size, dimensionality, base=2):
super().__init__()
self.max_freq = max_freq
self.dimensionality = dimensionality
self.num_bands = math.floor(feat_size / dimensionality / 2)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda... | PRBonn/contrastive_association | PositionalEncoder | false | 8,622 | [
"MIT"
] | 19 | 649693494197c8d3948252daee6767b66a89c868 | https://github.com/PRBonn/contrastive_association/tree/649693494197c8d3948252daee6767b66a89c868 | import math
import torch
class Model(torch.nn.Module):
def __init__(self, max_freq, feat_size, dimensionality, base=2):
super().__init__()
self.max_freq = max_freq
self.dimensionality = dimensionality
self.num_bands = math.floor(feat_size / dimensionality / 2)
self.base = ... |
WrapperKLDiv | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
from torch import nn
class WrapperKLDiv(nn.Module):
"""Wrapper for KL-Divergence for easy argument passing."""
def __init__(self, reduction: 'str'='mean') ->None:
"""Constructor.
Args:
reduction (str, optional): One of 'none','batchmean','sum... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | PaccMann/paccmann_datasets | WrapperKLDiv | false | 8,623 | [
"MIT"
] | 14 | 0cb0cee349ffab8e227f09f7df0a8bca6a71f22e | https://github.com/PaccMann/paccmann_datasets/tree/0cb0cee349ffab8e227f09f7df0a8bca6a71f22e | import torch
from torch import Tensor
from torch import nn
class Model(nn.Module):
"""Wrapper for KL-Divergence for easy argument passing."""
def __init__(self, reduction: 'str'='mean') ->None:
"""Constructor.
Args:
reduction (str, optional): One of 'none','batchmean','sum', 'mea... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class DiceLoss(nn.Module):
def __init__(self, smooth=1):
super(DiceLoss, self).__init__()
self.smooth = smooth
def dice_coef(self, y_pred, y_true):
pred_probs = torch.sigmoid(y_pred)
y_true_f = y_true.view(-1)
y_pred_f = pred_probs.v... | 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... | PARMAGroup/UNet-Instance-Cell-Segmentation | DiceLoss | false | 8,624 | [
"MIT"
] | 30 | 79655a2c5781d2e20c7d5760f631fbb0be392292 | https://github.com/PARMAGroup/UNet-Instance-Cell-Segmentation/tree/79655a2c5781d2e20c7d5760f631fbb0be392292 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, smooth=1):
super().__init__()
self.smooth = smooth
def dice_coef(self, y_pred, y_true):
pred_probs = torch.sigmoid(y_pred)
y_true_f = y_true.view(-1)
y_pred_f = pred_probs.view(-1)
i... |
RMSELoss | # 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 RMSELoss(nn.Module):
def __init__(self):
super(RMSELoss, self).__init__()
self.mse = nn.MSELoss()
def forward(self, yhat, y):
return torch.sqrt(self.mse(yhat, y))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([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 import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | PARMAGroup/UNet-Instance-Cell-Segmentation | RMSELoss | false | 8,626 | [
"MIT"
] | 30 | 79655a2c5781d2e20c7d5760f631fbb0be392292 | https://github.com/PARMAGroup/UNet-Instance-Cell-Segmentation/tree/79655a2c5781d2e20c7d5760f631fbb0be392292 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.mse = nn.MSELoss()
def forward(self, yhat, y):
return torch.sqrt(self.mse(yhat, y))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_ini... |
IoULoss | # 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 IoULoss(nn.Module):
"""
Intersection over Union Loss.
IoU = Area of Overlap / Area of Union
IoU loss is modified to use for heatmaps.
"""
def __init__(self):
super(IoULoss, self).__init__()
self.EPSILON = 1e-06
def _op_sum(self, x)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | OlgaChernytska/2D-Hand-Pose-Estimation-RGB | IoULoss | false | 8,627 | [
"MIT"
] | 24 | 31096d628ca11ec4a9b6fa8b2509a2b3e5272125 | https://github.com/OlgaChernytska/2D-Hand-Pose-Estimation-RGB/tree/31096d628ca11ec4a9b6fa8b2509a2b3e5272125 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Intersection over Union Loss.
IoU = Area of Overlap / Area of Union
IoU loss is modified to use for heatmaps.
"""
def __init__(self):
super().__init__()
self.EPSILON = 1e-06
def _op_sum(self, x):
retur... |
SpatialGate | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SpatialGate(nn.Module):
"""docstring for SpatialGate"""
def __init__(self, out_channels):
super(SpatialGate, self).__init__()
self.conv = nn.ConvTranspose2d(out_channels, 1, kernel_size=3,
stride=1, padding=1)
def forward(self, x):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | PRIS-CV/AP-CNN_Pytorch-master | SpatialGate | false | 8,630 | [
"MIT"
] | 26 | 00ddefee69ab35b8435b732bdf3bd7514a3e4545 | https://github.com/PRIS-CV/AP-CNN_Pytorch-master/tree/00ddefee69ab35b8435b732bdf3bd7514a3e4545 | import torch
import torch.nn as nn
class Model(nn.Module):
"""docstring for SpatialGate"""
def __init__(self, out_channels):
super().__init__()
self.conv = nn.ConvTranspose2d(out_channels, 1, kernel_size=3,
stride=1, padding=1)
def forward(self, x):
x = self.conv(x)
... |
WCELoss | # 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 WCELoss(nn.Module):
def __init__(self):
super(WCELoss, self).__init__()
def forward(self, y_pred, y_true, weights):
y_true = y_true / y_true.sum(2).sum(2, dtype=torch.float).unsqueeze(-1
).unsqueeze(-1)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | PARMAGroup/UNet-Instance-Cell-Segmentation | WCELoss | false | 8,631 | [
"MIT"
] | 30 | 79655a2c5781d2e20c7d5760f631fbb0be392292 | https://github.com/PARMAGroup/UNet-Instance-Cell-Segmentation/tree/79655a2c5781d2e20c7d5760f631fbb0be392292 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, y_pred, y_true, weights):
y_true = y_true / y_true.sum(2).sum(2, dtype=torch.float).unsqueeze(-1
).unsqueeze(-1)
y_true[y_tr... |
Quantizer | # 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.quantization
import torch.nn as nn
import torch.utils.data
class Quantizer(nn.Module):
def __init__(self):
super(Quantizer, self).__init__()
def forward(self, x, fine_tune=False):
cur_device = x.device
if self.training or fine_tune:
res = x + (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 libdevice
import torch.quantization
import torch.nn as nn
import torch.utils.data
assert_... | Orange-OpenSource/AIVC | Quantizer | false | 8,632 | [
"BSD-3-Clause"
] | 18 | 8534111d1e08cdbf7efa92ebbb105af3c9044521 | https://github.com/Orange-OpenSource/AIVC/tree/8534111d1e08cdbf7efa92ebbb105af3c9044521 | import torch
import torch.quantization
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, fine_tune=False):
cur_device = x.device
if self.training or fine_tune:
res = x + (torch.rand(x.size(), ... |
_Sum | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.jit
class _Sum(nn.Module):
def forward(self, input: 'torch.Tensor') ->torch.Tensor:
return input.sum()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.jit
assert_size_stride = torch._C._dynamo.guards.asser... | One-sixth/ms_ssim_pytorch | _Sum | false | 8,634 | [
"MIT"
] | 42 | 6269c62e0dd29c91fa38e4ba73d906d0c84ca966 | https://github.com/One-sixth/ms_ssim_pytorch/tree/6269c62e0dd29c91fa38e4ba73d906d0c84ca966 | import torch
import torch.nn as nn
import torch.jit
class Model(nn.Module):
def forward(self, input: 'torch.Tensor') ->torch.Tensor:
return input.sum()
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
Temperature | # 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 Temperature(nn.Module):
"""Temperature wrapper for nn.Sequential."""
def __init__(self, temperature):
super(Temperature, self).__init__()
self.temperature = temperature
def forward(self, data):
return data / self.temperature
def get_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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | PaccMann/paccmann_predictor | Temperature | false | 8,636 | [
"MIT"
] | 19 | 58071311310c45c1efabb34a4003b96a1c58901a | https://github.com/PaccMann/paccmann_predictor/tree/58071311310c45c1efabb34a4003b96a1c58901a | import torch
import torch.nn as nn
class Model(nn.Module):
"""Temperature wrapper for nn.Sequential."""
def __init__(self, temperature):
super().__init__()
self.temperature = temperature
def forward(self, data):
return data / self.temperature
def get_inputs():
return [torch... |
DeConvNet2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 spectral_norm(module, init=True, std=1, bound=False):
if init:
nn.init.normal_(module.weight, 0, std)
if hasattr(module, 'bias') and module.bias is not None:
module.bias.data.zero_()
SpectralNorm.apply(module, 'weight',... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | Neural-Diffusion-Research/normalized-autoencoders | DeConvNet2 | false | 8,637 | [
"MIT"
] | 30 | 0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | https://github.com/Neural-Diffusion-Research/normalized-autoencoders/tree/0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | import torch
import torch.nn as nn
import torch.nn.functional as F
def spectral_norm(module, init=True, std=1, bound=False):
if init:
nn.init.normal_(module.weight, 0, std)
if hasattr(module, 'bias') and module.bias is not None:
module.bias.data.zero_()
SpectralNorm.apply(module, 'weight',... |
DeConvNet3 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def get_activation(s_act):
if s_act == 'relu':
return nn.ReLU(inplace=True)
elif s_act == 'sigmoid':
return nn.Sigmoid()
elif s_act == 'softplus':
return nn.Softplus()
elif s_act == 'linear':
return None
elif s_act == 'tanh':
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | Neural-Diffusion-Research/normalized-autoencoders | DeConvNet3 | false | 8,638 | [
"MIT"
] | 30 | 0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | https://github.com/Neural-Diffusion-Research/normalized-autoencoders/tree/0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | import torch
import torch.nn as nn
def get_activation(s_act):
if s_act == 'relu':
return nn.ReLU(inplace=True)
elif s_act == 'sigmoid':
return nn.Sigmoid()
elif s_act == 'softplus':
return nn.Softplus()
elif s_act == 'linear':
return None
elif s_act == 'tanh':
... |
ConvNet2FC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def spectral_norm(module, init=True, std=1, bound=False):
if init:
nn.init.normal_(module.weight, 0, std)
if hasattr(module, 'bias') and module.bias is not None:
module.bias.data.zero_()
SpectralNorm.apply(module, 'weight', bound=bound)
return module
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Neural-Diffusion-Research/normalized-autoencoders | ConvNet2FC | false | 8,639 | [
"MIT"
] | 30 | 0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | https://github.com/Neural-Diffusion-Research/normalized-autoencoders/tree/0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | import torch
import torch.nn as nn
def spectral_norm(module, init=True, std=1, bound=False):
if init:
nn.init.normal_(module.weight, 0, std)
if hasattr(module, 'bias') and module.bias is not None:
module.bias.data.zero_()
SpectralNorm.apply(module, 'weight', bound=bound)
return module
... |
FixupResUnit | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class FixupResUnit(nn.Module):
def __init__(self, in_channels, out_channels, stride=1):
super().__init__()
self.bias1a = nn.Parameter(torch.zeros(1))
self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | OpenXAIProject/dac | FixupResUnit | false | 8,640 | [
"MIT"
] | 17 | 652776e21b56dcb68839363bb077d5c5ea28d81e | https://github.com/OpenXAIProject/dac/tree/652776e21b56dcb68839363bb077d5c5ea28d81e | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, stride=1):
super().__init__()
self.bias1a = nn.Parameter(torch.zeros(1))
self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1,
str... |
Encoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Scaled_Dot_Product_Attention(nn.Module):
"""Scaled Dot-Product Attention """
def __init__(self):
super(Scaled_Dot_Product_Attention, self).__init__()
def forward(self, Q, K, V, scale=None):
"""
Args:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | NTDXYG/Text-Classify-based-pytorch | Encoder | false | 8,641 | [
"Apache-2.0"
] | 20 | b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | https://github.com/NTDXYG/Text-Classify-based-pytorch/tree/b12a264a0ea64b2f8b46fafd5383ef0a8025ef2f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Scaled_Dot_Product_Attention(nn.Module):
"""Scaled Dot-Product Attention """
def __init__(self):
super().__init__()
def forward(self, Q, K, V, scale=None):
"""
Args:
Q: [batch_size, len_Q, dim_Q]... |
SAB | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.functional as F
import torch.nn as nn
class MAB(nn.Module):
def __init__(self, dim_X, dim_Y, dim, num_heads=4, ln=False, p=None):
super().__init__()
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_X, dim)
self.fc_k = nn.Linear(dim_Y, d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | OpenXAIProject/dac | SAB | false | 8,642 | [
"MIT"
] | 17 | 652776e21b56dcb68839363bb077d5c5ea28d81e | https://github.com/OpenXAIProject/dac/tree/652776e21b56dcb68839363bb077d5c5ea28d81e | import math
import torch
import torch.nn.functional as F
import torch.nn as nn
class MAB(nn.Module):
def __init__(self, dim_X, dim_Y, dim, num_heads=4, ln=False, p=None):
super().__init__()
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_X, dim)
self.fc_k = nn.Linear(dim_Y, d... |
GatedLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class GatedLinear(nn.Module):
def __init__(self, input_size, output_size):
super(GatedLinear, self).__init__()
self.linear = nn.Linear(input_size, output_size * 2)
self.glu = nn.GLU(dim=-1)
def forward(self, x, y=None, x_mask=None, y_mask=None, 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ParadoxZW/mmnas | GatedLinear | false | 8,643 | [
"Apache-2.0"
] | 23 | 186ef8648e71b5fc4433faf80431a0f8bc9261a0 | https://github.com/ParadoxZW/mmnas/tree/186ef8648e71b5fc4433faf80431a0f8bc9261a0 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, output_size):
super().__init__()
self.linear = nn.Linear(input_size, output_size * 2)
self.glu = nn.GLU(dim=-1)
def forward(self, x, y=None, x_mask=None, y_mask=None, rel_embed=None):
re... |
BlurPool2d | # 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 BlurPool2d(nn.Sequential):
"""Blur Pooling Layer (MaxPool2d replacement)
See: https://richzhang.github.io/antialiased-cnns/
Paper: https://arxiv.org/abs/1904.11486
"""
__constants__ = ['in_features']
_blur_kernel = torch.tensor([... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | Noodles-321/RegistrationEval | BlurPool2d | false | 8,644 | [
"MIT"
] | 38 | 3631d3d5bd65acf980fcfed803fa6125970f3e88 | https://github.com/Noodles-321/RegistrationEval/tree/3631d3d5bd65acf980fcfed803fa6125970f3e88 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Sequential):
"""Blur Pooling Layer (MaxPool2d replacement)
See: https://richzhang.github.io/antialiased-cnns/
Paper: https://arxiv.org/abs/1904.11486
"""
__constants__ = ['in_features']
_blur_kernel = torch.tensor([[1 / ... |
VarifocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss tensor.
"""
... | 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... | NEUdeep/TileDetection | VarifocalLoss | false | 8,645 | [
"Apache-2.0"
] | 41 | f453ac868de195a7859b9bf07c813e46eb35d2d0 | https://github.com/NEUdeep/TileDetection/tree/f453ac868de195a7859b9bf07c813e46eb35d2d0 | import torch
import torch.nn as nn
import torch.nn.functional as F
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "mean" and "sum".
Return:
Tensor: Reduced loss tensor.
"""
... |
ConvNet64 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def get_activation(s_act):
if s_act == 'relu':
return nn.ReLU(inplace=True)
elif s_act == 'sigmoid':
return nn.Sigmoid()
elif s_act == 'softplus':
return nn.Softplus()
elif s_act == 'linear':
return None
elif s_act == 'tanh':
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | Neural-Diffusion-Research/normalized-autoencoders | ConvNet64 | false | 8,646 | [
"MIT"
] | 30 | 0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | https://github.com/Neural-Diffusion-Research/normalized-autoencoders/tree/0c77f7e29289e336c0fe5e941aaec8baa4a4fb82 | import torch
import torch.nn as nn
def get_activation(s_act):
if s_act == 'relu':
return nn.ReLU(inplace=True)
elif s_act == 'sigmoid':
return nn.Sigmoid()
elif s_act == 'softplus':
return nn.Softplus()
elif s_act == 'linear':
return None
elif s_act == 'tanh':
... |
MAB | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.functional as F
import torch.nn as nn
class MAB(nn.Module):
def __init__(self, dim_X, dim_Y, dim, num_heads=4, ln=False, p=None):
super().__init__()
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_X, dim)
self.fc_k = nn.Linear(dim_Y, d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | OpenXAIProject/dac | MAB | false | 8,647 | [
"MIT"
] | 17 | 652776e21b56dcb68839363bb077d5c5ea28d81e | https://github.com/OpenXAIProject/dac/tree/652776e21b56dcb68839363bb077d5c5ea28d81e | import math
import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim_X, dim_Y, dim, num_heads=4, ln=False, p=None):
super().__init__()
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_X, dim)
self.fc_k = nn.Linear(dim_Y,... |
RMSPE | # 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 RMSPE(nn.Module):
def __init__(self, eps: 'float'=1e-08):
super().__init__()
self.eps = eps
def forward(self, pred: 'torch.Tensor', target: 'torch.Tensor'):
return torch.sqrt(torch.mean(torch.square((pred - target).abs() / (
target... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | Phimos/SIGSPATIAL-2021-GISCUP-3rd-Solution | RMSPE | false | 8,648 | [
"MIT"
] | 11 | 79fcf9941c28cdb2eb38a3654e1514a1d998a41c | https://github.com/Phimos/SIGSPATIAL-2021-GISCUP-3rd-Solution/tree/79fcf9941c28cdb2eb38a3654e1514a1d998a41c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps: 'float'=1e-08):
super().__init__()
self.eps = eps
def forward(self, pred: 'torch.Tensor', target: 'torch.Tensor'):
return torch.sqrt(torch.mean(torch.square((pred - target).abs() / (
target... |
AdaIN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class AdaIN(nn.Module):
def __init__(self, style_dim, num_features):
super().__init__()
self.norm = nn.InstanceNorm2d(num_features, affine=False)
self.fc = nn.Linear(style_dim, num_features * 2)
def forward(self, x, s):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | Noodles-321/RegistrationEval | AdaIN | false | 8,649 | [
"MIT"
] | 38 | 3631d3d5bd65acf980fcfed803fa6125970f3e88 | https://github.com/Noodles-321/RegistrationEval/tree/3631d3d5bd65acf980fcfed803fa6125970f3e88 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, style_dim, num_features):
super().__init__()
self.norm = nn.InstanceNorm2d(num_features, affine=False)
self.fc = nn.Linear(style_dim, num_features * 2)
def forward(self, x, s):
... |
Model | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs, hidden_size=256):
super(Model, self).__init__()
self.linear1 = nn.Linear(num_inputs, hidden_size)
self.linear2 = nn.Linear(hidden_size, num_outputs)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | PacktPublishing/Hands-On-Reinforcement-Learning-for-Games | Model | false | 8,650 | [
"MIT"
] | 41 | 045b8846f2558aa8fb8ac8cef5c71ee098cb9b22 | https://github.com/PacktPublishing/Hands-On-Reinforcement-Learning-for-Games/tree/045b8846f2558aa8fb8ac8cef5c71ee098cb9b22 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs, hidden_size=256):
super(Model, self).__init__()
self.linear1 = nn.Linear(num_inputs, hidden_size)
self.linear2 = nn.Linear(hidden_size, num_outputs)
... |
ResBlk | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def normalize(x, eps=1e-10):
return x * torch.rsqrt(torch.sum(x ** 2, dim=1, keepdim=True) + eps)
class ResBlk(nn.Module):
def __init__(self, dim_in, dim_out, actv=nn.LeakyReLU(0.2), normalize=
Fa... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
as... | Noodles-321/RegistrationEval | ResBlk | false | 8,651 | [
"MIT"
] | 38 | 3631d3d5bd65acf980fcfed803fa6125970f3e88 | https://github.com/Noodles-321/RegistrationEval/tree/3631d3d5bd65acf980fcfed803fa6125970f3e88 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
def normalize(x, eps=1e-10):
return x * torch.rsqrt(torch.sum(x ** 2, dim=1, keepdim=True) + eps)
class Model(nn.Module):
def __init__(self, dim_in, dim_out, actv=nn.LeakyReLU(0.2), normalize=
Fal... |
SimpleModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.onnx
import torch.nn.functional as F
class SimpleModel(nn.Module):
def __init__(self):
super(SimpleModel, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.conv3 = nn.Conv2d(64, 128, 3)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | PanJinquan/pytorch-base-trainer | SimpleModel | false | 8,652 | [
"MIT"
] | 11 | 37799c948f72b2f9d3771ff469e06cdbff4a1d07 | https://github.com/PanJinquan/pytorch-base-trainer/tree/37799c948f72b2f9d3771ff469e06cdbff4a1d07 | import torch
import torch.nn as nn
import torch.onnx
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.conv3 = nn.Conv2d(64, 128, 3)
self.fc = nn.Linear(128... |
DiceBCELoss | # 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 DiceBCELoss(nn.Module):
def __init__(self, weight=None, size_average=True):
super(DiceBCELoss, self).__init__()
def forward(self, inputs, targets, smooth=1):
inputs = torch.sigmoid(inputs)
inputs = inputs.view(-... | 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... | ProfessorHuang/2D-UNet-Pytorch | DiceBCELoss | false | 8,653 | [
"MIT"
] | 11 | b3941e8dc0ac3e76b6eedb656f943f1bd66fa799 | https://github.com/ProfessorHuang/2D-UNet-Pytorch/tree/b3941e8dc0ac3e76b6eedb656f943f1bd66fa799 | 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):
super().__init__()
def forward(self, inputs, targets, smooth=1):
inputs = torch.sigmoid(inputs)
inputs = inputs.view(-1)
targets = ta... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class ContrastiveLoss(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
Modified from: https://hackernoon.com/facial-similarity-with-siamese-networks-in-pytorch-9642aa9db2f7
"""... | 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
assert_size_stride = torch._... | QTIM-Lab/SiameseChange | ContrastiveLoss | false | 8,654 | [
"MIT"
] | 14 | a58fe2a93487b3e164f1d7e0b27f5a3321bc2672 | https://github.com/QTIM-Lab/SiameseChange/tree/a58fe2a93487b3e164f1d7e0b27f5a3321bc2672 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
Modified from: https://hackernoon.com/facial-similarity-with-siamese-networks-in-pytorch-9642aa9db2f7
"""
def ... |
SEConv2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _pair
class SEConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=False, size_splits=64,
threshold=0.005, sign_threshold=... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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 torch.nn.modules.utils import _pair
assert_size_strid... | PannenetsF/TQT | SEConv2d | false | 8,655 | [
"BSD-3-Clause"
] | 14 | 3c3125327d00efe6318b28cb1d0a199b734c2c7b | https://github.com/PannenetsF/TQT/tree/3c3125327d00efe6318b28cb1d0a199b734c2c7b | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import _pair
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1, bias=False, size_splits=64,
threshold=0.005, sign_threshold=0.5... |
ReconstructionCriterion | # 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 ReconstructionCriterion(nn.Module):
"""
Here we calculate the criterion for -log p(x|z), we list two forms, the binary cross entropy form
as well as the mse loss form
"""
def __init__(self, x_sigma=1, bce_reconstruction=True... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | PaperCodeSubmission/ICML2020-697 | ReconstructionCriterion | false | 8,656 | [
"MIT"
] | 12 | 00f7732c236b9c6234e76a47dfebe5de314d5c01 | https://github.com/PaperCodeSubmission/ICML2020-697/tree/00f7732c236b9c6234e76a47dfebe5de314d5c01 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Here we calculate the criterion for -log p(x|z), we list two forms, the binary cross entropy form
as well as the mse loss form
"""
def __init__(self, x_sigma=1, bce_reconstruction=True):
super()... |
KLDiscCriterion | # 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 KLDiscCriterion(nn.Module):
"""
calculate
sum (j=1,...,K) D_KL[q(c_j|x)||p(c_j|x)]
"""
def __init__(self):
super(KLDiscCriterion, self).__init__()
def forward(self, disc_log_pre, disc_gt, qp_order=True):
batch_size = disc_log_pre.size(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | PaperCodeSubmission/ICML2020-697 | KLDiscCriterion | false | 8,657 | [
"MIT"
] | 12 | 00f7732c236b9c6234e76a47dfebe5de314d5c01 | https://github.com/PaperCodeSubmission/ICML2020-697/tree/00f7732c236b9c6234e76a47dfebe5de314d5c01 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
calculate
sum (j=1,...,K) D_KL[q(c_j|x)||p(c_j|x)]
"""
def __init__(self):
super().__init__()
def forward(self, disc_log_pre, disc_gt, qp_order=True):
batch_size = disc_log_pre.size(0)
disc_log_gt = torch.... |
M1Criterion | # 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 M1Criterion(nn.Module):
def __init__(self, x_sigma=1, bce_reconstruction=True):
super(M1Criterion, self).__init__()
self.x_sigma = x_sigma
self.bce_reconstruction = bce_reconstruction
def forward(self, x, x_reco... | 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... | PaperCodeSubmission/ICML2020-697 | M1Criterion | false | 8,658 | [
"MIT"
] | 12 | 00f7732c236b9c6234e76a47dfebe5de314d5c01 | https://github.com/PaperCodeSubmission/ICML2020-697/tree/00f7732c236b9c6234e76a47dfebe5de314d5c01 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, x_sigma=1, bce_reconstruction=True):
super().__init__()
self.x_sigma = x_sigma
self.bce_reconstruction = bce_reconstruction
def forward(self, x, x_reconstructed, M1_mean, M1_... |
ada_mask | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResBlock(nn.Module):
def __init__(self, in_channel, out_channel, ker_size, stri, pad):
super(ResBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channel, out_channel, 3, 1, 1)
self.conv2 = nn.Conv2d(out_channel, out... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | NJUVISION/AWnet | ada_mask | false | 8,659 | [
"MIT"
] | 16 | f47a1692819a778b513b882d36ed727f7732d37b | https://github.com/NJUVISION/AWnet/tree/f47a1692819a778b513b882d36ed727f7732d37b | import torch
import torch.nn as nn
import torch.nn.functional as F
class ResBlock(nn.Module):
def __init__(self, in_channel, out_channel, ker_size, stri, pad):
super().__init__()
self.conv1 = nn.Conv2d(in_channel, out_channel, 3, 1, 1)
self.conv2 = nn.Conv2d(out_channel, out_channel, 3, 1... |
Classify | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def autopad(k, p=None):
if p is None:
p = k // 2 if isinstance(k, int) else [(x // 2) for x in k]
return p
class Classify(nn.Module):
def __init__(self, c1, c2, k=1, s=1, p=None, g=1):
super(Classify, self).__init__()
self.aap = nn.AdaptiveAvgP... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | PoCInnovation/Koic | Classify | false | 8,660 | [
"MIT"
] | 13 | eca53b53b7242c1e83213ef9408366ca0a346358 | https://github.com/PoCInnovation/Koic/tree/eca53b53b7242c1e83213ef9408366ca0a346358 | import torch
import torch.nn as nn
def autopad(k, p=None):
if p is None:
p = k // 2 if isinstance(k, int) else [(x // 2) for x in k]
return p
class Model(nn.Module):
def __init__(self, c1, c2, k=1, s=1, p=None, g=1):
super().__init__()
self.aap = nn.AdaptiveAvgPool2d(1)
... |
ClsCriterion | # 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 ClsCriterion(nn.Module):
def __init__(self):
super(ClsCriterion, self).__init__()
def forward(self, predict, label, batch_weight=None):
"""
:param predict: B*C log_softmax result
:param label: B*C one-hot label
:param batch_wei... | 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... | PaperCodeSubmission/ICML2020-697 | ClsCriterion | false | 8,661 | [
"MIT"
] | 12 | 00f7732c236b9c6234e76a47dfebe5de314d5c01 | https://github.com/PaperCodeSubmission/ICML2020-697/tree/00f7732c236b9c6234e76a47dfebe5de314d5c01 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, predict, label, batch_weight=None):
"""
:param predict: B*C log_softmax result
:param label: B*C one-hot label
:param batch_weight: B*1 0-1 weight for e... |
IWDiscriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 IWConv2d(nn.Module):
def __init__(self, input_dim, output_dim, kernel_size, he_init=True,
stride=1, bias=True):
super(IWConv2d, self).__init__()
self.he_init = he_init
self.padding = int((kernel_size - 1) / 2)
self.conv = nn.Conv2d(i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | MIC-DKFZ/mood | IWDiscriminator | false | 8,662 | [
"Apache-2.0"
] | 42 | a01303adb4256653b133e2f7cd4741d366b681f7 | https://github.com/MIC-DKFZ/mood/tree/a01303adb4256653b133e2f7cd4741d366b681f7 | import torch
from torch import nn
class IWConv2d(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, outp... |
MetaAconC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MetaAconC(nn.Module):
""" ACON activation (activate or not).
MetaAconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is generated by a small network
according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
"... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | PoCInnovation/Koic | MetaAconC | false | 8,663 | [
"MIT"
] | 13 | eca53b53b7242c1e83213ef9408366ca0a346358 | https://github.com/PoCInnovation/Koic/tree/eca53b53b7242c1e83213ef9408366ca0a346358 | import torch
import torch.nn as nn
class Model(nn.Module):
""" ACON activation (activate or not).
MetaAconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is generated by a small network
according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
"""
... |
ConvBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConvBlock(nn.Module):
def __init__(self):
super(ConvBlock, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
def forward(self, x):
x... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | QinbinLi/FedKT | ConvBlock | false | 8,664 | [
"MIT"
] | 14 | 0bb9a89ea266c057990a4a326b586ed3d2fb2df8 | https://github.com/QinbinLi/FedKT/tree/0bb9a89ea266c057990a4a326b586ed3d2fb2df8 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
def forward(self, x):
x = self.pool(F.relu... |
FixupResidual | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class FixupResidual(nn.Module):
def __init__(self, depth, num_residual):
super().__init__()
self.conv1 = nn.Conv2d(depth, depth, 3, padding=1, bias=False)
self.conv2 = nn.Conv2d(depth, depth, 3, padding=1, bias... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import math
import torch.nn a... | PacktPublishing/Hands-On-Reinforcement-Learning-for-Games | FixupResidual | false | 8,665 | [
"MIT"
] | 41 | 045b8846f2558aa8fb8ac8cef5c71ee098cb9b22 | https://github.com/PacktPublishing/Hands-On-Reinforcement-Learning-for-Games/tree/045b8846f2558aa8fb8ac8cef5c71ee098cb9b22 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, depth, num_residual):
super().__init__()
self.conv1 = nn.Conv2d(depth, depth, 3, padding=1, bias=False)
self.conv2 = nn.Conv2d(depth, depth, 3, padding=1, bias=False)
... |
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
class MaxPooling(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
x = torch.cat((x.unsqueeze(dim=1), y.unsqueeze(dim=1)), dim=1)
return x.max(dim=1)[0]
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([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 import triton_helpers
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | Qualcomm-AI-research/FrameExit | MaxPooling | false | 8,666 | [
"BSD-3-Clause-Clear"
] | 21 | fc5815fd092019d58bcac5d5e6fcc45ce666311f | https://github.com/Qualcomm-AI-research/FrameExit/tree/fc5815fd092019d58bcac5d5e6fcc45ce666311f | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
x = torch.cat((x.unsqueeze(dim=1), y.unsqueeze(dim=1)), dim=1)
return x.max(dim=1)[0]
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def g... |
KLNormCriterion | # 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 KLNormCriterion(nn.Module):
def __init__(self):
super(KLNormCriterion, self).__init__()
def forward(self, z_mean_pre, z_log_sigma_pre, z_mean_gt=None,
z_sigma_gt=None):
batch_size = z_mean_pre.size(0)
if z_mean_gt is None or z_sigma_gt... | 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
... | PaperCodeSubmission/ICML2020-697 | KLNormCriterion | false | 8,667 | [
"MIT"
] | 12 | 00f7732c236b9c6234e76a47dfebe5de314d5c01 | https://github.com/PaperCodeSubmission/ICML2020-697/tree/00f7732c236b9c6234e76a47dfebe5de314d5c01 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, z_mean_pre, z_log_sigma_pre, z_mean_gt=None,
z_sigma_gt=None):
batch_size = z_mean_pre.size(0)
if z_mean_gt is None or z_sigma_gt is None:
"""
... |
QNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 weights_init_(m):
if isinstance(m, nn.Linear):
torch.nn.init.xavier_uniform_(m.weight, gain=1)
torch.nn.init.constant_(m.bias, 0)
class QNetwork(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_dim):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | QwQ2000/E2GAN | QNetwork | false | 8,668 | [
"MIT"
] | 34 | f27b715362de4459129206217d100ae5b6cf82c8 | https://github.com/QwQ2000/E2GAN/tree/f27b715362de4459129206217d100ae5b6cf82c8 | import torch
import torch.nn as nn
import torch.nn.functional as F
def weights_init_(m):
if isinstance(m, nn.Linear):
torch.nn.init.xavier_uniform_(m.weight, gain=1)
torch.nn.init.constant_(m.bias, 0)
class Model(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_dim):
s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.