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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
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... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class Conv1D(nn.Module):
def __init__(self, nf, nx):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
import ... | adi0229/gpt-2-flask-api | MLP | false | 14,741 | [
"MIT"
] | 47 | 274d836ede9400566777893cea8662e61bbd5d8c | https://github.com/adi0229/gpt-2-flask-api/tree/274d836ede9400566777893cea8662e61bbd5d8c | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
def gelu(x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 *
torch.pow(x, 3))))
class Conv1D(nn.Module):
def __init__(self, nf, nx):
... |
PositionwiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PositionwiseFeedForward(nn.Module):
"""
Implements FFN equation (1-D convolution).
"""
def __init__(self, n_hid, dropout=0.1):
super(PositionwiseFeedForward, self).__init__()
self.w_1 = nn.Linear(n_hid, n_hid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | acbull/HiCE | PositionwiseFeedForward | false | 14,742 | [
"MIT"
] | 58 | 0a7e3035bc6e1e2ea5d08b0f1fb68656f75df62f | https://github.com/acbull/HiCE/tree/0a7e3035bc6e1e2ea5d08b0f1fb68656f75df62f | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Implements FFN equation (1-D convolution).
"""
def __init__(self, n_hid, dropout=0.1):
super().__init__()
self.w_1 = nn.Linear(n_hid, n_hid * 2)
self.w_2 = nn.Linear(n_hid * 2, n... |
PositionalAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PositionalAttention(nn.Module):
"""
A simple positional attention layer that assigns different weights for word in different relative position.
"""
def __init__(self, n_seq):
super(PositionalAttention, self).__init__()
self.pos_att = nn.Par... | 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... | acbull/HiCE | PositionalAttention | false | 14,743 | [
"MIT"
] | 58 | 0a7e3035bc6e1e2ea5d08b0f1fb68656f75df62f | https://github.com/acbull/HiCE/tree/0a7e3035bc6e1e2ea5d08b0f1fb68656f75df62f | import torch
import torch.nn as nn
class Model(nn.Module):
"""
A simple positional attention layer that assigns different weights for word in different relative position.
"""
def __init__(self, n_seq):
super().__init__()
self.pos_att = nn.Parameter(torch.ones(n_seq))
def forw... |
AttentionMatrix | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AttentionMatrix(nn.Module):
"""
Attention Matrix (unnormalized)
"""
def __init__(self, hidden_size):
"""
Create a module for attention matrices. The input is a pair of
matrices, the output is a matrix containing similarity scores between... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | abhinonymous/MSMARCO-Question-Answering | AttentionMatrix | false | 14,744 | [
"MIT"
] | 127 | bfdd802d20b63322adca23f1da1f6a5931593920 | https://github.com/abhinonymous/MSMARCO-Question-Answering/tree/bfdd802d20b63322adca23f1da1f6a5931593920 | import torch
from torch import nn
class Model(nn.Module):
"""
Attention Matrix (unnormalized)
"""
def __init__(self, hidden_size):
"""
Create a module for attention matrices. The input is a pair of
matrices, the output is a matrix containing similarity scores between
p... |
KLLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
from torch import nn
class KLLoss(nn.Module):
"""Loss that uses a 'hinge' on the lower bound.
This means that for samples with a label value smaller than the threshold, the loss is zero if the prediction is
also smaller than that threshold.
args:
er... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | abhisheklalwani/ActionCLIP | KLLoss | false | 14,745 | [
"MIT"
] | 141 | dd2ab27db4bf3d5be3a51cd011cb49aa8b679de0 | https://github.com/abhisheklalwani/ActionCLIP/tree/dd2ab27db4bf3d5be3a51cd011cb49aa8b679de0 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""Loss that uses a 'hinge' on the lower bound.
This means that for samples with a label value smaller than the threshold, the loss is zero if the prediction is
also smaller than that threshold.
args:
err... |
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
from torch import nn
class Highway(nn.Module):
"""
Individual highway layer
"""
def __init__(self, input_dim, activation_class=nn.ReLU):
"""
Create a highway layer. The input is a tensor of features, the output
is a tensor with the same dimension.
With in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | abhinonymous/MSMARCO-Question-Answering | Highway | false | 14,746 | [
"MIT"
] | 127 | bfdd802d20b63322adca23f1da1f6a5931593920 | https://github.com/abhinonymous/MSMARCO-Question-Answering/tree/bfdd802d20b63322adca23f1da1f6a5931593920 | import torch
from torch import nn
class Model(nn.Module):
"""
Individual highway layer
"""
def __init__(self, input_dim, activation_class=nn.ReLU):
"""
Create a highway layer. The input is a tensor of features, the output
is a tensor with the same dimension.
With inpu... |
PatchEmbedding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def pair(t):
"""
Parameters
----------
t: tuple[int] or int
"""
return t if isinstance(t, tuple) else (t, t)
class PatchEmbedding(nn.Module):
"""
Parameters
----------
img_size: int
Image Size
patch_size: int
Patch 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.triton_helpers import libdevice
import torch.nn as ... | aditya-agrawal-30502/vformer | PatchEmbedding | false | 14,747 | [
"MIT"
] | 90 | e1f4950f980238442ff1dc39a8f0791e4fbc9dac | https://github.com/aditya-agrawal-30502/vformer/tree/e1f4950f980238442ff1dc39a8f0791e4fbc9dac | import torch
import torch.nn as nn
def pair(t):
"""
Parameters
----------
t: tuple[int] or int
"""
return t if isinstance(t, tuple) else (t, t)
class Model(nn.Module):
"""
Parameters
----------
img_size: int
Image Size
patch_size: int
Patch Size
in_ch... |
BahdanauAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import torch.optim
import torch.utils.data
import torch.utils.collect_env
import torch.nn.parallel
import torch.utils.data.distributed
class BahdanauAttention(nn.Module):
"""
Bahdanau Attent... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aditbro/GNMTResearch | BahdanauAttention | false | 14,748 | [
"MIT"
] | 67 | 85cc739704b4647d98fac9f09fab6a3dcb92fe13 | https://github.com/aditbro/GNMTResearch/tree/85cc739704b4647d98fac9f09fab6a3dcb92fe13 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import torch.optim
import torch.utils.data
import torch.utils.collect_env
import torch.nn.parallel
import torch.utils.data.distributed
class Model(nn.Module):
"""
Bahdanau Attention (https:/... |
BertPooler | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class BertPooler(nn.Module):
def __init__(self, config, recurs=None):
super(BertPooler, self).__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
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 ... | aeloyq/EasyTransfer | BertPooler | false | 14,749 | [
"Apache-2.0"
] | 806 | f02b1f40109c4031632f3c51bce1cf3d1e906e34 | https://github.com/aeloyq/EasyTransfer/tree/f02b1f40109c4031632f3c51bce1cf3d1e906e34 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config, recurs=None):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
self.config = config
... |
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_... | abhi1kumar/AP-loss | ClassificationModel | false | 14,750 | [
"MIT"
] | 158 | 87f51b212761ef233422dbaaf799444fb453a10e | https://github.com/abhi1kumar/AP-loss/tree/87f51b212761ef233422dbaaf799444fb453a10e | 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... |
US | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn as nn
from torch.nn import functional as F
from torch.nn import init as init
from torch.utils import data as data
import torch.onnx
class US(nn.Module):
"""Up-sampling block
"""
def __init__(self, num_feat, scale):
super(US, self).__init__()
self.scale = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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 as nn
from torch.nn import init as init
from torch.utils im... | aesrgan/A-ESRGAN | US | false | 14,751 | [
"BSD-3-Clause"
] | 58 | e1a71deb4a47e332cad6b3d6bbbbb21a56bdd9c6 | https://github.com/aesrgan/A-ESRGAN/tree/e1a71deb4a47e332cad6b3d6bbbbb21a56bdd9c6 | import torch
from torch import nn as nn
from torch.nn import functional as F
from torch.nn import init as init
from torch.utils import data as data
import torch.onnx
class Model(nn.Module):
"""Up-sampling block
"""
def __init__(self, num_feat, scale):
super().__init__()
self.scale = scale... |
CrossAttentionBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.hub
class CrossAttention(nn.Module):
def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None,
attn_drop=0.0, proj_drop=0.0):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
self.scale = qk... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | abhrac/CrossViT | CrossAttentionBlock | false | 14,752 | [
"Apache-2.0"
] | 93 | 97a1414ec182c09609ebe141ff6acc350cc352e5 | https://github.com/abhrac/CrossViT/tree/97a1414ec182c09609ebe141ff6acc350cc352e5 | import torch
import torch.nn as nn
import torch.hub
class CrossAttention(nn.Module):
def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None,
attn_drop=0.0, proj_drop=0.0):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
self.scale = qk... |
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
class BaseModule(torch.nn.Module):
def __init__(self):
super(BaseModule, self).__init__()
@property
def nparams(self):
return sum(p.numel() for p in self.parameters() if p.requires_grad)
class Highway(BaseModule):
"""
Implementation as described
in https://arxi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | aflorithmic/DurIAN | Highway | false | 14,753 | [
"BSD-3-Clause"
] | 158 | a708e9c5bb89895ddf08ca1a13bc8fd683b1e23f | https://github.com/aflorithmic/DurIAN/tree/a708e9c5bb89895ddf08ca1a13bc8fd683b1e23f | import torch
class BaseModule(torch.nn.Module):
def __init__(self):
super().__init__()
@property
def nparams(self):
return sum(p.numel() for p in self.parameters() if p.requires_grad)
class Model(BaseModule):
"""
Implementation as described
in https://arxiv.org/pdf/1505.003... |
RPA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn as nn
from torch.nn import init as init
from torch.utils import data as data
import torch.onnx
class RPA(nn.Module):
"""Residual pixel-attention block
"""
def __init__(self, num_feat):
super(RPA, self).__init__()
self.conv1 = nn.Conv2d(num_feat, num_feat ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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 as nn
from torch.nn import init as init
from torch.utils im... | aesrgan/A-ESRGAN | RPA | false | 14,754 | [
"BSD-3-Clause"
] | 58 | e1a71deb4a47e332cad6b3d6bbbbb21a56bdd9c6 | https://github.com/aesrgan/A-ESRGAN/tree/e1a71deb4a47e332cad6b3d6bbbbb21a56bdd9c6 | import torch
from torch import nn as nn
from torch.nn import init as init
from torch.utils import data as data
import torch.onnx
class Model(nn.Module):
"""Residual pixel-attention block
"""
def __init__(self, num_feat):
super().__init__()
self.conv1 = nn.Conv2d(num_feat, num_feat * 2, 1)... |
BertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
class BertSelfAttention(nn.Module):
def __init__(self, config):
super(BertSelfAttention, self).__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aeloyq/EasyTransfer | BertSelfAttention | false | 14,755 | [
"Apache-2.0"
] | 806 | f02b1f40109c4031632f3c51bce1cf3d1e906e34 | https://github.com/aeloyq/EasyTransfer/tree/f02b1f40109c4031632f3c51bce1cf3d1e906e34 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
'The hidden size (%d) is not a... |
CRF_S | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.init
class CRF_S(nn.Module):
"""Conditional Random Field (CRF) layer. This version is used in Lample et al. 2016, has less parameters than CRF_L.
args:
hidden_dim: input dim size
tagset_size: target_set_size
if_biase: whether allow bi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.init
assert_size_stride = torch._C._dynamo... | ahmadshabbir2468/LM-LSTM-CRF | CRF_S | false | 14,756 | [
"Apache-2.0"
] | 877 | 99f157590b9efdcecff03d3cdd3a4500cd715ece | https://github.com/ahmadshabbir2468/LM-LSTM-CRF/tree/99f157590b9efdcecff03d3cdd3a4500cd715ece | import torch
import torch.nn as nn
import torch.nn.init
class Model(nn.Module):
"""Conditional Random Field (CRF) layer. This version is used in Lample et al. 2016, has less parameters than CRF_L.
args:
hidden_dim: input dim size
tagset_size: target_set_size
if_biase: whether allow bi... |
HeatmapLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.parallel
import torch.optim
import torch.utils.data.distributed
import torch.multiprocessing
class HeatmapLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, gt, mask):
assert pred.size() =... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
import torch.nn.parallel
import torch.optim
import torch.utils.data.distributed
import torch.m... | ahmedelmahy/HRNet-Bottom-Up-Pose-Estimation | HeatmapLoss | false | 14,757 | [
"MIT"
] | 129 | cf5831249999f0b307d5aa948ebdcdef981ba68f | https://github.com/ahmedelmahy/HRNet-Bottom-Up-Pose-Estimation/tree/cf5831249999f0b307d5aa948ebdcdef981ba68f | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.parallel
import torch.optim
import torch.utils.data.distributed
import torch.multiprocessing
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, gt, mask):
assert pred.size() == gt.s... |
BCEDiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class BCEDiceLoss(nn.Module):
def __init__(self, weight=None, size_average=True):
super().__init__()
def forward(self, input, target):
pred = input.view(-1)
truth = target.view(-1)
bce_loss = nn.BCELoss()(pred, truth).double()
dice_co... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | afperezm/road_building_extraction | BCEDiceLoss | false | 14,758 | [
"MIT"
] | 76 | e07458fcb36318ec93fc23feb764136cf0a0bffe | https://github.com/afperezm/road_building_extraction/tree/e07458fcb36318ec93fc23feb764136cf0a0bffe | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, weight=None, size_average=True):
super().__init__()
def forward(self, input, target):
pred = input.view(-1)
truth = target.view(-1)
bce_loss = nn.BCELoss()(pred, truth).double()
dice_coef = (... |
ShakeResNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.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
import math
from torch import... | aierh/autoML | ShakeResNet | false | 14,759 | [
"MIT"
] | 185 | 8e31966edf6de2c223d5eeb6cd4b4dbd6ddbbf77 | https://github.com/aierh/autoML/tree/8e31966edf6de2c223d5eeb6cd4b4dbd6ddbbf77 | import math
import torch
from torch import nn
from numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.si... |
ResidualAttentionBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 collections import OrderedDict
from torch import nn
class LayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super(LayerNorm, self).__init__()
self.weight = nn.Pa... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | abhisheklalwani/ActionCLIP | ResidualAttentionBlock | false | 14,760 | [
"MIT"
] | 141 | dd2ab27db4bf3d5be3a51cd011cb49aa8b679de0 | https://github.com/abhisheklalwani/ActionCLIP/tree/dd2ab27db4bf3d5be3a51cd011cb49aa8b679de0 | import torch
from collections import OrderedDict
from torch import nn
class LayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super().__init__()
self.weight = nn.Parameter(torch.o... |
ShakeResNeXt | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.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
import math
from torch import... | aierh/autoML | ShakeResNeXt | false | 14,761 | [
"MIT"
] | 185 | 8e31966edf6de2c223d5eeb6cd4b4dbd6ddbbf77 | https://github.com/aierh/autoML/tree/8e31966edf6de2c223d5eeb6cd4b4dbd6ddbbf77 | import math
import torch
from torch import nn
from numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.si... |
PositionalEncoder | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class PositionalEncoder(nn.Module):
def __init__(self, d_model):
super().__init__()
self.d_model = d_model
def forward(self, xyz):
xyz1 = xyz.unsqueeze(1)
xyz2 = xyz.unsqueeze(0)
pairwise_dist = xyz1 - xyz2
return pairwise_dis... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | aim-uofa/DyCo3D | PositionalEncoder | false | 14,762 | [
"BSD-2-Clause"
] | 100 | 17d22c2d839c0a1043fb72df301e3935af5ca0e9 | https://github.com/aim-uofa/DyCo3D/tree/17d22c2d839c0a1043fb72df301e3935af5ca0e9 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, d_model):
super().__init__()
self.d_model = d_model
def forward(self, xyz):
xyz1 = xyz.unsqueeze(1)
xyz2 = xyz.unsqueeze(0)
pairwise_dist = xyz1 - xyz2
return pairwise_dist
def get_... |
Sparsemax | # 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.multiprocessing
import torch.nn as nn
class Sparsemax(nn.Module):
"""Sparsemax function."""
def __init__(self, dim=None):
"""Initialize sparsemax activation
Args:
dim (int, optional): The dimension over which to apply the sparsemax function.
... | import torch
from torch import device
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.multiprocessing
import torch.nn as nn
assert_size_s... | ai4ce/DiscoNet | Sparsemax | false | 14,763 | [
"MIT"
] | 80 | 44b57faac3c5be289d33cbbab12b300e3ac767b0 | https://github.com/ai4ce/DiscoNet/tree/44b57faac3c5be289d33cbbab12b300e3ac767b0 | import torch
import torch.multiprocessing
import torch.nn as nn
class Model(nn.Module):
"""Sparsemax function."""
def __init__(self, dim=None):
"""Initialize sparsemax activation
Args:
dim (int, optional): The dimension over which to apply the sparsemax function.
... |
PreNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.utils.data
class PreNet(nn.Module):
def __init__(self, in_dims, fc1_dims=256, fc2_dims=128, dropout=0.5):
super().__init__()
self.fc1 = nn.Linear(in_dims, fc1_dims)
self.fc2 = nn.Linear(fc1_dims, fc2_dims)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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
import t... | airobotnews/cloneVoice | PreNet | false | 14,764 | [
"MIT"
] | 15,983 | 8ad9ba2b60aef57d6d7c83832f07c4f1173d493b | https://github.com/airobotnews/cloneVoice/tree/8ad9ba2b60aef57d6d7c83832f07c4f1173d493b | import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_dims, fc1_dims=256, fc2_dims=128, dropout=0.5):
super().__init__()
self.fc1 = nn.Linear(in_dims, fc1_dims)
self.fc2 = nn.Linear(fc1_dims, fc2_dims)
... |
BboxHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 itertools import product as product
class BboxHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super(BboxHead, self).__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 4, kernel_size=(
1, 1), stride=1, padding=0)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from itertools import product as product
assert_size_strid... | ai18435136351/facenet-retinaface-pytorch | BboxHead | false | 14,765 | [
"MIT"
] | 48 | f228969e46d7402170b708798a210de552879d16 | https://github.com/ai18435136351/facenet-retinaface-pytorch/tree/f228969e46d7402170b708798a210de552879d16 | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super().__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 4, kernel_size=(
1, 1), stride=1, padding=0)
def forward(se... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class SelfAttention(nn.Module):
"""SelfAttention class"""
def __init__(self, input_dim: 'int', da: 'int', r: 'int') ->None:
"""Instantiating SelfAttention class
Args:
input_dim (int): dimension of input, eg) (batc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aisolab/nlp_implementation | SelfAttention | false | 14,766 | [
"MIT"
] | 181 | 21ea6e3f5737e7074bdd8dd190e5f5172f86f6bf | https://github.com/aisolab/nlp_implementation/tree/21ea6e3f5737e7074bdd8dd190e5f5172f86f6bf | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""SelfAttention class"""
def __init__(self, input_dim: 'int', da: 'int', r: 'int') ->None:
"""Instantiating SelfAttention class
Args:
input_dim (int): dimension of input, eg) (batch_size, ... |
ShuffleCatChunk | # 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 ShuffleCatChunk(nn.Module):
def forward(self, a, b):
assert a.size() == b.size()
_n, c, _h, _w = a.size()
a = torch.chunk(a, chunks=c, dim=1)
b = torch.chunk(b, chunks=c, dim=1)
x = [None] * (c * 2)
x[::2] = a
x[1::2... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | akaneko1019/yolact_edge | ShuffleCatChunk | false | 14,767 | [
"MIT"
] | 1,036 | a9a00281b33b3ac90253a4939773308a8f95e21d | https://github.com/akaneko1019/yolact_edge/tree/a9a00281b33b3ac90253a4939773308a8f95e21d | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, a, b):
assert a.size() == b.size()
_n, c, _h, _w = a.size()
a = torch.chunk(a, chunks=c, dim=1)
b = torch.chunk(b, chunks=c, dim=1)
x = [None] * (c * 2)
x[::2] = a
x[1::2] = b
... |
ShuffleCatAlt | # 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 ShuffleCatAlt(nn.Module):
def forward(self, a, b):
assert a.size() == b.size()
n, c, h, w = a.size()
x = torch.zeros(n, c * 2, h, w, dtype=a.dtype, device=a.device)
x[:, ::2] = a
x[:, 1::2] = b
return x
def get_inputs():
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | akaneko1019/yolact_edge | ShuffleCatAlt | false | 14,768 | [
"MIT"
] | 1,036 | a9a00281b33b3ac90253a4939773308a8f95e21d | https://github.com/akaneko1019/yolact_edge/tree/a9a00281b33b3ac90253a4939773308a8f95e21d | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, a, b):
assert a.size() == b.size()
n, c, h, w = a.size()
x = torch.zeros(n, c * 2, h, w, dtype=a.dtype, device=a.device)
x[:, ::2] = a
x[:, 1::2] = b
return x
def get_inputs():
retur... |
ShuffleCat | # 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 ShuffleCat(nn.Module):
def forward(self, a, b):
assert a.size() == b.size()
n, c, h, w = a.size()
a = a.permute(0, 2, 3, 1).contiguous().view(-1, c)
b = b.permute(0, 2, 3, 1).contiguous().view(-1, c)
x = torch.cat((a, b), dim=0).tra... | 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... | akaneko1019/yolact_edge | ShuffleCat | false | 14,769 | [
"MIT"
] | 1,036 | a9a00281b33b3ac90253a4939773308a8f95e21d | https://github.com/akaneko1019/yolact_edge/tree/a9a00281b33b3ac90253a4939773308a8f95e21d | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, a, b):
assert a.size() == b.size()
n, c, h, w = a.size()
a = a.permute(0, 2, 3, 1).contiguous().view(-1, c)
b = b.permute(0, 2, 3, 1).contiguous().view(-1, c)
x = torch.cat((a, b), dim=0).transpos... |
ClassHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 itertools import product as product
class ClassHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super(ClassHead, self).__init__()
self.num_anchors = num_anchors
self.conv1x1 = nn.Conv2d(inchannels, self.num_anchors * 2,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from itertools import product as product
assert_size_strid... | ai18435136351/facenet-retinaface-pytorch | ClassHead | false | 14,770 | [
"MIT"
] | 48 | f228969e46d7402170b708798a210de552879d16 | https://github.com/ai18435136351/facenet-retinaface-pytorch/tree/f228969e46d7402170b708798a210de552879d16 | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super().__init__()
self.num_anchors = num_anchors
self.conv1x1 = nn.Conv2d(inchannels, self.num_anchors * 2,
kernel_size=(1, 1... |
ConvNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConvNet(nn.Module):
def __init__(self):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=
5, padding=2)
self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size
=3... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | agriyakhetarpal/dffml | ConvNet | false | 14,771 | [
"MIT"
] | 171 | f76f2ce94c3972634053377b00e7c16530f7f0a4 | https://github.com/agriyakhetarpal/dffml/tree/f76f2ce94c3972634053377b00e7c16530f7f0a4 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=
5, padding=2)
self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size
=3, padding=1)
... |
MSELoss | # 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.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.onnx
def _reduce(x, reduction='elementwise_mean'):
if reduction == 'none':
return x
elif reduction == 'elementwise_mea... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data... | akshayka/gavel | MSELoss | false | 14,772 | [
"MIT"
] | 67 | 40a22a725f2e70478483e98c9b07c6fc588e0c40 | https://github.com/akshayka/gavel/tree/40a22a725f2e70478483e98c9b07c6fc588e0c40 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.onnx
def _reduce(x, reduction='elementwise_mean'):
if reduction == 'none':
return x
elif reduction == 'elementwise_mea... |
MaxOut | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class MaxOut(nn.Module):
def __init__(self, input_size: 'int', hidden_size: 'int') ->None:
super(MaxOut, self).__init__()
self._ops_1 = nn.Linear(input_size, hidden_size)
self._ops_2 = nn.Linear(input_size, hidden_size)
def forward(self, x: 'torch.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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | aisolab/nlp_implementation | MaxOut | false | 14,773 | [
"MIT"
] | 181 | 21ea6e3f5737e7074bdd8dd190e5f5172f86f6bf | https://github.com/aisolab/nlp_implementation/tree/21ea6e3f5737e7074bdd8dd190e5f5172f86f6bf | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size: 'int', hidden_size: 'int') ->None:
super().__init__()
self._ops_1 = nn.Linear(input_size, hidden_size)
self._ops_2 = nn.Linear(input_size, hidden_size)
def forward(self, x: 'torch.Tensor') ->tor... |
EncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from torch.nn import functional as F
def attention(q, k, v, d_k, mask=None, dropout=None):
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
mask = mask.unsqueeze(1)
scores = scores.masked_fill(mask == 0, -10000000... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aim-uofa/DyCo3D | EncoderLayer | false | 14,774 | [
"BSD-2-Clause"
] | 100 | 17d22c2d839c0a1043fb72df301e3935af5ca0e9 | https://github.com/aim-uofa/DyCo3D/tree/17d22c2d839c0a1043fb72df301e3935af5ca0e9 | import math
import torch
from torch import nn
from torch.nn import functional as F
def attention(q, k, v, d_k, mask=None, dropout=None):
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
mask = mask.unsqueeze(1)
scores = scores.masked_fill(mask == 0, -10000000... |
FCN8s | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
def get_upsampling_weight(in_channels, out_channels, kernel_size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (kernel_size + 1) // 2
if kernel_size % 2 == 1:
center = factor - 1
else:
center = factor - 0.5
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import numpy as np
import tor... | MatthewKleinsmith/portrait-seg | FCN8s | false | 14,775 | [
"MIT"
] | 50 | 0dcdd5952c6d10aa103c4997556559173d922687 | https://github.com/MatthewKleinsmith/portrait-seg/tree/0dcdd5952c6d10aa103c4997556559173d922687 | import torch
import numpy as np
import torch.nn as nn
def get_upsampling_weight(in_channels, out_channels, kernel_size):
"""Make a 2D bilinear kernel suitable for upsampling"""
factor = (kernel_size + 1) // 2
if kernel_size % 2 == 1:
center = factor - 1
else:
center = factor - 0.5
... |
DecoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from torch.nn import functional as F
def attention(q, k, v, d_k, mask=None, dropout=None):
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
mask = mask.unsqueeze(1)
scores = scores.masked_fill(mask == 0, -10000000... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aim-uofa/DyCo3D | DecoderLayer | false | 14,776 | [
"BSD-2-Clause"
] | 100 | 17d22c2d839c0a1043fb72df301e3935af5ca0e9 | https://github.com/aim-uofa/DyCo3D/tree/17d22c2d839c0a1043fb72df301e3935af5ca0e9 | import math
import torch
from torch import nn
from torch.nn import functional as F
def attention(q, k, v, d_k, mask=None, dropout=None):
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
mask = mask.unsqueeze(1)
scores = scores.masked_fill(mask == 0, -10000000... |
FeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FeedForward(nn.Module):
def __init__(self, d_model, d_ff=64, dropout=0.1):
super().__init__()
self.linear_1 = nn.Linear(d_model, d_ff)
self.dropout = nn.Dropout(dropout)
self.linear_2 = nn.Linear(d_ff, d_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | aim-uofa/DyCo3D | FeedForward | false | 14,777 | [
"BSD-2-Clause"
] | 100 | 17d22c2d839c0a1043fb72df301e3935af5ca0e9 | https://github.com/aim-uofa/DyCo3D/tree/17d22c2d839c0a1043fb72df301e3935af5ca0e9 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, d_model, d_ff=64, dropout=0.1):
super().__init__()
self.linear_1 = nn.Linear(d_model, d_ff)
self.dropout = nn.Dropout(dropout)
self.linear_2 = nn.Linear(d_ff, d_model)... |
down_right_shifted_conv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm as wn
def right_shift(x, pad=None):
xs = [int(y) for y in x.size()]
x = x[:, :, :, :xs[3] - 1]
pad = nn.ZeroPad2d((1, 0, 0, 0)) if pad is None else pad
return pad(x)
class down_right_shifted_conv2d(nn.Module):
def __init_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | ajayjain/lmconv | down_right_shifted_conv2d | false | 14,778 | [
"MIT"
] | 69 | e00576de5118702c90493e88c6e459b0e45d1290 | https://github.com/ajayjain/lmconv/tree/e00576de5118702c90493e88c6e459b0e45d1290 | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm as wn
def right_shift(x, pad=None):
xs = [int(y) for y in x.size()]
x = x[:, :, :, :xs[3] - 1]
pad = nn.ZeroPad2d((1, 0, 0, 0)) if pad is None else pad
return pad(x)
class Model(nn.Module):
def __init__(self, num_filters_... |
GELU | # 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 GELU(nn.Module):
def __init__(self):
super(GELU, self).__init__()
def forward(self, x):
return F.relu(x, inplace=True)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@... | akulaarora/pre-training | GELU | false | 14,779 | [
"Apache-2.0"
] | 107 | 312ae1ec1ec279da557543184fc064dade76dbbd | https://github.com/akulaarora/pre-training/tree/312ae1ec1ec279da557543184fc064dade76dbbd | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return F.relu(x, inplace=True)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
BCEWithLogitsLoss | # 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 as th
import torch.nn as nn
class BCEWithLogitsLoss(nn.Module):
def __init__(self, weight=None):
super().__init__()
self.loss = th.nn.BCEWithLogitsLoss(weight=weight)
def forward(self, x, target):
return self.loss(x, target)
def get_inputs():
return [t... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | albanie/collaborative-experts | BCEWithLogitsLoss | false | 14,780 | [
"Apache-2.0"
] | 237 | b41defc4fb8de451809014c970ccbe518621909f | https://github.com/albanie/collaborative-experts/tree/b41defc4fb8de451809014c970ccbe518621909f | import torch
import torch as th
import torch.nn as nn
class Model(nn.Module):
def __init__(self, weight=None):
super().__init__()
self.loss = th.nn.BCEWithLogitsLoss(weight=weight)
def forward(self, x, target):
return self.loss(x, target)
def get_inputs():
return [torch.rand([4... |
ConcatReLU | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
def concat_relu(x):
"""Concatenated ReLU (http://arxiv.org/abs/1603.05201)."""
return F.relu(torch.cat([x, -x], dim=1))
class ConcatReLU(nn.Module):
"""Concatenated ReLU (http://arxiv.org/abs/1603.05201)."""
def forward(self, input)... | 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.functional as F
assert_size_stride = torch._C._dyna... | alisiahkoohi/survae_flows | ConcatReLU | false | 14,781 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import torch
import torch.nn as nn
import torch.nn.functional as F
def concat_relu(x):
"""Concatenated ReLU (http://arxiv.org/abs/1603.05201)."""
return F.relu(torch.cat([x, -x], dim=1))
class Model(nn.Module):
"""Concatenated ReLU (http://arxiv.org/abs/1603.05201)."""
def forward(self, input):
... |
down_shifted_conv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm as wn
def down_shift(x, pad=None):
xs = [int(y) for y in x.size()]
x = x[:, :, :xs[2] - 1, :]
pad = nn.ZeroPad2d((0, 0, 1, 0)) if pad is None else pad
return pad(x)
class down_shifted_conv2d(nn.Module):
def __init__(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 ... | ajayjain/lmconv | down_shifted_conv2d | false | 14,782 | [
"MIT"
] | 69 | e00576de5118702c90493e88c6e459b0e45d1290 | https://github.com/ajayjain/lmconv/tree/e00576de5118702c90493e88c6e459b0e45d1290 | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm as wn
def down_shift(x, pad=None):
xs = [int(y) for y in x.size()]
x = x[:, :, :xs[2] - 1, :]
pad = nn.ZeroPad2d((0, 0, 1, 0)) if pad is None else pad
return pad(x)
class Model(nn.Module):
def __init__(self, num_filters_i... |
ConcatELU | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
def concat_elu(x):
"""Like concatenated ReLU (http://arxiv.org/abs/1603.05201), but with ELU instead."""
return F.elu(torch.cat([x, -x], dim=1))
class ConcatELU(nn.Module):
"""Like concatenated ReLU (http://arxiv.org/abs/1603.05201), but... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn.functional as F
assert_size_stride = torc... | alisiahkoohi/survae_flows | ConcatELU | false | 14,783 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import torch
import torch.nn as nn
import torch.nn.functional as F
def concat_elu(x):
"""Like concatenated ReLU (http://arxiv.org/abs/1603.05201), but with ELU instead."""
return F.elu(torch.cat([x, -x], dim=1))
class Model(nn.Module):
"""Like concatenated ReLU (http://arxiv.org/abs/1603.05201), but wit... |
LandmarkHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 itertools import product as product
class LandmarkHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super(LandmarkHead, self).__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=
(1, 1), stride=1, padd... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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 itertools import product as product
assert_size_strid... | ai18435136351/facenet-retinaface-pytorch | LandmarkHead | false | 14,784 | [
"MIT"
] | 48 | f228969e46d7402170b708798a210de552879d16 | https://github.com/ai18435136351/facenet-retinaface-pytorch/tree/f228969e46d7402170b708798a210de552879d16 | import torch
import torch.nn as nn
from itertools import product as product
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=2):
super().__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=
(1, 1), stride=1, padding=0)
def forward(s... |
AutoregressiveShift | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AutoregressiveShift(nn.Module):
"""Shifts input right to make model autoregressive."""
def __init__(self, embed_dim):
super(AutoregressiveShift, self).__init__()
self.embed_dim = embed_dim
self.first_token = nn.Parameter(torch.Tensor(1, 1, embe... | 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... | alisiahkoohi/survae_flows | AutoregressiveShift | false | 14,785 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import torch
import torch.nn as nn
class Model(nn.Module):
"""Shifts input right to make model autoregressive."""
def __init__(self, embed_dim):
super().__init__()
self.embed_dim = embed_dim
self.first_token = nn.Parameter(torch.Tensor(1, 1, embed_dim))
self._reset_parameters(... |
EPELoss | # 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 EPELoss(nn.Module):
def __init__(self):
super(EPELoss, self).__init__()
def forward(self, output, target):
lossvalue = torch.norm(output - target + 1e-16, p=2, dim=1).mean()
return lossvalue
def get_inputs():
return [torch.rand([4, 4, 4,... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | aishmittal/DocProj | EPELoss | false | 14,786 | [
"MIT"
] | 246 | 761e27927ab7a83f48e347921dc023d45a9d394f | https://github.com/aishmittal/DocProj/tree/761e27927ab7a83f48e347921dc023d45a9d394f | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, target):
lossvalue = torch.norm(output - target + 1e-16, p=2, dim=1).mean()
return lossvalue
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.ran... |
RewardCriterion | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.autograd import *
import torch.nn
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
else:
return tensor.contiguous()
class RewardCriterion(nn.Module):
def __init__(self):
super(RewardCriterion, self).__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.autograd import *
import torch.nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_str... | aliabd/cos-cvae | RewardCriterion | false | 14,787 | [
"Apache-2.0"
] | 53 | d6f94dd0f1de6727e43da55d36a6433fbfd0c44b | https://github.com/aliabd/cos-cvae/tree/d6f94dd0f1de6727e43da55d36a6433fbfd0c44b | import torch
import torch.nn as nn
from torch.autograd import *
import torch.nn
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
else:
return tensor.contiguous()
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, seq, ... |
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
from torch.autograd import *
import torch.nn.parallel
import torch.utils.data
class FC(nn.Module):
def __init__(self, in_size, out_size, dropout_r=0.0, use_relu=True):
super(FC, self).__init__()
self.dropout_r = dropout_r
self.use_relu = use_relu
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | alfred100p/VC-R-CNN | MLP | false | 14,788 | [
"MIT"
] | 344 | c887f5b6db6932fb5c828c8037e299ce5baadb9e | https://github.com/alfred100p/VC-R-CNN/tree/c887f5b6db6932fb5c828c8037e299ce5baadb9e | import torch
import torch.nn as nn
from torch.autograd import *
import torch.nn.parallel
import torch.utils.data
class FC(nn.Module):
def __init__(self, in_size, out_size, dropout_r=0.0, use_relu=True):
super().__init__()
self.dropout_r = dropout_r
self.use_relu = use_relu
self.li... |
Linear_dynamics | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
from torch import nn
class Linear_dynamics(nn.Module):
def __init__(self, device='cpu'):
super(Linear_dynamics, self).__init__()
self.time = nn.Parameter(torch.ones(1) * 0.7)
self.device = device
self
def forward(self, x, v):
retur... | 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.utils.data
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._... | alanpaivaa/egnn | Linear_dynamics | false | 14,789 | [
"MIT"
] | 142 | e9ca6c0c3e1d30a7598efbd66034121b4af8dccc | https://github.com/alanpaivaa/egnn/tree/e9ca6c0c3e1d30a7598efbd66034121b4af8dccc | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
def __init__(self, device='cpu'):
super().__init__()
self.time = nn.Parameter(torch.ones(1) * 0.7)
self.device = device
self
def forward(self, x, v):
return x + v * self.time
def get_i... |
PositionalEncoding1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PositionalEncoding1d(nn.Module):
"""
Learning positional embeddings.
Args:
shape: Iterable, the shape of the input.
embedding_dim: int, the size of each embedding vector.
"""
def __init__(self, size, embedding_dim):
sup... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guar... | alisiahkoohi/survae_flows | PositionalEncoding1d | false | 14,790 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""
Learning positional embeddings.
Args:
shape: Iterable, the shape of the input.
embedding_dim: int, the size of each embedding vector.
"""
def __init__(self, size, embedding_dim):
super().__init__()... |
SilogLoss | # 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 SilogLoss(nn.Module):
def __init__(self, ratio=10, ratio2=0.85):
super().__init__()
self.ratio = ratio
self.ratio2 = ratio2
def forward(self, pred, gt):
log_diff = torch.log(pred * self.ratio) - torch.log(gt * self.ratio)
silog... | 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... | aliyun/dro-sfm | SilogLoss | false | 14,791 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, ratio=10, ratio2=0.85):
super().__init__()
self.ratio = ratio
self.ratio2 = ratio2
def forward(self, pred, gt):
log_diff = torch.log(pred * self.ratio) - torch.log(gt * self.ratio)
silog1 = ... |
PositionalEncodingImage | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PositionalEncodingImage(nn.Module):
"""
Learning positional embeddings for images.
Embeddings for channel, height and width are added to form the full positional embedding.
These encodings correspond to the ones from Sparse Transformers (https://arx... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guar... | alisiahkoohi/survae_flows | PositionalEncodingImage | false | 14,792 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""
Learning positional embeddings for images.
Embeddings for channel, height and width are added to form the full positional embedding.
These encodings correspond to the ones from Sparse Transformers (https://arxiv.org/abs/1904.10... |
DumbFeat | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.optim
class DumbFeat(nn.Module):
def __init__(self, dropout):
super().__init__()
if dropout > 0.0:
self.dropout = torch.nn.Dropout(p=dropout, inplace=False)
else:
self.dropout = None
def forward(self, x):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dyna... | alisure-fork/BF3S | DumbFeat | false | 14,793 | [
"Apache-2.0"
] | 130 | 99cfb7ce4696f2585bb7c2502f234e60c55e8007 | https://github.com/alisure-fork/BF3S/tree/99cfb7ce4696f2585bb7c2502f234e60c55e8007 | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
def __init__(self, dropout):
super().__init__()
if dropout > 0.0:
self.dropout = torch.nn.Dropout(p=dropout, inplace=False)
else:
self.dropout = None
def forward(self, x):
if... |
BerHuLoss | # 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 BerHuLoss(nn.Module):
"""Class implementing the BerHu loss."""
def __init__(self, threshold=0.2):
"""
Initializes the BerHuLoss class.
Parameters
----------
threshold : float
Mask parameter
"""
super... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | aliyun/dro-sfm | BerHuLoss | false | 14,794 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Class implementing the BerHu loss."""
def __init__(self, threshold=0.2):
"""
Initializes the BerHuLoss class.
Parameters
----------
threshold : float
Mask parameter
"""
super()._... |
MultinomialNLLLoss | # 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.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.onnx
def _reduce(x, reduction='elementwise_mean'):
if reduction == 'none':
return x
elif reduction == 'elementwise_mea... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | akshayka/gavel | MultinomialNLLLoss | false | 14,795 | [
"MIT"
] | 67 | 40a22a725f2e70478483e98c9b07c6fc588e0c40 | https://github.com/akshayka/gavel/tree/40a22a725f2e70478483e98c9b07c6fc588e0c40 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.onnx
def _reduce(x, reduction='elementwise_mean'):
if reduction == 'none':
return x
elif reduction == 'elementwise_mea... |
GatedTanhUnit | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def gated_tanh(x, dim):
"""Gated Tanh activation."""
x_tanh, x_sigmoid = torch.chunk(x, 2, dim=dim)
return torch.tanh(x_tanh) * torch.sigmoid(x_sigmoid)
class GatedTanhUnit(nn.Module):
"""Gated Tanh activation."""
def __init__(self, dim=-1):
super(Gate... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | alisiahkoohi/survae_flows | GatedTanhUnit | false | 14,796 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import torch
import torch.nn as nn
def gated_tanh(x, dim):
"""Gated Tanh activation."""
x_tanh, x_sigmoid = torch.chunk(x, 2, dim=dim)
return torch.tanh(x_tanh) * torch.sigmoid(x_sigmoid)
class Model(nn.Module):
"""Gated Tanh activation."""
def __init__(self, dim=-1):
super().__init__()... |
GatedConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GatedConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, padding):
super(GatedConv2d, self).__init__()
self.in_channels = in_channels
self.conv = nn.Conv2d(in_channels, out_channels * 3, kernel_size=
kernel_siz... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | alisiahkoohi/survae_flows | GatedConv2d | false | 14,797 | [
"MIT"
] | 262 | e1747b05524c7ab540a211ed360ab3e67bc3e96d | https://github.com/alisiahkoohi/survae_flows/tree/e1747b05524c7ab540a211ed360ab3e67bc3e96d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, padding):
super().__init__()
self.in_channels = in_channels
self.conv = nn.Conv2d(in_channels, out_channels * 3, kernel_size=
kernel_size, padding=padding)
... |
Alignment | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
from torch.nn import Module
import math
import torch
import torch.nn.functional as f
import torch.nn as nn
class Module(nn.Module):
def __init__(self):
super().__init__()
self.summary = {}
def add_summary(self, name, val):
if self.trainin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | alibaba-edu/simple-effective-text-matching-pytorch | Alignment | false | 14,798 | [
"Apache-2.0"
] | 278 | 05d572e30801b235e989c78c95dd24d5f5d35f74 | https://github.com/alibaba-edu/simple-effective-text-matching-pytorch/tree/05d572e30801b235e989c78c95dd24d5f5d35f74 | from _paritybench_helpers import _mock_config
from torch.nn import Module
import math
import torch
import torch.nn.functional as f
import torch.nn as nn
class Module(nn.Module):
def __init__(self):
super().__init__()
self.summary = {}
def add_summary(self, name, val):
if self.trainin... |
MegatronGelu | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class MegatronGelu(torch.nn.Module):
def forward(self, x):
return x * 0.5 * (torch.erf(x / 1.41421) + 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
import torch.nn
import torch.onnx
import torch.utils.checkpoint
assert_size_str... | almiliMSFT/onnxruntime | MegatronGelu | false | 14,799 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.nn.Module):
def forward(self, x):
return x * 0.5 * (torch.erf(x / 1.41421) + 1.0)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
MegatronFastGelu | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class MegatronFastGelu(torch.nn.Module):
def forward(self, x):
return 0.5 * x * (1.0 + torch.tanh(0.7978845608028654 * x * (1.0 +
0.044715 * x * x)))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def g... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn
import torch.onnx
import torch.utils.checkpoint
assert_size_str... | almiliMSFT/onnxruntime | MegatronFastGelu | false | 14,800 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.nn.Module):
def forward(self, x):
return 0.5 * x * (1.0 + torch.tanh(0.7978845608028654 * x * (1.0 +
0.044715 * x * x)))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inp... |
MyCustomFunctionReluModel | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class MyCustomFunctionReluModel(torch.nn.Module):
def __init__(self):
super().__init__()
class MyReLU(torch.autograd.Function):
@staticmethod
def forward(ctx, input):
ctx.save_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
import torch.onnx
import torch.utils.checkpoint
assert_size_stride = torc... | almiliMSFT/onnxruntime | MyCustomFunctionReluModel | false | 14,801 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
class MyReLU(torch.autograd.Function):
@staticmethod
def forward(ctx, input):
ctx.save_for_backward(input)
... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class LayerNorm(nn.Module):
def __init__(self, hidden_size, epsilon, cast_fp16=True, formula=0):
super().__init__()
self.layer_norm = nn.LayerNorm(hidden_size, eps=epsilon)
self.layer_norm.b... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn
import torch.onnx
import torch.utils.chec... | almiliMSFT/onnxruntime | LayerNorm | false | 14,802 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn as nn
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(nn.Module):
def __init__(self, hidden_size, epsilon, cast_fp16=True, formula=0):
super().__init__()
self.layer_norm = nn.LayerNorm(hidden_size, eps=epsilon)
self.layer_norm.bias.... |
DepthHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DepthHead(nn.Module):
def __init__(self, input_dim=256, hidden_dim=128, scale=False):
super(DepthHead, self).__init__()
self.scale = scale
self.conv1 = nn.Conv2d(input_dim, hidden_dim, 3, padding=1)
self.conv... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aliyun/dro-sfm | DepthHead | false | 14,803 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_dim=256, hidden_dim=128, scale=False):
super().__init__()
self.scale = scale
self.conv1 = nn.Conv2d(input_dim, hidden_dim, 3, padding=1)
self.conv2 = nn.Conv2d(hidde... |
FeatBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FeatBlock(nn.Module):
def __init__(self, planes=128, out_dim=128):
super().__init__()
self.conv1 = nn.Conv2d(planes, planes, 3, padding=1)
self.conv2 = nn.Conv2d(planes, out_dim, 3, padding=1)
self.relu = nn.ReLU(inplace=True)
def forw... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | aliyun/dro-sfm | FeatBlock | false | 14,804 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, planes=128, out_dim=128):
super().__init__()
self.conv1 = nn.Conv2d(planes, planes, 3, padding=1)
self.conv2 = nn.Conv2d(planes, out_dim, 3, padding=1)
self.relu = nn.ReLU(inplace=True)
def forward(... |
ProjectionInputDepth | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ProjectionInputDepth(nn.Module):
def __init__(self, cost_dim, hidden_dim, out_chs):
super().__init__()
self.out_chs = out_chs
self.convc1 = nn.Conv2d(cost_dim, hidden_dim, 1, padding=0)
self.convc2 = nn.Conv2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | aliyun/dro-sfm | ProjectionInputDepth | false | 14,805 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, cost_dim, hidden_dim, out_chs):
super().__init__()
self.out_chs = out_chs
self.convc1 = nn.Conv2d(cost_dim, hidden_dim, 1, padding=0)
self.convc2 = nn.Conv2d(hidden_dim, h... |
NeuralNetNonDifferentiableOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class NeuralNetNonDifferentiableOutput(torch.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNetNonDifferentiableOutput, self).__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_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
import torch.nn
import torch.... | almiliMSFT/onnxruntime | NeuralNetNonDifferentiableOutput | false | 14,806 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super().__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size)
self.relu = torch.nn.ReLU()
self.fc2 = torch.... |
NeuralNetPartialNoGradModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class NeuralNetPartialNoGradModel(torch.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNetPartialNoGradModel, self).__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size).requir... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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
import torch.... | almiliMSFT/onnxruntime | NeuralNetPartialNoGradModel | false | 14,807 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super().__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size).requires_grad_(
False)
self.relu = torch.... |
PixelSort | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class PixelSort(nn.Module):
"""The inverse operation of PixelShuffle
Reduces the spatial resolution, increasing the number of channels.
Currently, scale 0.5 is supported only.
Later, torch.nn.functional.pixel_sort may be implemented.
Reference:
http://pyto... | 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... | alpayuz/DeepDeblur-PyTorch | PixelSort | false | 14,808 | [
"MIT"
] | 158 | 771252e123e3a11da849bb9cef2a7cc49d8d1a2d | https://github.com/alpayuz/DeepDeblur-PyTorch/tree/771252e123e3a11da849bb9cef2a7cc49d8d1a2d | import torch
from torch import nn
class Model(nn.Module):
"""The inverse operation of PixelShuffle
Reduces the spatial resolution, increasing the number of channels.
Currently, scale 0.5 is supported only.
Later, torch.nn.functional.pixel_sort may be implemented.
Reference:
http://pytorch.... |
BertPooler | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class BertPooler(nn.Module):
def __init__(self, config):
super(BertPooler, self).__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
def forward(self, hi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | Aksh97/VGCN-BERT | BertPooler | false | 14,809 | [
"MIT"
] | 106 | 62b5ae5a3c53f4bff555027d87a57d3a994a32bb | https://github.com/Aksh97/VGCN-BERT/tree/62b5ae5a3c53f4bff555027d87a57d3a994a32bb | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
def forward(self, hidden_states):
... |
enhance_net_nopool | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class CSDN_Tem(nn.Module):
def __init__(self, in_ch, out_ch):
super(CSDN_Tem, self).__init__()
self.depth_conv = nn.Conv2d(in_channels=in_ch, out_channels=in_ch,
kernel_size=3, stride=1, padding=1, g... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | alisonwqq/Zero-DCE_extension | enhance_net_nopool | false | 14,810 | [
"MIT"
] | 97 | 6b59b36cbe2983e216789583d837bdc88d3e5cf8 | https://github.com/alisonwqq/Zero-DCE_extension/tree/6b59b36cbe2983e216789583d837bdc88d3e5cf8 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class CSDN_Tem(nn.Module):
def __init__(self, in_ch, out_ch):
super().__init__()
self.depth_conv = nn.Conv2d(in_channels=in_ch, out_channels=in_ch,
kernel_size=3, stride=1, padding=1, groups=in_ch)
... |
NeuralNetMultiplePositionalArguments | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class NeuralNetMultiplePositionalArguments(torch.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNetMultiplePositionalArguments, self).__init__()
self.fc1 = torch.nn.Linear(input_size, h... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn
import torch.... | almiliMSFT/onnxruntime | NeuralNetMultiplePositionalArguments | false | 14,811 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super().__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size)
self.relu = torch.nn.ReLU()
self.fc2 = torch.... |
TransformerEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
import torch.nn.functional as F
from torch.nn import Linear
from torch.nn import Dropout
from torch.nn import LayerNorm
from torch.nn import Identity
def drop_path(x, drop_prob: 'float'=0.0, training: 'bool'=Fals... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | alihassanijr/Compact-Transformers | TransformerEncoderLayer | false | 14,812 | [
"Apache-2.0"
] | 281 | 61b656eacdf113f92900f800410bb788bb7d9a3c | https://github.com/alihassanijr/Compact-Transformers/tree/61b656eacdf113f92900f800410bb788bb7d9a3c | from torch.nn import Module
import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
import torch.nn.functional as F
from torch.nn import Linear
from torch.nn import Dropout
from torch.nn import LayerNorm
from torch.nn import Identity
def drop_path(x, drop_prob: 'float'=0.0, training: 'bool'=Fals... |
TV_L1LOSS | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class TV_L1LOSS(nn.Module):
def __init__(self):
super(TV_L1LOSS, self).__init__()
def forward(self, x, y):
size = x.size()
h_tv_diff = torch.abs(x[:, :, 1:, :] - x[:, :, :-1, :] - (y[:, :, 1
:, :] - y[:, :, :-1, :... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch.... | alsgkals2/SRResCGAN | TV_L1LOSS | false | 14,813 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
size = x.size()
h_tv_diff = torch.abs(x[:, :, 1:, :] - x[:, :, :-1, :] - (y[:, :, 1
:, :] - y[:, :, :-1, :])).sum()
w... |
L1GradLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class L1GradLoss(nn.Module):
def __init__(self, grad=False):
super(L1GradLoss, self).__init__()
self.grad = grad
def forward(self, input, target):
err = input - target
loss = err.norm(p=1).div(err.numel())
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._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | alsgkals2/SRResCGAN | L1GradLoss | false | 14,814 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, grad=False):
super().__init__()
self.grad = grad
def forward(self, input, target):
err = input - target
loss = err.norm(p=1).div(err.numel())
if self.grad:
... |
NeuralNetMultiplePositionalArgumentsMultiOutputsWithoutDependency | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class NeuralNetMultiplePositionalArgumentsMultiOutputsWithoutDependency(torch
.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNetMultiplePositionalArgumentsMultiOutputsWithoutDependency
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | almiliMSFT/onnxruntime | NeuralNetMultiplePositionalArgumentsMultiOutputsWithoutDependency | false | 14,815 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch
.nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super().__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size)
self.fc2 = torch.nn.Linear(input_size, hidden_si... |
MSEGradLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class MSEGradLoss(nn.Module):
def __init__(self, grad=False):
super(MSEGradLoss, self).__init__()
self.grad = grad
def forward(self, input, target):
err = input - target
loss = err.norm(p=2).pow(2).div(err.numel())
... | 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... | alsgkals2/SRResCGAN | MSEGradLoss | false | 14,816 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, grad=False):
super().__init__()
self.grad = grad
def forward(self, input, target):
err = input - target
loss = err.norm(p=2).pow(2).div(err.numel())
if self.grad:
... |
PoseHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PoseHead(nn.Module):
def __init__(self, input_dim=256, hidden_dim=128):
super(PoseHead, self).__init__()
self.conv1_pose = nn.Conv2d(input_dim, hidden_dim, 3, padding=1)
self.conv2_pose = nn.Conv2d(hidden_dim, 6, 3, padding=1)
self.relu = n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | aliyun/dro-sfm | PoseHead | false | 14,817 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim=256, hidden_dim=128):
super().__init__()
self.conv1_pose = nn.Conv2d(input_dim, hidden_dim, 3, padding=1)
self.conv2_pose = nn.Conv2d(hidden_dim, 6, 3, padding=1)
self.relu = nn.ReLU(inplace=Tr... |
ProjectionInputPose | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ProjectionInputPose(nn.Module):
def __init__(self, cost_dim, hidden_dim, out_chs):
super().__init__()
self.out_chs = out_chs
self.convc1 = nn.Conv2d(cost_dim, hidden_dim, 1, padding=0)
self.convc2 = nn.Conv2d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | aliyun/dro-sfm | ProjectionInputPose | false | 14,818 | [
"MIT"
] | 147 | 8707e2e0ef799d7d47418a018060f503ef449fe3 | https://github.com/aliyun/dro-sfm/tree/8707e2e0ef799d7d47418a018060f503ef449fe3 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, cost_dim, hidden_dim, out_chs):
super().__init__()
self.out_chs = out_chs
self.convc1 = nn.Conv2d(cost_dim, hidden_dim, 1, padding=0)
self.convc2 = nn.Conv2d(hidden_dim, h... |
ResNetV2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 collections import OrderedDict
import torch.nn as nn
import torch.nn.functional as F
def conv1x1(cin, cout, stride=1, bias=False):
return StdConv2d(cin, cout, kernel_size=1, stride=stride, padding=0,
bias=bias)
def conv3x3(cin, cout, stride=1, groups=1, bias=False):
return StdConv2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Willy0919/progressive-coordinate-transforms | ResNetV2 | false | 14,819 | [
"Apache-2.0",
"MIT"
] | 142 | b637fa2541a815d270e162a4c9cd3348b098d48a | https://github.com/Willy0919/progressive-coordinate-transforms/tree/b637fa2541a815d270e162a4c9cd3348b098d48a | import torch
from collections import OrderedDict
import torch.nn as nn
import torch.nn.functional as F
def conv1x1(cin, cout, stride=1, bias=False):
return StdConv2d(cin, cout, kernel_size=1, stride=stride, padding=0,
bias=bias)
def conv3x3(cin, cout, stride=1, groups=1, bias=False):
return StdConv2... |
NeuralNetMultiplePositionalArgumentsMultiOutputsWithDependency | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class NeuralNetMultiplePositionalArgumentsMultiOutputsWithDependency(torch.
nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNetMultiplePositionalArgumentsMultiOutputsWithDependency,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | almiliMSFT/onnxruntime | NeuralNetMultiplePositionalArgumentsMultiOutputsWithDependency | false | 14,820 | [
"MIT"
] | 6,036 | c002dc86a364852859ca9642698fcfc5edf22c9d | https://github.com/almiliMSFT/onnxruntime/tree/c002dc86a364852859ca9642698fcfc5edf22c9d | import torch
import torch.nn
import torch.onnx
import torch.utils.checkpoint
class Model(torch.
nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super().__init__()
self.fc1 = torch.nn.Linear(input_size, hidden_size)
self.softmax = torch.nn.Softmax(dim=1)
s... |
TV_L1Loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class TV_L1Loss(nn.Module):
def __init__(self, tv_loss_weight=1):
super(TV_L1Loss, self).__init__()
def forward(self, x):
batch_size = x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
count_h = self.tensor_size... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch.... | alsgkals2/SRResCGAN | TV_L1Loss | false | 14,821 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, tv_loss_weight=1):
super().__init__()
def forward(self, x):
batch_size = x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
count_h = self.tensor_size(x[:, :, 1:, :])
... |
GraphLearner | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class GraphLearner(Module):
def __init__(self, in_feature_dim, combined_feature_dim, K, dropout=0.0):
super(GraphLearner, self).__init__()
"""
## Varia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | aimbrain/vqa-project | GraphLearner | false | 14,822 | [
"Apache-2.0"
] | 145 | 341122a267293017b55db4f033fbe81445af03ea | https://github.com/aimbrain/vqa-project/tree/341122a267293017b55db4f033fbe81445af03ea | from torch.nn import Module
import torch
from torch.nn.modules.module import Module
import torch.nn as nn
import torch.nn.functional as F
class Model(Module):
def __init__(self, in_feature_dim, combined_feature_dim, K, dropout=0.0):
super().__init__()
"""
## Variables:
- in_featur... |
LSTMRegressCriterion | # 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 LSTMRegressCriterion(nn.Module):
def __init__(self):
super(LSTMRegressCriterion, self).__init__()
def forward(self, pred, target, mask):
pred = pred.clone()
target = target.clone()
mask = mask.clone()
target = target[:, :pred.s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | aluo-x/shape2prog | LSTMRegressCriterion | false | 14,823 | [
"BSD-2-Clause"
] | 109 | 1177e5205b99bb293e353688b564c94a14211c75 | https://github.com/aluo-x/shape2prog/tree/1177e5205b99bb293e353688b564c94a14211c75 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, target, mask):
pred = pred.clone()
target = target.clone()
mask = mask.clone()
target = target[:, :pred.size(1), :]
mask = mask[:, :pred.s... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class ResidualBlock(nn.Module):
def __init__(self, channels):
super(ResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
self.prelu = nn.PReLU()
self.conv2 = nn.Conv2d(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
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | alsgkals2/SRResCGAN | ResidualBlock | false | 14,824 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, channels):
super().__init__()
self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
self.prelu = nn.PReLU()
self.conv2 = nn.Conv2d(channels, channels, kernel_size=3... |
TV_L2Loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class TV_L2Loss(nn.Module):
def __init__(self):
super(TV_L2Loss, self).__init__()
def forward(self, x):
batch_size = x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
count_h = self.tensor_size(x[:, :, 1:, :])
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | alsgkals2/SRResCGAN | TV_L2Loss | false | 14,825 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
batch_size = x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
count_h = self.tensor_size(x[:, :, 1:, :])
count_w = se... |
SigmoidRange | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import functools
import torch
import torch.nn as nn
from typing import *
def sigmoid_range(x, low, high):
"""Sigmoid function with range `(low, high)`"""
return torch.sigmoid(x) * (high - low) + low
class PrePostInitMeta(type):
"""A metaclass that calls optional `__pre_init__... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
import functools
import torch.nn as nn
from typing import *
assert_size_stride = torch._C._dynamo.guards.assert_... | amaarora/fastai_dev | SigmoidRange | false | 14,826 | [
"Apache-2.0"
] | 380 | ffea51a553e4a7f71bc7240730b370cd0d07cb0a | https://github.com/amaarora/fastai_dev/tree/ffea51a553e4a7f71bc7240730b370cd0d07cb0a | from torch.nn import Module
import functools
import torch
import torch.nn as nn
from typing import *
def sigmoid_range(x, low, high):
"""Sigmoid function with range `(low, high)`"""
return torch.sigmoid(x) * (high - low) + low
class PrePostInitMeta(type):
"""A metaclass that calls optional `__pre_init__... |
LSTMClassCriterion | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
else:
return tensor.contiguous()
class LSTMClassCriterion(nn.Module):
def __init__(self):
super(LSTMClassCriterion, self).__init__()
def forward(self, pred, target, mask):... | 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... | aluo-x/shape2prog | LSTMClassCriterion | false | 14,827 | [
"BSD-2-Clause"
] | 109 | 1177e5205b99bb293e353688b564c94a14211c75 | https://github.com/aluo-x/shape2prog/tree/1177e5205b99bb293e353688b564c94a14211c75 | import torch
import torch.nn as nn
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
else:
return tensor.contiguous()
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, target, mask):
pred = pred.clone()
... |
Discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Discriminator(nn.Module):
def __init__(self, num_inputs, args):
super(Discriminator, self).__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidde... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | amy12xx/lets-do-irl | Discriminator | false | 14,828 | [
"MIT"
] | 408 | fd469e9fb7426e41b07c83ce4b87962ac3543b1e | https://github.com/amy12xx/lets-do-irl/tree/fd469e9fb7426e41b07c83ce4b87962ac3543b1e | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, args):
super().__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_size)
self.fc3 = ... |
MaxMarginRankingLoss | # 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
from torch import nn
import torch.nn.functional as F
class MaxMarginRankingLoss(nn.Module):
def __init__(self, margin=1.0, negative_weighting=False, batch_size=1,
n_pair=1, hard_negative_rate=0.5):
super(MaxMarginRankingLoss, self).__init__()
self.margin = ... | 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 numpy as np
from torch import nn
assert_size_stride = torch._C._dynamo.guards.asse... | amirziai/CLIP4Clip | MaxMarginRankingLoss | false | 14,829 | [
"MIT"
] | 294 | d1f31c881ed897a513c29e62512cd56c482420e6 | https://github.com/amirziai/CLIP4Clip/tree/d1f31c881ed897a513c29e62512cd56c482420e6 | import torch
import numpy as np
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, margin=1.0, negative_weighting=False, batch_size=1,
n_pair=1, hard_negative_rate=0.5):
super().__init__()
self.margin = margin
self.n_pair = n_pair
... |
GaussianFilter | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class GaussianFilter(nn.Module):
def __init__(self, kernel_size=13, stride=1, padding=6):
super(GaussianFilter, self).__init__()
mean = (kernel_size - 1) / 2.0
variance = ((kernel_size - 1) / 6.0) ** 2.0
x_coord = torch.ar... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | alsgkals2/SRResCGAN | GaussianFilter | false | 14,830 | [
"MIT"
] | 81 | a71201a93e1819045f9c7711743812546d3a1f31 | https://github.com/alsgkals2/SRResCGAN/tree/a71201a93e1819045f9c7711743812546d3a1f31 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, kernel_size=13, stride=1, padding=6):
super().__init__()
mean = (kernel_size - 1) / 2.0
variance = ((kernel_size - 1) / 6.0) ** 2.0
x_coord = torch.arange(kernel_size)
x_g... |
VDB | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class VDB(nn.Module):
def __init__(self, num_inputs, args):
super(VDB, self).__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.z_size)
self.fc3 ... | 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.triton_helpers import libd... | amy12xx/lets-do-irl | VDB | false | 14,831 | [
"MIT"
] | 408 | fd469e9fb7426e41b07c83ce4b87962ac3543b1e | https://github.com/amy12xx/lets-do-irl/tree/fd469e9fb7426e41b07c83ce4b87962ac3543b1e | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, args):
super().__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.z_size)
self.fc3 = nn.Li... |
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... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Critic(nn.Module):
def __init__(self, num_inputs, args):
super(Critic, self).__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | amy12xx/lets-do-irl | Critic | false | 14,832 | [
"MIT"
] | 408 | fd469e9fb7426e41b07c83ce4b87962ac3543b1e | https://github.com/amy12xx/lets-do-irl/tree/fd469e9fb7426e41b07c83ce4b87962ac3543b1e | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, args):
super().__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_size)
self.fc3 = ... |
BasicBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=
stride, padding=1, bia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | amyami187/nngeometry | BasicBlock | false | 14,833 | [
"MIT"
] | 103 | cb516da3f7a019e148f48ff3ef3bed0cdae0d184 | https://github.com/amyami187/nngeometry/tree/cb516da3f7a019e148f48ff3ef3bed0cdae0d184 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1):
super().__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=
stride, padding=1, bias=False)
self... |
DeResNetBlockGroupNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def deconv3x3(in_planes, out_planes, stride=1, output_padding=0):
"""3x3 deconvolution with padding"""
return nn.ConvTranspose2d(in_planes, out_planes, kernel_size=3, stride=
stride, padding=1, output_padding=output_padding, bias=False)
class DeResNetBlockGroupNorm... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | andrecianflone/wolf | DeResNetBlockGroupNorm | false | 14,834 | [
"Apache-2.0"
] | 75 | 826bbedc58d4d29871110349356868066a3108e6 | https://github.com/andrecianflone/wolf/tree/826bbedc58d4d29871110349356868066a3108e6 | import torch
import torch.nn as nn
def deconv3x3(in_planes, out_planes, stride=1, output_padding=0):
"""3x3 deconvolution with padding"""
return nn.ConvTranspose2d(in_planes, out_planes, kernel_size=3, stride=
stride, padding=1, output_padding=output_padding, bias=False)
class Model(nn.Module):
... |
PairwiseBilinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PairwiseBilinear(nn.Module):
"""
https://github.com/stanfordnlp/stanza/blob/v1.1.1/stanza/models/common/biaffine.py#L5 # noqa
"""
def __init__(self, in1_features: 'int', in2_features: 'int',
out_features: 'int', bias: 'bool'=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
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.a... | andhikayusup/biaffineparser | PairwiseBilinear | false | 14,835 | [
"Apache-2.0"
] | 46 | 30180b805bdb6c0f1e0386ceb090ba83d6ab2621 | https://github.com/andhikayusup/biaffineparser/tree/30180b805bdb6c0f1e0386ceb090ba83d6ab2621 | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""
https://github.com/stanfordnlp/stanza/blob/v1.1.1/stanza/models/common/biaffine.py#L5 # noqa
"""
def __init__(self, in1_features: 'int', in2_features: 'int',
out_features: 'int', bias: 'bool'=True):
super().__... |
CrossEmbeddings | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class CrossEmbeddings(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings.
"""
def __init__(self, config):
super(CrossEmbeddings, self).__init__()
self.position_embeddings = 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 import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | amirziai/CLIP4Clip | CrossEmbeddings | false | 14,836 | [
"MIT"
] | 294 | d1f31c881ed897a513c29e62512cd56c482420e6 | https://github.com/amirziai/CLIP4Clip/tree/d1f31c881ed897a513c29e62512cd56c482420e6 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class Model(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings.
"""
def __init__(self, config):
super().__init__()
self.position_embeddings = nn.Embedding(config.
... |
AdaIN2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AdaIN2d(nn.Module):
def __init__(self, in_channels, in_features):
super(AdaIN2d, self).__init__()
self.norm = nn.InstanceNorm2d(in_channels, affine=False,
track_running_stats=False)
self.net = nn.Linear(in_features, 2 * in_channels)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | andrecianflone/wolf | AdaIN2d | false | 14,837 | [
"Apache-2.0"
] | 75 | 826bbedc58d4d29871110349356868066a3108e6 | https://github.com/andrecianflone/wolf/tree/826bbedc58d4d29871110349356868066a3108e6 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, in_features):
super().__init__()
self.norm = nn.InstanceNorm2d(in_channels, affine=False,
track_running_stats=False)
self.net = nn.Linear(in_features, 2 * in_channels)
self.reset... |
Biaffine | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
class PairwiseBilinear(nn.Module):
"""
https://github.com/stanfordnlp/stanza/blob/v1.1.1/stanza/models/common/biaffine.py#L5 # noqa
"""
def __init__(self, in1_features: 'int', in2_features: 'int',
out_features: 'int', bias: 'bool'=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
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.a... | andhikayusup/biaffineparser | Biaffine | false | 14,838 | [
"Apache-2.0"
] | 46 | 30180b805bdb6c0f1e0386ceb090ba83d6ab2621 | https://github.com/andhikayusup/biaffineparser/tree/30180b805bdb6c0f1e0386ceb090ba83d6ab2621 | import math
import torch
import torch.nn as nn
class PairwiseBilinear(nn.Module):
"""
https://github.com/stanfordnlp/stanza/blob/v1.1.1/stanza/models/common/biaffine.py#L5 # noqa
"""
def __init__(self, in1_features: 'int', in2_features: 'int',
out_features: 'int', bias: 'bool'=True):
... |
DeepMind | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DeepMind(nn.Module):
def __init__(self):
super(DeepMind, self).__init__()
self.conv1 = nn.Conv2d(4, 32, 8, stride=4)
self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
self.conv3 = nn.Conv2d(64, 32, 3, stride=1)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | TianhongDai/Self_Imitation_Learning | DeepMind | false | 14,839 | [
"MIT"
] | 61 | e49003582fa3d875495d84682f2a3332d4922dbc | https://github.com/TianhongDai/Self_Imitation_Learning/tree/e49003582fa3d875495d84682f2a3332d4922dbc | 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(4, 32, 8, stride=4)
self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
self.conv3 = nn.Conv2d(64, 32, 3, stride=1)
self.fc1 = n... |
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... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Actor(nn.Module):
def __init__(self, num_inputs, num_outputs, args):
super(Actor, self).__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | amy12xx/lets-do-irl | Actor | false | 14,840 | [
"MIT"
] | 408 | fd469e9fb7426e41b07c83ce4b87962ac3543b1e | https://github.com/amy12xx/lets-do-irl/tree/fd469e9fb7426e41b07c83ce4b87962ac3543b1e | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs, args):
super().__init__()
self.fc1 = nn.Linear(num_inputs, args.hidden_size)
self.fc2 = nn.Linear(args.hidden_size, args.hidden_size)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.