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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
IDPredictor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch import nn
class IDPredictor(nn.Module):
def __init__(self, nz_feat, n_dim=5):
super(IDPredictor, self).__init__()
self.pred_layer = nn.Linear(nz_feat, 256)
self.sc_layer = nn.Linear(256, 128)
self.sc_layer2 = nn.Linear(128, 6... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | JasonQSY/Associative3D | IDPredictor | false | 8,350 | [
"MIT"
] | 25 | c50818b593ec48c38ed7ee3e109c23531089da32 | https://github.com/JasonQSY/Associative3D/tree/c50818b593ec48c38ed7ee3e109c23531089da32 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
def __init__(self, nz_feat, n_dim=5):
super().__init__()
self.pred_layer = nn.Linear(nz_feat, 256)
self.sc_layer = nn.Linear(256, 128)
self.sc_layer2 = nn.Linear(128, 64)
def forward(sel... |
ConvModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)
if activation ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dyn... | IlyaBizyaev/ttools | ConvModule | false | 8,351 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)
if activation ... |
Normalize | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
class Normalize(nn.Module):
def __init__(self, p=2):
super(Normalize, self).__init__()
self.p = p
def forward(self, x):
return F.normalize(x, p=self.p, 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 libdevice
import torch.nn as nn
import... | JindongGu/SimDis | Normalize | false | 8,352 | [
"MIT"
] | 12 | 0871a217a756acc268f35f802e35b01b12817f0d | https://github.com/JindongGu/SimDis/tree/0871a217a756acc268f35f802e35b01b12817f0d | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, p=2):
super().__init__()
self.p = p
def forward(self, x):
return F.normalize(x, p=self.p, dim=1)
def get_inputs():
return [torch.ran... |
MultiHeadAttn | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
from torch import nn
class MultiHeadAttn(nn.Module):
def __init__(self, n_head, d_model, d_head, dropout, dropatt=0,
pre_lnorm=False):
super(MultiHeadAttn, self).__init__()
self.n_head = n_head
self.d_model = d_model
self.d_head... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JasonBenn/duet | MultiHeadAttn | false | 8,353 | [
"Apache-2.0"
] | 11 | 0d6f1f66fad097023b022f2a361a1587d0f740ba | https://github.com/JasonBenn/duet/tree/0d6f1f66fad097023b022f2a361a1587d0f740ba | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
def __init__(self, n_head, d_model, d_head, dropout, dropatt=0,
pre_lnorm=False):
super().__init__()
self.n_head = n_head
self.d_model = d_model
self.d_head = d_head
self.drop... |
PositionalWiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class GELU(nn.Module):
"""
This is a smoother version of the RELU.
Original paper: https://arxiv.org/abs/1606.08415
"""
def forward(self, x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x +
0.044715 * torch.pow(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
from torch._inductor.runtime.... | JiaweiSheng/FAAN | PositionalWiseFeedForward | false | 8,354 | [
"MIT"
] | 41 | b439b829506c4e2e9044a6b2ab7f3d844f445a95 | https://github.com/JiaweiSheng/FAAN/tree/b439b829506c4e2e9044a6b2ab7f3d844f445a95 | import math
import torch
import torch.nn as nn
class GELU(nn.Module):
"""
This is a smoother version of the RELU.
Original paper: https://arxiv.org/abs/1606.08415
"""
def forward(self, x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x +
0.044715 * torch.pow(x, ... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class SelfAttention(nn.Module):
def __init__(self, input_size, hidden_size):
super(SelfAttention, self).__init__()
self.W1 = torch.Tensor(input_size, hidden_size)
self.W1 = nn.Parameter(nn.init.xavie... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | IBM/graph4nlp | SelfAttention | false | 8,355 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class Model(nn.Module):
def __init__(self, input_size, hidden_size):
super().__init__()
self.W1 = torch.Tensor(input_size, hidden_size)
self.W1 = nn.Parameter(nn.init.xavier_uniform_(self.W1))
... |
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 numpy as np
import torch.nn as nn
class ScaledDotProductAttention(nn.Module):
""" Scaled Dot-Product Attention
"""
def __init__(self, attn_dropout=0.0):
super(ScaledDotProductAttention, self).__init__()
self.dropout = nn.Dropout(attn_dropout)
self.softmax = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | JiaweiSheng/FAAN | ScaledDotProductAttention | false | 8,356 | [
"MIT"
] | 41 | b439b829506c4e2e9044a6b2ab7f3d844f445a95 | https://github.com/JiaweiSheng/FAAN/tree/b439b829506c4e2e9044a6b2ab7f3d844f445a95 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
""" Scaled Dot-Product Attention
"""
def __init__(self, attn_dropout=0.0):
super().__init__()
self.dropout = nn.Dropout(attn_dropout)
self.softmax = nn.Softmax(dim=2)
def forward(self, q, k, v, scal... |
MLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class MLP(nn.Module):
def __init__(self, input_dim, output_dim, hidden_dim=128):
""" 初始化q网络，为全连接网络
input_dim: 输入的特征数即环境的状态维度
output_dim: 输出的动作维度
"""
super(MLP, self).__init__()
self.fc1 = nn... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | JohnJim0816/rl-tutorials | MLP | false | 8,357 | [
"MIT"
] | 16 | e99daea815da85f9f25dff2d01b030249a203d22 | https://github.com/JohnJim0816/rl-tutorials/tree/e99daea815da85f9f25dff2d01b030249a203d22 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_dim, output_dim, hidden_dim=128):
""" 初始化q网络，为全连接网络
input_dim: 输入的特征数即环境的状态维度
output_dim: 输出的动作维度
"""
super().__init__()
self.fc1 = nn.Linear... |
FixupBasicBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 as th
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 as th
import tor... | IlyaBizyaev/ttools | FixupBasicBlock | false | 8,358 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch as th
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)... |
LabelPredictor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 LabelPredictor(nn.Module):
def __init__(self, nz_feat, classify_rot=True):
super(LabelPredictor, self).__init__()
self.pred_layer = nn.Linear(nz_feat, 1)
def forward(self, feat):
pred = self.pred_layer.forward(feat)
pred = torch.sigmoid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | JasonQSY/Associative3D | LabelPredictor | false | 8,359 | [
"MIT"
] | 25 | c50818b593ec48c38ed7ee3e109c23531089da32 | https://github.com/JasonQSY/Associative3D/tree/c50818b593ec48c38ed7ee3e109c23531089da32 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, nz_feat, classify_rot=True):
super().__init__()
self.pred_layer = nn.Linear(nz_feat, 1)
def forward(self, feat):
pred = self.pred_layer.forward(feat)
pred = torch.sigmoid(pred)
return pred
... |
MultimodalHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MultimodalHead(nn.Module):
"""
Multimodal head for the conv net outputs.
This layer concatenate the outputs of audio and visual convoluational nets
and performs a fully-connected projection
"""
def __init__(self, dim_in, num_classes, dropout_rate=0.0, a... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | JiwanChung/acav100m | MultimodalHead | false | 8,360 | [
"MIT"
] | 27 | 51cb948d5682da69334a8d05d2df631971b60215 | https://github.com/JiwanChung/acav100m/tree/51cb948d5682da69334a8d05d2df631971b60215 | import torch
from torch import nn
class Model(nn.Module):
"""
Multimodal head for the conv net outputs.
This layer concatenate the outputs of audio and visual convoluational nets
and performs a fully-connected projection
"""
def __init__(self, dim_in, num_classes, dropout_rate=0.0, act_func=
... |
CNN_small | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.utils.data
class CNN_small(nn.Module):
def __init__(self, num_classes=10):
super(CNN_small, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | JiarunLiu/Co-correcting | CNN_small | false | 8,361 | [
"Apache-2.0"
] | 19 | 4e3ca4951de5d73ca812bbbcfe666273082ff2fd | https://github.com/JiarunLiu/Co-correcting/tree/4e3ca4951de5d73ca812bbbcfe666273082ff2fd | import torch
import torch.nn as nn
from torch.nn import functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
se... |
CRFLoss | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CRFLoss(nn.Module):
def __init__(self, L, init):
super(CRFLoss, self).__init__()
self.start = nn.Parameter(torch.Tensor(L).uniform_(-init, init))
self.T = nn.Parameter(torch.Tensor(L, L).uniform_(-init, init))
self.end = nn.Parameter(torch.... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | Johannes0Horn/mtl-dts | CRFLoss | false | 8,362 | [
"MIT"
] | 19 | ae50253c808bbb77af3b1117f69f08d2268099e9 | https://github.com/Johannes0Horn/mtl-dts/tree/ae50253c808bbb77af3b1117f69f08d2268099e9 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, L, init):
super().__init__()
self.start = nn.Parameter(torch.Tensor(L).uniform_(-init, init))
self.T = nn.Parameter(torch.Tensor(L, L).uniform_(-init, init))
self.end = nn.Parameter(torch.Tensor(L).unifo... |
NonLocalBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 time import *
class NonLocalBlock(nn.Module):
def __init__(self, channel):
super(NonLocalBlock, self).__init__()
self.inter_channel = channel // 2
self.conv_phi = nn.Conv2d(in_channels=channel, out_channels=self.
inter_channel, kernel_si... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Jinming-Su/SGNet | NonLocalBlock | false | 8,363 | [
"MIT"
] | 13 | fcf35edaf332c1a4e2713acad5a0fc0e21509c3e | https://github.com/Jinming-Su/SGNet/tree/fcf35edaf332c1a4e2713acad5a0fc0e21509c3e | import torch
import torch.nn as nn
from time import *
class Model(nn.Module):
def __init__(self, channel):
super().__init__()
self.inter_channel = channel // 2
self.conv_phi = nn.Conv2d(in_channels=channel, out_channels=self.
inter_channel, kernel_size=1, stride=1, padding=0, ... |
SoftCrossEntropyLoss | # 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 soft_cross_entropy(logit, label, weight=None, reduce=None, reduction='mean'
):
if weight is not None and weight.requires_grad:
raise RuntimeError('gradient for weight is not supported')
losses = SoftCrossEntropyFunction.apply(logit, label, weight)
reduction = {(True): 'mean', ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
assert_size_stride = t... | Jingkang50/ICCV21_SCOOD | SoftCrossEntropyLoss | false | 8,364 | [
"MIT"
] | 34 | 51204e3788a9e81aa334611072bef106fd9d13ad | https://github.com/Jingkang50/ICCV21_SCOOD/tree/51204e3788a9e81aa334611072bef106fd9d13ad | import torch
def soft_cross_entropy(logit, label, weight=None, reduce=None, reduction='mean'
):
if weight is not None and weight.requires_grad:
raise RuntimeError('gradient for weight is not supported')
losses = SoftCrossEntropyFunction.apply(logit, label, weight)
reduction = {(True): 'mean', ... |
MaxPool2dSamePadding | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
def get_same_padding(in_size, kernel_size, stride):
"""'Same 'same' operation with tensorflow
notice：padding=(0, 1, 0, 1) and padding=(1, 1, 1, 1) are different
padding=(1, 1, 1, 1):
out(H, W) = (in + [2 * padding] − k... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_siz... | Jintao-Huang/EfficientDet_PyTorch | MaxPool2dSamePadding | false | 8,365 | [
"Apache-2.0"
] | 18 | 79616be397b7f57992cd43b772f65b58b5e25a8b | https://github.com/Jintao-Huang/EfficientDet_PyTorch/tree/79616be397b7f57992cd43b772f65b58b5e25a8b | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
def get_same_padding(in_size, kernel_size, stride):
"""'Same 'same' operation with tensorflow
notice：padding=(0, 1, 0, 1) and padding=(1, 1, 1, 1) are different
padding=(1, 1, 1, 1):
out(H, W) = (in + [2 * padding] − k... |
SoftSelectPrototype | # 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 SoftSelectAttention(nn.Module):
def __init__(self, hidden_size):
super(SoftSelectAttention, self).__init__()
def forward(self, support, query):
"""
:param support: [few, dim]
:param query: [batch, dim]
:return:
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JiaweiSheng/FAAN | SoftSelectPrototype | false | 8,366 | [
"MIT"
] | 41 | b439b829506c4e2e9044a6b2ab7f3d844f445a95 | https://github.com/JiaweiSheng/FAAN/tree/b439b829506c4e2e9044a6b2ab7f3d844f445a95 | import torch
import torch.nn as nn
class SoftSelectAttention(nn.Module):
def __init__(self, hidden_size):
super().__init__()
def forward(self, support, query):
"""
:param support: [few, dim]
:param query: [batch, dim]
:return:
"""
query_ = query.unsque... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Critic(nn.Module):
def __init__(self, n_obs, action_dim, hidden_size, init_w=0.003):
super(Critic, self).__init__()
self.linear1 = nn.Linear(n_obs + action_dim, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidd... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | JohnJim0816/rl-tutorials | Critic | false | 8,367 | [
"MIT"
] | 16 | e99daea815da85f9f25dff2d01b030249a203d22 | https://github.com/JohnJim0816/rl-tutorials/tree/e99daea815da85f9f25dff2d01b030249a203d22 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, n_obs, action_dim, hidden_size, init_w=0.003):
super().__init__()
self.linear1 = nn.Linear(n_obs + action_dim, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidden_size)
... |
GlobalAveragePooling | # 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 GlobalAveragePooling(nn.Module):
"""Global Average Pooling neck.
Note that we use `view` to remove extra channel after pooling. We do not
use `squeeze` as it will also remove the batch dimension when the tensor
has a batch dimension of size 1, which can lead t... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | Jackqu/mmpose | GlobalAveragePooling | false | 8,368 | [
"Apache-2.0"
] | 38 | ad8acc5ff5da7993c6befdc4b1ced2c2ecb64533 | https://github.com/Jackqu/mmpose/tree/ad8acc5ff5da7993c6befdc4b1ced2c2ecb64533 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Global Average Pooling neck.
Note that we use `view` to remove extra channel after pooling. We do not
use `squeeze` as it will also remove the batch dimension when the tensor
has a batch dimension of size 1, which can lead to unexpected er... |
GlobalAttentionGeneral | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.parallel
class GlobalAttentionGeneral(nn.Module):
def __init__(self, idf, cdf):
super(GlobalAttentionGeneral, self).__init__()
self.sm = nn.Softmax()
self.mask = None
def applyMask(self, mask):
self.mask = mask
def forwa... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JoonHong-Kim/T2I_CL | GlobalAttentionGeneral | false | 8,369 | [
"MIT"
] | 35 | c52aa73da903d6e4174eeef2663e5bc1163785b1 | https://github.com/JoonHong-Kim/T2I_CL/tree/c52aa73da903d6e4174eeef2663e5bc1163785b1 | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, idf, cdf):
super().__init__()
self.sm = nn.Softmax()
self.mask = None
def applyMask(self, mask):
self.mask = mask
def forward(self, input, context_key, content_value):
... |
PolicyNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class PolicyNet(nn.Module):
def __init__(self, state_dim, action_dim, hidden_dim, init_w=0.003,
log_std_min=-20, log_std_max=2):
super(PolicyNet, self).__init__()
self.log_std_min = l... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | JohnJim0816/rl-tutorials | PolicyNet | false | 8,370 | [
"MIT"
] | 16 | e99daea815da85f9f25dff2d01b030249a203d22 | https://github.com/JohnJim0816/rl-tutorials/tree/e99daea815da85f9f25dff2d01b030249a203d22 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class Model(nn.Module):
def __init__(self, state_dim, action_dim, hidden_dim, init_w=0.003,
log_std_min=-20, log_std_max=2):
super().__init__()
self.log_std_min = log_std_min
... |
SE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 itertools import chain as chain
import torch.utils.data
import torch.nn as nn
class SwishEfficient(torch.autograd.Function):
"""Swish activation function: x * sigmoid(x)."""
@staticmethod
def forward(ctx, x):
result = x * torch.sigmoid(x)
ctx.save_for_backward(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
from itertools import chain a... | JaywongWang/SlowFast | SE | false | 8,371 | [
"Apache-2.0"
] | 43 | 366467aafc856712fdc3e9c4cce8e90969047ee6 | https://github.com/JaywongWang/SlowFast/tree/366467aafc856712fdc3e9c4cce8e90969047ee6 | import torch
from itertools import chain as chain
import torch.utils.data
import torch.nn as nn
class SwishEfficient(torch.autograd.Function):
"""Swish activation function: x * sigmoid(x)."""
@staticmethod
def forward(ctx, x):
result = x * torch.sigmoid(x)
ctx.save_for_backward(x)
... |
WasLoss | # 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 WasLoss(nn.Module):
def __init__(self):
super(WasLoss, self).__init__()
self.MSEls = torch.nn.BCEWithLogitsLoss()
def forward(self, true_data, fake_data):
SLX, _ = torch.sort(true_data, 0)
SLG, _ = torch.sort(fake_data, 0)
retu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | Johnson-yue/RS-GAN | WasLoss | false | 8,372 | [
"MIT"
] | 26 | 8e8723045d63d8f9a4b510800cd909e7a6e3d195 | https://github.com/Johnson-yue/RS-GAN/tree/8e8723045d63d8f9a4b510800cd909e7a6e3d195 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.MSEls = torch.nn.BCEWithLogitsLoss()
def forward(self, true_data, fake_data):
SLX, _ = torch.sort(true_data, 0)
SLG, _ = torch.sort(fake_data, 0)
return self.MSEls(S... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Actor(nn.Module):
def __init__(self, n_obs, action_dim, hidden_size, init_w=0.003):
super(Actor, self).__init__()
self.linear1 = nn.Linear(n_obs, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidden_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | JohnJim0816/rl-tutorials | Actor | false | 8,373 | [
"MIT"
] | 16 | e99daea815da85f9f25dff2d01b030249a203d22 | https://github.com/JohnJim0816/rl-tutorials/tree/e99daea815da85f9f25dff2d01b030249a203d22 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, n_obs, action_dim, hidden_size, init_w=0.003):
super().__init__()
self.linear1 = nn.Linear(n_obs, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidden_size)
self.line... |
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... | import torch
import torch.utils.data
from torchvision.transforms import functional as F
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt as sqrt
from itertools import product as product
class Mish(nn.Module):
def forward(self, x):
return x.mul_(F.softplus(x).tanh())
def get_i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.utils.data
import torch.nn as nn
from math import... | Het-Shah/Monk_Object_Detection | Mish | false | 8,374 | [
"Apache-2.0"
] | 15 | 1d7a07193ea3455221caa41d07c33c81d50c6b3f | https://github.com/Het-Shah/Monk_Object_Detection/tree/1d7a07193ea3455221caa41d07c33c81d50c6b3f | import torch
import torch.utils.data
from torchvision.transforms import functional as F
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt as sqrt
from itertools import product as product
class Model(nn.Module):
def forward(self, x):
return x.mul_(F.softplus(x).tanh())
def get_... |
AttentionPool2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
import torch as th
def conv_nd(dims, *args, **kwargs):
"""
Create a 1D, 2D, or 3D convolution module.
"""
if dims == 1:
return nn.Conv1d(*args, **kwargs)
elif dims == 2:
return nn.Conv2d(*args, **kwargs)
elif dims == 3:
retu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Jack000/glid-3 | AttentionPool2d | false | 8,375 | [
"MIT"
] | 31 | 4a18efc2785339ebc743e149a7955e34fff436fb | https://github.com/Jack000/glid-3/tree/4a18efc2785339ebc743e149a7955e34fff436fb | import math
import torch
from torch import nn
import torch as th
def conv_nd(dims, *args, **kwargs):
"""
Create a 1D, 2D, or 3D convolution module.
"""
if dims == 1:
return nn.Conv1d(*args, **kwargs)
elif dims == 2:
return nn.Conv2d(*args, **kwargs)
elif dims == 3:
retu... |
GaussianKernel | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.nn as nn
import torch.utils.data
class GaussianKernel(nn.Module):
def __init__(self, delta_var, pmaps_threshold):
super().__init__()
self.delta_var = delta_var
self.two_sigma = delta_var * delta_var / -math.log(pmaps_threshold)
def forward(self, ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import math
import torch.nn as nn
import torch.utils.data
assert_size_str... | JonasHell/torch-em | GaussianKernel | false | 8,376 | [
"MIT"
] | 13 | 2e008e0cd2f0ea6681581374fce4f9f47b986d55 | https://github.com/JonasHell/torch-em/tree/2e008e0cd2f0ea6681581374fce4f9f47b986d55 | import math
import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, delta_var, pmaps_threshold):
super().__init__()
self.delta_var = delta_var
self.two_sigma = delta_var * delta_var / -math.log(pmaps_threshold)
def forward(self, dist_map)... |
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
from torch import nn
import torch.nn.functional as F
class Attention(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
"""
def __init__(self, dim):
super(Attention, self).__init__()
self.dim = dim
self.linear1 = nn.Linear(dim ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | JiwanChung/tapm | Attention | false | 8,377 | [
"MIT"
] | 14 | ec42b139d1c012daccc55f85e67744488d526476 | https://github.com/JiwanChung/tapm/tree/ec42b139d1c012daccc55f85e67744488d526476 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
"""
def __init__(self, dim):
super().__init__()
self.dim = dim
self.linear1 = nn.Linear(dim * 2, dim)
s... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Swish(nn.Module):
def __init__(self, inplace=True):
super(Swish, self).__init__()
self.inplace = inplace
def forward(self, x):
if self.inplace:
x.mul_(torch.sigmoid(x))
return x
else:
return x * torc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | Jianxun-Wang/Physics-constrained-Bayesian-deep-learning | Net | false | 8,378 | [
"MIT"
] | 24 | cde0287f848f83c6def1fe409c67d7d4e14174da | https://github.com/Jianxun-Wang/Physics-constrained-Bayesian-deep-learning/tree/cde0287f848f83c6def1fe409c67d7d4e14174da | import torch
import torch.nn as nn
class Swish(nn.Module):
def __init__(self, inplace=True):
super().__init__()
self.inplace = inplace
def forward(self, x):
if self.inplace:
x.mul_(torch.sigmoid(x))
return x
else:
return x * torch.sigmoid(x... |
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
from torch import nn
import torch.nn.functional as F
class Block(nn.Module):
def __init__(self, dim):
super(Block, self).__init__()
self.dim = dim
self.layer_norm = nn.LayerNorm(self.dim)
self.conv = nn.Conv1d(self.dim, self.dim, kernel_size=3, padding=1)
def for... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JiwanChung/tapm | Block | false | 8,379 | [
"MIT"
] | 14 | ec42b139d1c012daccc55f85e67744488d526476 | https://github.com/JiwanChung/tapm/tree/ec42b139d1c012daccc55f85e67744488d526476 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.dim = dim
self.layer_norm = nn.LayerNorm(self.dim)
self.conv = nn.Conv1d(self.dim, self.dim, kernel_size=3, padding=1)
def forward(self, ... |
RLFeatPreprocessNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 RLFeatPreprocessNet(nn.Module):
"""
Preprocess Features
1. visual feature
2. label prediction embed feature
3. box embed
4. overlap embed
"""
def __init__(self, feat_size, embed_size, bbox_size, overlap_size,
out... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | KaihuaTang/VCTree-Visual-Question-Answering | RLFeatPreprocessNet | false | 8,380 | [
"MIT"
] | 31 | b6b0a8bdb01d45d36de3bded91db42544ad6a593 | https://github.com/KaihuaTang/VCTree-Visual-Question-Answering/tree/b6b0a8bdb01d45d36de3bded91db42544ad6a593 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
Preprocess Features
1. visual feature
2. label prediction embed feature
3. box embed
4. overlap embed
"""
def __init__(self, feat_size, embed_size, bbox_size, overlap_size,
output_size):
... |
ELUPlus | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn
class ELUPlus(nn.Module):
def __init__(self):
super().__init__()
self.elu = nn.ELU()
def forward(self, x):
return self.elu(x) + 1.0
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.triton_helpers import libdevice
from torch import nn
import torch.nn
assert_size_stride = torch._C._dynamo.guar... | KailinLi/nflows | ELUPlus | false | 8,381 | [
"MIT"
] | 13 | 7c07a1d5e510beb681d1b11d6ffda95a086a8153 | https://github.com/KailinLi/nflows/tree/7c07a1d5e510beb681d1b11d6ffda95a086a8153 | import torch
from torch import nn
import torch.nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.elu = nn.ELU()
def forward(self, x):
return self.elu(x) + 1.0
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
Memory | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.parallel
class Memory(nn.Module):
def __init__(self):
super(Memory, self).__init__()
self.sm = nn.Softmax()
self.mask = None
def applyMask(self, mask):
self.mask = mask
def forward(self, input, context_key, content_value... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JoonHong-Kim/T2I_CL | Memory | false | 8,382 | [
"MIT"
] | 35 | c52aa73da903d6e4174eeef2663e5bc1163785b1 | https://github.com/JoonHong-Kim/T2I_CL/tree/c52aa73da903d6e4174eeef2663e5bc1163785b1 | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self):
super().__init__()
self.sm = nn.Softmax()
self.mask = None
def applyMask(self, mask):
self.mask = mask
def forward(self, input, context_key, content_value):
""... |
DiceLossWithLogits | # 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
def flatten_samples(input_):
"""
Flattens a tensor or a variable such that the channel axis is first and the sample axis
is second. The shapes are transformed as follows:
(N, C, H, W) --> (C, N * H * W)
(N, C, D, H, W) --> (C, N * ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | JonasHell/torch-em | DiceLossWithLogits | false | 8,383 | [
"MIT"
] | 13 | 2e008e0cd2f0ea6681581374fce4f9f47b986d55 | https://github.com/JonasHell/torch-em/tree/2e008e0cd2f0ea6681581374fce4f9f47b986d55 | import torch
import torch.nn as nn
import torch.utils.data
def flatten_samples(input_):
"""
Flattens a tensor or a variable such that the channel axis is first and the sample axis
is second. The shapes are transformed as follows:
(N, C, H, W) --> (C, N * H * W)
(N, C, D, H, W) --> (C, N * ... |
ActorNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ActorNet(nn.Module):
""" Actor Network """
def __init__(self, state_num, action_num, hidden1=256, hidden2=256,
hidden3=256):
"""
:param state_num: number of states
:param action_num: number of actions
:param hidden1: hidden lay... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | Kanaderu/spiking-ddpg-mapless-navigation | ActorNet | false | 8,384 | [
"MIT"
] | 29 | 2b5e7e67385dee4428b8036bc4ffe95e812b34e0 | https://github.com/Kanaderu/spiking-ddpg-mapless-navigation/tree/2b5e7e67385dee4428b8036bc4ffe95e812b34e0 | import torch
import torch.nn as nn
class Model(nn.Module):
""" Actor Network """
def __init__(self, state_num, action_num, hidden1=256, hidden2=256,
hidden3=256):
"""
:param state_num: number of states
:param action_num: number of actions
:param hidden1: hidden layer ... |
StochasticClassifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 StochasticClassifier(nn.Module):
def __init__(self, num_features, num_classes, temp=0.05):
super().__init__()
self.mu = nn.Parameter(0.01 * torch.randn(num_classes, num_features))
self.sigma = nn.Parameter(torch... | import torch
from torch import device
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from... | KaiyangZhou/ssdg-benchmark | StochasticClassifier | false | 8,385 | [
"MIT"
] | 43 | aaa48be4f93b77347fbadff649be6b3e0f7a8779 | https://github.com/KaiyangZhou/ssdg-benchmark/tree/aaa48be4f93b77347fbadff649be6b3e0f7a8779 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, num_features, num_classes, temp=0.05):
super().__init__()
self.mu = nn.Parameter(0.01 * torch.randn(num_classes, num_features))
self.sigma = nn.Parameter(torch.zeros(num_clas... |
Highway | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Highway(nn.Module):
"""Highway network"""
def __init__(self, input_size):
super(Highway, self).__init__()
self.fc1 = nn.Linear(input_size, input_size, bias=True)
self.fc2 = nn.Linear(input_size, input_size, 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 torch.nn as nn
assert_... | Kailianghu/Character-Aware-Neural-Language-Model | Highway | false | 8,386 | [
"MIT"
] | 35 | 6bd72ce00a3ac9eb152ba006bdae8a6922e0ad35 | https://github.com/Kailianghu/Character-Aware-Neural-Language-Model/tree/6bd72ce00a3ac9eb152ba006bdae8a6922e0ad35 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Highway network"""
def __init__(self, input_size):
super().__init__()
self.fc1 = nn.Linear(input_size, input_size, bias=True)
self.fc2 = nn.Linear(input_size, input_size, bias=True)
def ... |
BCEDiceLossWithLogits | # 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
def flatten_samples(input_):
"""
Flattens a tensor or a variable such that the channel axis is first and the sample axis
is second. The shapes are transformed as follows:
(N, C, H, W) --> (C, N * H * W)
(N, C, D, H, W) --> (C, N * ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | JonasHell/torch-em | BCEDiceLossWithLogits | false | 8,387 | [
"MIT"
] | 13 | 2e008e0cd2f0ea6681581374fce4f9f47b986d55 | https://github.com/JonasHell/torch-em/tree/2e008e0cd2f0ea6681581374fce4f9f47b986d55 | import torch
import torch.nn as nn
import torch.utils.data
def flatten_samples(input_):
"""
Flattens a tensor or a variable such that the channel axis is first and the sample axis
is second. The shapes are transformed as follows:
(N, C, H, W) --> (C, N * H * W)
(N, C, D, H, W) --> (C, N * ... |
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
from torch import nn
import torch.nn.functional as F
class ResBlock(nn.Module):
def __init__(self, dim, dropout=0):
super(ResBlock, self).__init__()
self.dim = dim
self.dropout = nn.Dropout(dropout)
self.linear1 = nn.Linear(self.dim, self.dim)
self.linear2 = n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | JiwanChung/tapm | ResBlock | false | 8,388 | [
"MIT"
] | 14 | ec42b139d1c012daccc55f85e67744488d526476 | https://github.com/JiwanChung/tapm/tree/ec42b139d1c012daccc55f85e67744488d526476 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim, dropout=0):
super().__init__()
self.dim = dim
self.dropout = nn.Dropout(dropout)
self.linear1 = nn.Linear(self.dim, self.dim)
self.linear2 = nn.Linear(self.dim... |
FeatureEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FeatureEncoder(nn.Module):
def __init__(self, video_dim, dim):
super(FeatureEncoder, self).__init__()
self.linear = nn.Linear(video_dim, dim)
def forward(self, feature, h=None):
feature = self.linear(feature)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | JiwanChung/tapm | FeatureEncoder | false | 8,389 | [
"MIT"
] | 14 | ec42b139d1c012daccc55f85e67744488d526476 | https://github.com/JiwanChung/tapm/tree/ec42b139d1c012daccc55f85e67744488d526476 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, video_dim, dim):
super().__init__()
self.linear = nn.Linear(video_dim, dim)
def forward(self, feature, h=None):
feature = self.linear(feature)
feature = F.leaky_relu(f... |
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, input_dim, output_dim):
super(net, self).__init__()
self.fc1 = nn.Linear(input_dim, 30)
self.fc1.weight.data.normal_(0, 1)
self.fc2 = nn.Linear(30, 20)
self.fc2.weig... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | Kernels-K/DDPG-pytorch- | net | false | 8,390 | [
"MIT"
] | 26 | 9a80a56f52f2232e5bd197521d3d2d388b48c882 | https://github.com/Kernels-K/DDPG-pytorch-/tree/9a80a56f52f2232e5bd197521d3d2d388b48c882 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_dim, output_dim):
super().__init__()
self.fc1 = nn.Linear(input_dim, 30)
self.fc1.weight.data.normal_(0, 1)
self.fc2 = nn.Linear(30, 20)
self.fc2.weight.data... |
GraphConvolution | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GraphConvolution(nn.Module):
def __init__(self, in_dim, out_dim):
super(GraphConvolution, self).__init__()
self.relu = nn.LeakyReLU(0.2)
self.weight = nn.Conv1d(in_dim, out_dim, 1)
def forward(self, adj, nodes):
nodes = torch.matmul(no... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Kanaricc/TDRG | GraphConvolution | false | 8,391 | [
"Apache-2.0"
] | 16 | 91416976c8887877775f516ebee60469449e7e5f | https://github.com/Kanaricc/TDRG/tree/91416976c8887877775f516ebee60469449e7e5f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_dim, out_dim):
super().__init__()
self.relu = nn.LeakyReLU(0.2)
self.weight = nn.Conv1d(in_dim, out_dim, 1)
def forward(self, adj, nodes):
nodes = torch.matmul(nodes, adj)
nodes = self.re... |
ANet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ANet(nn.Module):
def __init__(self, s_dim, a_dim):
super(ANet, self).__init__()
self.fc1 = nn.Linear(s_dim, 30)
self.fc1.weight.data.normal_(0, 0.1)
self.out = nn.Linear(30, a_dim)
self.out.weight.dat... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Kernels-K/DDPG-pytorch- | ANet | false | 8,392 | [
"MIT"
] | 26 | 9a80a56f52f2232e5bd197521d3d2d388b48c882 | https://github.com/Kernels-K/DDPG-pytorch-/tree/9a80a56f52f2232e5bd197521d3d2d388b48c882 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, s_dim, a_dim):
super().__init__()
self.fc1 = nn.Linear(s_dim, 30)
self.fc1.weight.data.normal_(0, 0.1)
self.out = nn.Linear(30, a_dim)
self.out.weight.data.normal_... |
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
import torch.utils.data
def flatten_samples(input_):
"""
Flattens a tensor or a variable such that the channel axis is first and the sample axis
is second. The shapes are transformed as follows:
(N, C, H, W) --> (C, N * H * W)
(N, C, D, H, W) --> (C, N * ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | JonasHell/torch-em | DiceLoss | false | 8,393 | [
"MIT"
] | 13 | 2e008e0cd2f0ea6681581374fce4f9f47b986d55 | https://github.com/JonasHell/torch-em/tree/2e008e0cd2f0ea6681581374fce4f9f47b986d55 | import torch
import torch.nn as nn
import torch.utils.data
def flatten_samples(input_):
"""
Flattens a tensor or a variable such that the channel axis is first and the sample axis
is second. The shapes are transformed as follows:
(N, C, H, W) --> (C, N * H * W)
(N, C, D, H, W) --> (C, N * ... |
TopKMaxPooling | # 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 TopKMaxPooling(nn.Module):
def __init__(self, kmax=1.0):
super(TopKMaxPooling, self).__init__()
self.kmax = kmax
@staticmethod
def get_positive_k(k, n):
if k <= 0:
return 0
elif k < 1:
return round(k * n)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | Kanaricc/TDRG | TopKMaxPooling | false | 8,394 | [
"Apache-2.0"
] | 16 | 91416976c8887877775f516ebee60469449e7e5f | https://github.com/Kanaricc/TDRG/tree/91416976c8887877775f516ebee60469449e7e5f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, kmax=1.0):
super().__init__()
self.kmax = kmax
@staticmethod
def get_positive_k(k, n):
if k <= 0:
return 0
elif k < 1:
return round(k * n)
elif k > n:
... |
HadamardProduct | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 HadamardProduct(nn.Module):
def __init__(self, shape):
super(HadamardProduct, self).__init__()
self.weights = nn.Parameter(torch.rand(shape))
def forward(self, x):
return x * self.weights
def get_inputs():
return [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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | KimUyen/LSTM-BCI-Decoder | HadamardProduct | false | 8,395 | [
"MIT"
] | 38 | c7b4bd108335a4d6c7d99c00c263346026186b0b | https://github.com/KimUyen/LSTM-BCI-Decoder/tree/c7b4bd108335a4d6c7d99c00c263346026186b0b | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, shape):
super().__init__()
self.weights = nn.Parameter(torch.rand(shape))
def forward(self, x):
return x * self.weights
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
... |
ResNetBottleneck | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResNetBottleneck(nn.Module):
def __init__(self, in_channels, out_channels, bottleneck_channels,
stride, downsample=None):
super(ResNetBottleneck, self).__init__()
self.conv1 = nn.Conv2d(in_channels, bottleneck_channel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | KH-Kyle/rmp_nav | ResNetBottleneck | false | 8,396 | [
"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, in_channels, out_channels, bottleneck_channels,
stride, downsample=None):
super().__init__()
self.conv1 = nn.Conv2d(in_channels, bottleneck_channels,
kernel_size=1, bia... |
GlobalAttention_text | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.parallel
class GlobalAttention_text(nn.Module):
def __init__(self, idf, cdf):
super(GlobalAttention_text, self).__init__()
self.conv_context = nn.Conv1d(cdf, idf, kernel_size=1, stride=1,
padding=0)
self.sm = nn.Softmax()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JoonHong-Kim/T2I_CL | GlobalAttention_text | false | 8,397 | [
"MIT"
] | 35 | c52aa73da903d6e4174eeef2663e5bc1163785b1 | https://github.com/JoonHong-Kim/T2I_CL/tree/c52aa73da903d6e4174eeef2663e5bc1163785b1 | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, idf, cdf):
super().__init__()
self.conv_context = nn.Conv1d(cdf, idf, kernel_size=1, stride=1,
padding=0)
self.sm = nn.Softmax()
self.mask = None
def applyMask(s... |
GRUCell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GRUCell(nn.Module):
def __init__(self, input_size, hidden_size, init_scale=1.0,
no_weight_init=False):
super(GRUCell, self).__init__()
self.recurrent = nn.GRUCell(input_size, hidden_size)
if not no_weight_init:
for name, param 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 import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | KH-Kyle/rmp_nav | GRUCell | false | 8,398 | [
"MIT"
] | 30 | d598fe70664a4cdc0e9b9dd4b52e84aa3de1b551 | https://github.com/KH-Kyle/rmp_nav/tree/d598fe70664a4cdc0e9b9dd4b52e84aa3de1b551 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_size, hidden_size, init_scale=1.0,
no_weight_init=False):
super().__init__()
self.recurrent = nn.GRUCell(input_size, hidden_size)
if not no_weight_init:
for name, param in self.recurrent... |
Fusion | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Fusion(nn.Module):
""" Crazy multi-modal fusion: negative squared difference minus relu'd sum
"""
def __init__(self):
super().__init__()
def forward(self, x, y):
return -(x - y) ** 2 + F.... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | KaihuaTang/VCTree-Visual-Question-Answering | Fusion | false | 8,399 | [
"MIT"
] | 31 | b6b0a8bdb01d45d36de3bded91db42544ad6a593 | https://github.com/KaihuaTang/VCTree-Visual-Question-Answering/tree/b6b0a8bdb01d45d36de3bded91db42544ad6a593 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
""" Crazy multi-modal fusion: negative squared difference minus relu'd sum
"""
def __init__(self):
super().__init__()
def forward(self, x, y):
return -(x - y) ** 2 + F.r... |
CommandEmbedding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
from torch import nn
class CommandEmbedding(nn.Module):
def __init__(self, input_size, output_size):
super().__init__()
self.embedding = nn.Linear(input_size, output_size // 2)
self.encoding = nn.Parameter(torch.rand(1, 1, output_size // 2))
def ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | Kaixhin/GUDRL | CommandEmbedding | false | 8,400 | [
"MIT"
] | 26 | c13fa605a9ffb4c2932390b0b86e476aec62c142 | https://github.com/Kaixhin/GUDRL/tree/c13fa605a9ffb4c2932390b0b86e476aec62c142 | import torch
from torch import Tensor
from torch import nn
class Model(nn.Module):
def __init__(self, input_size, output_size):
super().__init__()
self.embedding = nn.Linear(input_size, output_size // 2)
self.encoding = nn.Parameter(torch.rand(1, 1, output_size // 2))
def forward(sel... |
BertLayerNormNoVar | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 BertLayerNormNoVar(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
super(BertLayerNormNoVar, self).__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.bias = nn.Parameter(torch.zeros(hidden_size))
self.variance_epsil... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | KaidiXu/LiRPA_Verify | BertLayerNormNoVar | false | 8,401 | [
"BSD-2-Clause"
] | 14 | 71f5327a8abf136bcfb3e1ec07604628abf8126e | https://github.com/KaidiXu/LiRPA_Verify/tree/71f5327a8abf136bcfb3e1ec07604628abf8126e | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
super().__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.bias = nn.Parameter(torch.zeros(hidden_size))
self.variance_epsilon = eps
def forward(self, x):
... |
ConvLSTMCell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.autograd import Variable
class ConvLSTMCell(nn.Module):
def __init__(self, input_channels, hidden_channels, kernel_size, bias=True
):
super(ConvLSTMCell, self).__init__()
assert hidden_channels % 2 == 0
self.input_channels = input_chan... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | Kwanss/PCLNet | ConvLSTMCell | false | 8,402 | [
"MIT"
] | 31 | d288820975a9daf23eab47c52d7ea6f7dd564725 | https://github.com/Kwanss/PCLNet/tree/d288820975a9daf23eab47c52d7ea6f7dd564725 | import torch
import torch.nn as nn
from torch.autograd import Variable
class Model(nn.Module):
def __init__(self, input_channels, hidden_channels, kernel_size, bias=True
):
super().__init__()
assert hidden_channels % 2 == 0
self.input_channels = input_channels
self.hidden_... |
CAMBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CAMBlock(torch.nn.Module):
def __init__(self, inplanes, redr, pool='full'):
super(CAMBlock, self).__init__()
self.planes = inplanes // redr
self.poolingavg = torch.nn.AdaptiveAvgPool2d((1, 1))
self.poolingmax = torch.nn.AdaptiveMaxPool2d((1, 1))
self.avg... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | Knight825/models-pytorch | CAMBlock | false | 8,403 | [
"Apache-2.0"
] | 16 | 133559eebb8795d78a32fa44d49408d0c5167ae9 | https://github.com/Knight825/models-pytorch/tree/133559eebb8795d78a32fa44d49408d0c5167ae9 | import torch
class Model(torch.nn.Module):
def __init__(self, inplanes, redr, pool='full'):
super().__init__()
self.planes = inplanes // redr
self.poolingavg = torch.nn.AdaptiveAvgPool2d((1, 1))
self.poolingmax = torch.nn.AdaptiveMaxPool2d((1, 1))
self.avglinear1 = torch.n... |
Gram | # 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 Gram(nn.Module):
def __init__(self):
super(Gram, self).__init__()
def forward(self, input):
a, b, c, d = input.size()
feature = input.view(a * b, c * d)
gram = torch.mm(feature, feature.t())
gram /= a * b * c * d
return... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | L1aoXingyu/neural-transfer | Gram | false | 8,404 | [
"MIT"
] | 45 | bed445791d823872d9a40ea8927681d8cc99e8df | https://github.com/L1aoXingyu/neural-transfer/tree/bed445791d823872d9a40ea8927681d8cc99e8df | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input):
a, b, c, d = input.size()
feature = input.view(a * b, c * d)
gram = torch.mm(feature, feature.t())
gram /= a * b * c * d
return gram
d... |
BiLSTM_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 as T
import torch.nn as nn
class BiLSTM_Encoder(nn.Module):
def __init__(self, D: 'int', hidden_size: 'int', dropout: 'float'):
super(BiLSTM_Encoder, self).__init__()
self.D = D
self.hidden_size = hidden_size
self.initial_hidden_f = nn.Parameter(T.randn(1... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch as T
i... | JRC1995/BERT-Disaster-Classification-Capsule-Routing | BiLSTM_Encoder | false | 8,405 | [
"MIT"
] | 16 | 520d2b37af309c95f09bcda321915cffae803086 | https://github.com/JRC1995/BERT-Disaster-Classification-Capsule-Routing/tree/520d2b37af309c95f09bcda321915cffae803086 | import torch
import torch as T
import torch.nn as nn
class Model(nn.Module):
def __init__(self, D: 'int', hidden_size: 'int', dropout: 'float'):
super().__init__()
self.D = D
self.hidden_size = hidden_size
self.initial_hidden_f = nn.Parameter(T.randn(1, hidden_size))
self.... |
MultiHeadQKVAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : 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
from torch._inductor.runtime.... | KohavTal/SCAE_Project | MultiHeadQKVAttention | false | 8,406 | [
"Apache-2.0"
] | 40 | bc6d1c3697fcb9327dd96e9657c3299b47cf355e | https://github.com/KohavTal/SCAE_Project/tree/bc6d1c3697fcb9327dd96e9657c3299b47cf355e | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : Tensor... |
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 numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : 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
from torch._inductor.runtime.... | KohavTal/SCAE_Project | MAB | false | 8,407 | [
"Apache-2.0"
] | 40 | bc6d1c3697fcb9327dd96e9657c3299b47cf355e | https://github.com/KohavTal/SCAE_Project/tree/bc6d1c3697fcb9327dd96e9657c3299b47cf355e | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : Tensor... |
ConditionalLayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 sklearn.metrics import *
from torch import nn
class ConditionalLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-06):
super(ConditionalLayerNorm, self).__init__()
self.eps = eps
self.gamma_dense = nn.Linear(hidden_size, hidden_size, bias=False)
self.be... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 sklearn.metric... | JiaweiSheng/CasEE | ConditionalLayerNorm | false | 8,408 | [
"MIT"
] | 44 | af69432baf34d150f4721a4b4119002555758601 | https://github.com/JiaweiSheng/CasEE/tree/af69432baf34d150f4721a4b4119002555758601 | import torch
from sklearn.metrics import *
from torch import nn
class Model(nn.Module):
def __init__(self, hidden_size, eps=1e-06):
super().__init__()
self.eps = eps
self.gamma_dense = nn.Linear(hidden_size, hidden_size, bias=False)
self.beta_dense = nn.Linear(hidden_size, hidden_... |
VisTransformerDecoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
from typing import Tuple
from typing import Optional
import torch.nn as nn
class VisTransformerDecoderLayer(nn.TransformerDecoderLayer):
def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
activation='relu', layer_norm_eps=1e-05, batch_first=False, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Kamino666/Video-Captioning-Transformer | VisTransformerDecoderLayer | false | 8,409 | [
"Apache-2.0"
] | 14 | 06e6c95d9bf11d61f5825be3c640e489521f9934 | https://github.com/Kamino666/Video-Captioning-Transformer/tree/06e6c95d9bf11d61f5825be3c640e489521f9934 | import torch
from torch import Tensor
from typing import Tuple
from typing import Optional
import torch.nn as nn
class Model(nn.TransformerDecoderLayer):
def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
activation='relu', layer_norm_eps=1e-05, batch_first=False, device=
None,... |
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 numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : 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
from torch._inductor.runtime.... | KohavTal/SCAE_Project | SAB | false | 8,410 | [
"Apache-2.0"
] | 40 | bc6d1c3697fcb9327dd96e9657c3299b47cf355e | https://github.com/KohavTal/SCAE_Project/tree/bc6d1c3697fcb9327dd96e9657c3299b47cf355e | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : Tensor... |
AvgPoolShortCut | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn import functional as F
class AvgPoolShortCut(nn.Module):
def __init__(self, stride, out_c, in_c):
super(AvgPoolShortCut, self).__init__()
self.stride = stride
self.out_c = out_c
self.in_c = in_c
def forward(self, x):
if ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | Karthik-Ragunath/DDU | AvgPoolShortCut | false | 8,411 | [
"MIT"
] | 43 | b9daae9304bdeb222857884ef8cb3b6b3d004d33 | https://github.com/Karthik-Ragunath/DDU/tree/b9daae9304bdeb222857884ef8cb3b6b3d004d33 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, stride, out_c, in_c):
super().__init__()
self.stride = stride
self.out_c = out_c
self.in_c = in_c
def forward(self, x):
if x.shape[2] % 2 != 0:
... |
CNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CNet(nn.Module):
def __init__(self, s_dim, a_dim):
super(CNet, self).__init__()
self.fcs = nn.Linear(s_dim, 30)
self.fcs.weight.data.normal_(0, 0.1)
self.fca = nn.Linear(a_dim, 30)
self.fca.weight.dat... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | Kernels-K/DDPG-pytorch- | CNet | false | 8,412 | [
"MIT"
] | 26 | 9a80a56f52f2232e5bd197521d3d2d388b48c882 | https://github.com/Kernels-K/DDPG-pytorch-/tree/9a80a56f52f2232e5bd197521d3d2d388b48c882 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, s_dim, a_dim):
super().__init__()
self.fcs = nn.Linear(s_dim, 30)
self.fcs.weight.data.normal_(0, 0.1)
self.fca = nn.Linear(a_dim, 30)
self.fca.weight.data.normal_... |
HSwish | # 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
class HSwish(nn.Module):
"""
H-Swish activation function from 'Searching for MobileNetV3,' https://arxiv.org/abs/1905.02244.
Parameters:
----------
inplace : bool
Whether to use inplace version of the module.
"""
def __init__(self... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.nn
assert_size_stride = torch._C._dynamo.guards.assert... | Kthyeon/micronet_neurips_challenge | HSwish | false | 8,413 | [
"MIT"
] | 19 | 9f71fb752e8fbd5abca07be530f7fb19e164125c | https://github.com/Kthyeon/micronet_neurips_challenge/tree/9f71fb752e8fbd5abca07be530f7fb19e164125c | import torch
import torch.nn as nn
import torch.nn
class Model(nn.Module):
"""
H-Swish activation function from 'Searching for MobileNetV3,' https://arxiv.org/abs/1905.02244.
Parameters:
----------
inplace : bool
Whether to use inplace version of the module.
"""
def __init__(self,... |
SAMblock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SAMblock(torch.nn.Module):
def __init__(self, size=7, model='full', outplanes=None):
super(SAMblock, self).__init__()
self.outplanes = outplanes
if self.outplanes is None:
self.outplanes = 1
self.model = model
self.conv1 = torch.nn.Conv2d(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... | Knight825/models-pytorch | SAMblock | false | 8,414 | [
"Apache-2.0"
] | 16 | 133559eebb8795d78a32fa44d49408d0c5167ae9 | https://github.com/Knight825/models-pytorch/tree/133559eebb8795d78a32fa44d49408d0c5167ae9 | import torch
class Model(torch.nn.Module):
def __init__(self, size=7, model='full', outplanes=None):
super().__init__()
self.outplanes = outplanes
if self.outplanes is None:
self.outplanes = 1
self.model = model
self.conv1 = torch.nn.Conv2d(2, self.outplanes, (... |
CrossAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CrossAttention(nn.Module):
def __init__(self, in_channel=256, ratio=8):
super(CrossAttention, self).__init__()
self.conv_query = nn.Conv2d(in_channel, in_channel // ratio,
kernel_size=1)
self.conv_key = nn.Conv2d(in_channel, in_channel ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | JosephChenHub/DPANet | CrossAttention | false | 8,415 | [
"MIT"
] | 19 | 68cf40a405d8c8c6506884079cd0a206d6d58e63 | https://github.com/JosephChenHub/DPANet/tree/68cf40a405d8c8c6506884079cd0a206d6d58e63 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channel=256, ratio=8):
super().__init__()
self.conv_query = nn.Conv2d(in_channel, in_channel // ratio,
kernel_size=1)
self.conv_key = nn.Conv2d(in_channel, in_channel // ratio,
kernel_... |
ISAB | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : 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
from torch._inductor.runtime.... | KohavTal/SCAE_Project | ISAB | false | 8,416 | [
"Apache-2.0"
] | 40 | bc6d1c3697fcb9327dd96e9657c3299b47cf355e | https://github.com/KohavTal/SCAE_Project/tree/bc6d1c3697fcb9327dd96e9657c3299b47cf355e | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : Tensor... |
PositionWiseFeedForwardNetworks | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
def Linear(in_features, out_features, bias=True):
m = nn.Linear(in_features, out_features, bias)
nn.init.xavier_uniform_(m.weight)
if bias:
nn.init.constant_(m.bias, 0.0)
return m
class PositionWiseFeedForwardNetworks(nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | L-Zhe/FasySeq | PositionWiseFeedForwardNetworks | false | 8,417 | [
"Apache-2.0"
] | 34 | 2cd2abd290666b1e118d8ad11c973b58ca4f0573 | https://github.com/L-Zhe/FasySeq/tree/2cd2abd290666b1e118d8ad11c973b58ca4f0573 | import torch
from torch import nn
from torch.nn import functional as F
def Linear(in_features, out_features, bias=True):
m = nn.Linear(in_features, out_features, bias)
nn.init.xavier_uniform_(m.weight)
if bias:
nn.init.constant_(m.bias, 0.0)
return m
class Model(nn.Module):
def __init__... |
SEBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SEBlock(torch.nn.Module):
def __init__(self, inplanes, redr, poolflag='avg'):
super(SEBlock, self).__init__()
if poolflag == 'max':
self.pool = torch.nn.AdaptiveMaxPool2d((1, 1))
if poolflag == 'avg':
self.pool = torch.nn.AdaptiveAvgPool2d((1, 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
assert_size_stride = torch._C... | Knight825/models-pytorch | SEBlock | false | 8,418 | [
"Apache-2.0"
] | 16 | 133559eebb8795d78a32fa44d49408d0c5167ae9 | https://github.com/Knight825/models-pytorch/tree/133559eebb8795d78a32fa44d49408d0c5167ae9 | import torch
class Model(torch.nn.Module):
def __init__(self, inplanes, redr, poolflag='avg'):
super().__init__()
if poolflag == 'max':
self.pool = torch.nn.AdaptiveMaxPool2d((1, 1))
if poolflag == 'avg':
self.pool = torch.nn.AdaptiveAvgPool2d((1, 1))
self.... |
FourierEmbedding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FourierEmbedding(nn.Module):
def __init__(self, features, height, width, **kwargs):
super().__init__(**kwargs)
self.projector = nn.Linear(2, features)
self._height = height
self._width = width
def forward(self, y, x):
x_norm = 2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch im... | LS4GAN/uvcgan | FourierEmbedding | false | 8,419 | [
"BSD-2-Clause"
] | 20 | 376439ae2a9be684ff279ddf634fe137aadc5df5 | https://github.com/LS4GAN/uvcgan/tree/376439ae2a9be684ff279ddf634fe137aadc5df5 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, features, height, width, **kwargs):
super().__init__(**kwargs)
self.projector = nn.Linear(2, features)
self._height = height
self._width = width
def forward(self, y, x):
x_norm = 2 * x / (sel... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Critic(nn.Module):
def __init__(self, state_dim, hidden_dim=64):
super(Critic, self).__init__()
self.l1 = nn.Linear(state_dim, hidden_dim)
self.l2 = nn.Linear(hidden_dim, hidden_dim)
self.l3 = nn.Linear(hidden_dim, 1)
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.triton_helpers import libdevice
import torch.nn as ... | LQNew/LWDRL | Critic | false | 8,420 | [
"MIT"
] | 11 | 0e4fab077a0cfbd27590b840557f4fda033c74ff | https://github.com/LQNew/LWDRL/tree/0e4fab077a0cfbd27590b840557f4fda033c74ff | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, state_dim, hidden_dim=64):
super().__init__()
self.l1 = nn.Linear(state_dim, hidden_dim)
self.l2 = nn.Linear(hidden_dim, hidden_dim)
self.l3 = nn.Linear(hidden_dim, 1)
def forward(self, state):
... |
PMA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : 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
from torch._inductor.runtime.... | KohavTal/SCAE_Project | PMA | false | 8,421 | [
"Apache-2.0"
] | 40 | bc6d1c3697fcb9327dd96e9657c3299b47cf355e | https://github.com/KohavTal/SCAE_Project/tree/bc6d1c3697fcb9327dd96e9657c3299b47cf355e | import math
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def qkv_attention(queries, keys, values, presence=None):
"""
Transformer-like self-attention.
Args:
queries: Tensor of shape [B, N, d_k].
keys: Tensor of shape [B, M, d_k].
values: : Tensor... |
MeanMap | # 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.autograd
class MeanMap(nn.Module):
"""
Compute vanilla mean on a 4D tensor. This acts as a standard PyTorch layer.
The Mean is computed independantly for each batch item at each location x,y
Input should be:
(1... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.autograd
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._d... | LLNL/fastcam | MeanMap | false | 8,422 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
Compute vanilla mean on a 4D tensor. This acts as a standard PyTorch layer.
The Mean is computed independantly for each batch item at each location x,y
Input should be:
(1) ... |
SMOEScaleMap | # 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.autograd
class SMOEScaleMap(nn.Module):
"""
Compute SMOE Scale on a 4D tensor. This acts as a standard PyTorch layer.
SMOE Scale is computed independantly for each batch item at each location x,y
Input should be:
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.autograd
assert_size_stride = torch._C._dyna... | LLNL/fastcam | SMOEScaleMap | false | 8,423 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
Compute SMOE Scale on a 4D tensor. This acts as a standard PyTorch layer.
SMOE Scale is computed independantly for each batch item at each location x,y
Input should be:
(1) ... |
EqualConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from math import sqrt
def equal_lr(module, name='weight'):
EqualLR.apply(module, name)
return module
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, module):
weight = getattr(module, self.name + '_orig')
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from math import sqrt
assert_size_stride = torch._C._dynam... | KwonGihyun/DiagonalGAN | EqualConv2d | false | 8,424 | [
"MIT"
] | 13 | 9e401c00e741d700f85df2c715ee11c1e66e1d1c | https://github.com/KwonGihyun/DiagonalGAN/tree/9e401c00e741d700f85df2c715ee11c1e66e1d1c | import torch
import torch.nn as nn
from math import sqrt
def equal_lr(module, name='weight'):
EqualLR.apply(module, name)
return module
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, module):
weight = getattr(module, self.name + '_orig')
... |
SE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SE(nn.Module):
"""Squeeze-and-Excitation block."""
def __init__(self, in_planes, se_planes):
super(SE, self).__init__()
self.se1 = nn.Conv2d(in_planes, se_planes, kernel_size=1, bias=True)
self.se2 = nn.Conv2d(se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | LIJUNYI95/SuperAdam | SE | false | 8,425 | [
"MIT"
] | 14 | 00fc8a4d90bd037ccb9b871fbc64482818457b93 | https://github.com/LIJUNYI95/SuperAdam/tree/00fc8a4d90bd037ccb9b871fbc64482818457b93 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Squeeze-and-Excitation block."""
def __init__(self, in_planes, se_planes):
super().__init__()
self.se1 = nn.Conv2d(in_planes, se_planes, kernel_size=1, bias=True)
self.se2 = nn.Conv2d(se_plan... |
StdMap | # 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.autograd
class StdMap(nn.Module):
"""
Compute vanilla standard deviation on a 4D tensor. This acts as a standard PyTorch layer.
Standard Deviation is computed independantly for each batch item at each location x,y
Input should ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.autograd
assert_size_stride = torch._C._dyna... | LLNL/fastcam | StdMap | false | 8,426 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
Compute vanilla standard deviation on a 4D tensor. This acts as a standard PyTorch layer.
Standard Deviation is computed independantly for each batch item at each location x,y
Input should b... |
RangeNorm2D | # 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.autograd
class RangeNorm2D(nn.Module):
"""
This will normalize a saliency map to range from 0 to 1 via linear range function.
Input and output will be a 3D tensor of size [batch size x height x width].
Input can be any rea... | 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.autograd
assert_size_stride = torch._C._dynamo.guards.... | LLNL/fastcam | RangeNorm2D | false | 8,427 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
This will normalize a saliency map to range from 0 to 1 via linear range function.
Input and output will be a 3D tensor of size [batch size x height x width].
Input can be any real valu... |
MaxMap | # 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.autograd
class MaxMap(nn.Module):
"""
Compute vanilla mean on a 4D tensor. This acts as a standard PyTorch layer.
The Max is computed independantly for each batch item at each location x,y
Input should be:
(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
import torch.nn as nn
import torch.autograd
assert_size_stride = torch._C._dynamo.guards.... | LLNL/fastcam | MaxMap | false | 8,428 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
Compute vanilla mean on a 4D tensor. This acts as a standard PyTorch layer.
The Max is computed independantly for each batch item at each location x,y
Input should be:
(1) A... |
InfoNCE_loss_vectorized | # 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 InfoNCE_loss_vectorized(nn.Module):
"""
SimCLR loss: https://github.com/google-research/simclr // https://github.com/sthalles/SimCLR
"""
def __init__(self, temperature):
super(InfoNCE_loss_vectorized, self).__init__()
self.temperature = tem... | 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... | LIIR-KULeuven/CLDR_CLNER_models | InfoNCE_loss_vectorized | false | 8,429 | [
"MIT"
] | 12 | 5fe47a988b88a36d0ccf4484aff5ab70c59f39d6 | https://github.com/LIIR-KULeuven/CLDR_CLNER_models/tree/5fe47a988b88a36d0ccf4484aff5ab70c59f39d6 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
SimCLR loss: https://github.com/google-research/simclr // https://github.com/sthalles/SimCLR
"""
def __init__(self, temperature):
super().__init__()
self.temperature = temperature
self.cos = nn.CosineSimilarity... |
ClassificationModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ClassificationModel(nn.Module):
def __init__(self, num_features_in, num_anchors=9, num_classes=80,
prior=0.01, feature_size=256):
super(ClassificationModel, self).__init__()
self.num_classes = num_classes
self.num_anchors = num_anchors
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | LLYXC/OXNet | ClassificationModel | false | 8,430 | [
"Apache-2.0"
] | 13 | 4fb67a8c42b9158a8e563c4b68a157e4dedd9c66 | https://github.com/LLYXC/OXNet/tree/4fb67a8c42b9158a8e563c4b68a157e4dedd9c66 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_features_in, num_anchors=9, num_classes=80,
prior=0.01, feature_size=256):
super().__init__()
self.num_classes = num_classes
self.num_anchors = num_anchors
self.conv1 = nn.Conv2d(num_features... |
TwoLayerNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 TwoLayerNet(torch.nn.Module):
def __init__(self, D_in, H, D_out):
super(TwoLayerNet, self).__init__()
self.linear1 = torch.nn.Linear(D_in, H)
self.linear2 = torch.nn.Linear(H, D_out)
def forward(self, x):
h_relu = self.linear1(x).clamp(min=0)
y_pred... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | KentonMurray/ProxGradPytorch | TwoLayerNet | false | 8,431 | [
"MIT"
] | 27 | c534a49142ac9ec149ca67de24bb0487fde1607b | https://github.com/KentonMurray/ProxGradPytorch/tree/c534a49142ac9ec149ca67de24bb0487fde1607b | import torch
class Model(torch.nn.Module):
def __init__(self, D_in, H, D_out):
super().__init__()
self.linear1 = torch.nn.Linear(D_in, H)
self.linear2 = torch.nn.Linear(H, D_out)
def forward(self, x):
h_relu = self.linear1(x).clamp(min=0)
y_pred = self.linear2(h_relu)... |
DiagonalwiseRefactorization | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.parallel
import torch.optim
import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
def get_mask(in_channels, channels, ks):
in_channels = int(in_channels)
channels = int(channels)
if len(ks) == 1:
mask = np.zer... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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.parallel
import torch.optim
import torch
impo... | LaputaDream/region-based-non-local-network | DiagonalwiseRefactorization | false | 8,432 | [
"MIT"
] | 18 | 98e5fb3d8010e8c5360ac3066fdc06c37106d7dc | https://github.com/LaputaDream/region-based-non-local-network/tree/98e5fb3d8010e8c5360ac3066fdc06c37106d7dc | import torch
import numpy as np
import torch.nn.parallel
import torch.optim
import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
def get_mask(in_channels, channels, ks):
in_channels = int(in_channels)
channels = int(channels)
if len(ks) == 1:
mask = np.zer... |
GroupLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GroupLinear(nn.Module):
def __init__(self, in_features, out_features, groups, bias=True):
super(GroupLinear, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.groups = groups
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | Lakonik/EPro-PnP | GroupLinear | false | 8,433 | [
"Apache-2.0"
] | 19 | 931df847190ce10eddd1dc3e3168ce1a2f295ffa | https://github.com/Lakonik/EPro-PnP/tree/931df847190ce10eddd1dc3e3168ce1a2f295ffa | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_features, out_features, groups, bias=True):
super().__init__()
self.in_features = in_features
self.out_features = out_features
self.groups = groups
self.weight = nn.Par... |
GammaScaleMap | # 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.autograd
class GammaScaleMap(nn.Module):
"""
Compute Gamma Scale on a 4D tensor (The hard way). This acts as a standard PyTorch layer.
Gamma Scale is computed independantly for each batch item at each location x,y
Input should ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn as nn
import torch.autograd
assert_size_stride... | LLNL/fastcam | GammaScaleMap | false | 8,434 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
Compute Gamma Scale on a 4D tensor (The hard way). This acts as a standard PyTorch layer.
Gamma Scale is computed independantly for each batch item at each location x,y
Input should be:
... |
L2Norm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from math import sqrt as sqrt
from itertools import product as product
import torch.nn as nn
import torch.nn.init as init
class L2Norm(nn.Module):
def __init__(self, n_channels, scale):
super(L2Norm, self).__init__()
self.n_channels = n_channels
self.gamma = scale or None
... | 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 math import sqrt as sqrt
from itertools import product as product
import t... | Kalana304/realtime-action-detection | L2Norm | false | 8,435 | [
"MIT"
] | 26 | a40178c749d60c135290c40a8ac658bac253f0d4 | https://github.com/Kalana304/realtime-action-detection/tree/a40178c749d60c135290c40a8ac658bac253f0d4 | import torch
from math import sqrt as sqrt
from itertools import product as product
import torch.nn as nn
import torch.nn.init as init
class Model(nn.Module):
def __init__(self, n_channels, scale):
super().__init__()
self.n_channels = n_channels
self.gamma = scale or None
self.eps... |
AdaptiveInstanceNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from math import sqrt
def equal_lr(module, name='weight'):
EqualLR.apply(module, name)
return module
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, module):
weight = getattr(module, self.name + '_orig')
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | KwonGihyun/DiagonalGAN | AdaptiveInstanceNorm | false | 8,437 | [
"MIT"
] | 13 | 9e401c00e741d700f85df2c715ee11c1e66e1d1c | https://github.com/KwonGihyun/DiagonalGAN/tree/9e401c00e741d700f85df2c715ee11c1e66e1d1c | import torch
import torch.nn as nn
from math import sqrt
def equal_lr(module, name='weight'):
EqualLR.apply(module, name)
return module
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, module):
weight = getattr(module, self.name + '_orig')
... |
AdaptiveAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt
def equal_lr(module, name='weight'):
EqualLR.apply(module, name)
return module
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, module):
weight = getattr(modul... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from math import sqrt
assert_size_stride = torch._C._dynam... | KwonGihyun/DiagonalGAN | AdaptiveAttention | false | 8,438 | [
"MIT"
] | 13 | 9e401c00e741d700f85df2c715ee11c1e66e1d1c | https://github.com/KwonGihyun/DiagonalGAN/tree/9e401c00e741d700f85df2c715ee11c1e66e1d1c | import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt
def equal_lr(module, name='weight'):
EqualLR.apply(module, name)
return module
class EqualLR:
def __init__(self, name):
self.name = name
def compute_weight(self, module):
weight = getattr(modul... |
ConvTemporalGraphical | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConvTemporalGraphical(nn.Module):
"""The basic module for applying a graph convolution.
Args:
in_channels (int): Number of channels in the input sequence data
out_channels (int): Number of channels produced by the convolution
kernel_size (int):... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Levigty/AimCLR | ConvTemporalGraphical | false | 8,439 | [
"MIT"
] | 25 | 6cd73767f17748792508647355fa324fa63e235d | https://github.com/Levigty/AimCLR/tree/6cd73767f17748792508647355fa324fa63e235d | import torch
import torch.nn as nn
class Model(nn.Module):
"""The basic module for applying a graph convolution.
Args:
in_channels (int): Number of channels in the input sequence data
out_channels (int): Number of channels produced by the convolution
kernel_size (int): Size of the gra... |
DropBlockT_1d | # 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 DropBlockT_1d(nn.Module):
def __init__(self, keep_prob=0.9):
super(DropBlockT_1d, self).__init__()
self.keep_prob = keep_prob
def forward(self, input, mask):
n, c, t, v = input.size()
input1 = input.permute(0, 1, 3, 2).contiguous().vie... | 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... | Levigty/AimCLR | DropBlockT_1d | false | 8,440 | [
"MIT"
] | 25 | 6cd73767f17748792508647355fa324fa63e235d | https://github.com/Levigty/AimCLR/tree/6cd73767f17748792508647355fa324fa63e235d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, keep_prob=0.9):
super().__init__()
self.keep_prob = keep_prob
def forward(self, input, mask):
n, c, t, v = input.size()
input1 = input.permute(0, 1, 3, 2).contiguous().view(n, c * v, t)
mask... |
GaussNorm2D | # 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.autograd
class GaussNorm2D(nn.Module):
"""
This will normalize a saliency map to range from 0 to 1 via normal cumulative distribution function.
Input and output will be a 3D tensor of size [batch size x height x width].
In... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.autograd
assert_size_stride = torch._C._dyna... | LLNL/fastcam | GaussNorm2D | false | 8,441 | [
"BSD-3-Clause"
] | 25 | 99cefe37528014247319468cf05f54fef259d3bf | https://github.com/LLNL/fastcam/tree/99cefe37528014247319468cf05f54fef259d3bf | import torch
import torch.nn as nn
import torch.autograd
class Model(nn.Module):
"""
This will normalize a saliency map to range from 0 to 1 via normal cumulative distribution function.
Input and output will be a 3D tensor of size [batch size x height x width].
Input ca... |
FirstNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FirstNet(nn.Module):
def __init__(self):
super(FirstNet, self).__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=
3, padding=1, stride=1)
self.conv2 = nn.Conv2d(64, 128, 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_... | Koukyosyumei/AIJack | FirstNet | false | 8,442 | [
"MIT"
] | 24 | 9545d3828907b54965ede85e0e12cb32eef54294 | https://github.com/Koukyosyumei/AIJack/tree/9545d3828907b54965ede85e0e12cb32eef54294 | 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(in_channels=1, out_channels=64, kernel_size=
3, padding=1, stride=1)
self.conv2 = nn.Conv2d(64, 128, 3, padding=1)
def ... |
FusedDownsample | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt
class FusedDownsample(nn.Module):
def __init__(self, in_channel, out_channel, kernel_size, padding=0):
super().__init__()
weight = torch.randn(out_channel, in_channel, kernel_size, kernel_size)
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
import torch.nn as nn
from math import sqrt
assert_size_stride = torch._C._dynam... | KwonGihyun/DiagonalGAN | FusedDownsample | false | 8,443 | [
"MIT"
] | 13 | 9e401c00e741d700f85df2c715ee11c1e66e1d1c | https://github.com/KwonGihyun/DiagonalGAN/tree/9e401c00e741d700f85df2c715ee11c1e66e1d1c | import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt
class Model(nn.Module):
def __init__(self, in_channel, out_channel, kernel_size, padding=0):
super().__init__()
weight = torch.randn(out_channel, in_channel, kernel_size, kernel_size)
bias = torch.zer... |
AttentionCrossEntropy | # 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 AttentionCrossEntropy(nn.Module):
def __init__(self):
super(AttentionCrossEntropy, self).__init__()
def forward(self, input, target):
cross_loss = torch.mul(target.float(), F.log_softmax(input, dim=1))
loss = 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 import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | LindgeW/sentiment-analysis-based-on-attention | AttentionCrossEntropy | false | 8,444 | [
"Apache-2.0"
] | 13 | 82ea37c8ef84eec56082d60001b1179b4c12f416 | https://github.com/LindgeW/sentiment-analysis-based-on-attention/tree/82ea37c8ef84eec56082d60001b1179b4c12f416 | 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, input, target):
cross_loss = torch.mul(target.float(), F.log_softmax(input, dim=1))
loss = torch.neg(torch.mean(cross_loss))
ret... |
CausalConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super(CausalConv1d, self).__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channels, kernel_size,
padding=... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | LittleGuoKe/Entity-Concept-enhanced-Few-shot-Relation-Extraction | CausalConv1d | false | 8,445 | [
"MIT"
] | 19 | b41386bdc70a3b84731bdbf700ff1ba4eda6675d | https://github.com/LittleGuoKe/Entity-Concept-enhanced-Few-shot-Relation-Extraction/tree/b41386bdc70a3b84731bdbf700ff1ba4eda6675d | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super().__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channels, kernel_size,
padding=self.padding, dilation=di... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from torch.nn import functional as F
from numpy import inf
from math import inf
def Linear(in_features, out_features, bias=True):
m = nn.Linear(in_features, out_features, bias)
nn.init.xavier_uniform_(m.weight)
if bias:
nn.init.constant_(m.bias, 0.0)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
from torch import nn
from torch.nn import functional as F
from numpy... | L-Zhe/FasySeq | MultiHeadAttention | false | 8,446 | [
"Apache-2.0"
] | 34 | 2cd2abd290666b1e118d8ad11c973b58ca4f0573 | https://github.com/L-Zhe/FasySeq/tree/2cd2abd290666b1e118d8ad11c973b58ca4f0573 | import math
import torch
from torch import nn
from torch.nn import functional as F
from numpy import inf
from math import inf
def Linear(in_features, out_features, bias=True):
m = nn.Linear(in_features, out_features, bias)
nn.init.xavier_uniform_(m.weight)
if bias:
nn.init.constant_(m.bias, 0.0)
... |
DenseBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super(CausalConv1d, self).__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | LittleGuoKe/Entity-Concept-enhanced-Few-shot-Relation-Extraction | DenseBlock | false | 8,447 | [
"MIT"
] | 19 | b41386bdc70a3b84731bdbf700ff1ba4eda6675d | https://github.com/LittleGuoKe/Entity-Concept-enhanced-Few-shot-Relation-Extraction/tree/b41386bdc70a3b84731bdbf700ff1ba4eda6675d | import torch
from torch import nn
from torch.nn import functional as F
class CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=2, dilation=2):
super().__init__()
self.padding = dilation
self.causal_conv = nn.Conv1d(in_channels, out_channels, kernel_size,
... |
NoiseInjection | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 NoiseInjection(nn.Module):
def __init__(self, channel):
super().__init__()
self.weight = nn.Parameter(torch.zeros(1, channel, 1, 1))
def forward(self, image, noise):
return image + self.weight * noise
def get_inputs():
return [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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | KwonGihyun/DiagonalGAN | NoiseInjection | false | 8,448 | [
"MIT"
] | 13 | 9e401c00e741d700f85df2c715ee11c1e66e1d1c | https://github.com/KwonGihyun/DiagonalGAN/tree/9e401c00e741d700f85df2c715ee11c1e66e1d1c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, channel):
super().__init__()
self.weight = nn.Parameter(torch.zeros(1, channel, 1, 1))
def forward(self, image, noise):
return image + self.weight * noise
def get_inputs():
return [torch.rand([4, 4, 4... |
SymmetricPad2d | # 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 SymmetricPad2d(nn.Module):
"""symmetric 0-pad to splited tensors and concat"""
def __init__(self, pad=1):
super(SymmetricPad2d, self).__init__()
self.padding1 = nn.ZeroPad2d((pad, 0, pad, 0))
self.padding2 = nn.ZeroPad2d((pad, 0, 0, pad))
... | 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... | Lee-Gihun/Micronet_GSJ | SymmetricPad2d | false | 8,449 | [
"MIT"
] | 12 | 72289bb66507b6c3b4d14f2e5916dec718a1b198 | https://github.com/Lee-Gihun/Micronet_GSJ/tree/72289bb66507b6c3b4d14f2e5916dec718a1b198 | import torch
import torch.nn as nn
class Model(nn.Module):
"""symmetric 0-pad to splited tensors and concat"""
def __init__(self, pad=1):
super().__init__()
self.padding1 = nn.ZeroPad2d((pad, 0, pad, 0))
self.padding2 = nn.ZeroPad2d((pad, 0, 0, pad))
self.padding3 = nn.ZeroPad... |
FusedUpsample | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt
class FusedUpsample(nn.Module):
def __init__(self, in_channel, out_channel, kernel_size, padding=0):
super().__init__()
weight = torch.randn(in_channel, out_channel, kernel_size, kernel_size)
bias = t... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from math import sqrt
assert_size_stride = torch._C._dynam... | KwonGihyun/DiagonalGAN | FusedUpsample | false | 8,450 | [
"MIT"
] | 13 | 9e401c00e741d700f85df2c715ee11c1e66e1d1c | https://github.com/KwonGihyun/DiagonalGAN/tree/9e401c00e741d700f85df2c715ee11c1e66e1d1c | import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt
class Model(nn.Module):
def __init__(self, in_channel, out_channel, kernel_size, padding=0):
super().__init__()
weight = torch.randn(in_channel, out_channel, kernel_size, kernel_size)
bias = torch.zer... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.