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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
GraphResConvolution | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 import nn
import torch.autograd
from torch.nn.modules.module import Module
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907.
"""
def __init__(self, state_dim, name='', out_state_dim=None):
sup... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn import Module
f... | sumanmichael/Palmira_pb | GraphResConvolution | false | 4,398 | [
"MIT"
] | 0 | 8ca9f370ccd9bba694317be648ce5e4f4c55d0e7 | https://github.com/sumanmichael/Palmira_pb/tree/8ca9f370ccd9bba694317be648ce5e4f4c55d0e7 | from torch.nn import Module
import torch
from torch import nn
import torch.autograd
from torch.nn.modules.module import Module
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907.
"""
def __init__(self, state_dim, name='', out_state_dim=None):
sup... |
CosineActivation | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 t2v(tau, f, weight_linear, bias_linear, weight_periodic, bias_periodic,
arg=None):
if arg:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear, arg)
else:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear)
v2 = torch.matmul(tau, weight_perio... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | sungreong/PyTimeSeries | CosineActivation | false | 4,399 | [
"MIT"
] | 0 | d5321c1226fc7fb6a45fec7009843894be417594 | https://github.com/sungreong/PyTimeSeries/tree/d5321c1226fc7fb6a45fec7009843894be417594 | import torch
import torch.nn as nn
def t2v(tau, f, weight_linear, bias_linear, weight_periodic, bias_periodic,
arg=None):
if arg:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear, arg)
else:
v1 = f(torch.matmul(tau, weight_linear) + bias_linear)
v2 = torch.matmul(tau, weight_perio... |
GlobalAvgPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class GlobalAvgPool2d(nn.Module):
def forward(self, inputs):
return inputs.mean(-1).mean(-1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | synxlin/mini-torchpack | GlobalAvgPool2d | false | 4,400 | [
"MIT"
] | 0 | 3ea5bca75992941e4346102d99e789a88417d7c1 | https://github.com/synxlin/mini-torchpack/tree/3ea5bca75992941e4346102d99e789a88417d7c1 | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, inputs):
return inputs.mean(-1).mean(-1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
CharbonnierLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn as nn
class CharbonnierLoss(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=1e-06):
super(CharbonnierLoss, self).__init__()
self.eps = eps
def forward(self, x, y):
diff = x - y
loss = torch.sum(torch.sqrt... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.data
impo... | sutkarsh/EDVR | CharbonnierLoss | false | 4,401 | [
"Apache-2.0"
] | 0 | cd9f2d46edbb00333d8ffb31aebc52cfbda4b6e3 | https://github.com/sutkarsh/EDVR/tree/cd9f2d46edbb00333d8ffb31aebc52cfbda4b6e3 | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=1e-06):
super().__init__()
self.eps = eps
def forward(self, x, y):
diff = x - y
loss = torch.sum(torch.sqrt(diff * diff + self.eps))
... |
ConvLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as f
class ConvLayer(nn.Conv3d):
def __init__(self, network_config, config, name, in_shape, groups=1):
self.name = name
self.layer_config = config
self.network_config = network_conf... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | superrrpotato/Spike-Train-Predict | ConvLayer | false | 4,402 | [
"MIT"
] | 0 | 0a924e5af11c2fc58cf9049a73fff00970a3c967 | https://github.com/superrrpotato/Spike-Train-Predict/tree/0a924e5af11c2fc58cf9049a73fff00970a3c967 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as f
class Model(nn.Conv3d):
def __init__(self, network_config, config, name, in_shape, groups=1):
self.name = name
self.layer_config = config
self.network_config = network_config
... |
Policy | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Policy(nn.Module):
def __init__(self, num_inputs, num_outputs):
super(Policy, self).__init__()
self.affine1 = nn.Linear(num_inputs, 64)
self.affine2 = nn.Linear(64, 64)
self.action_mean = nn.Linear(64, num_outputs)
self.action_mean.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
im... | SaminYeasar/pytorch-trpo | Policy | false | 4,403 | [
"MIT"
] | 0 | 653a3357cf0461c175fb741604c0cd4ad1f4b841 | https://github.com/SaminYeasar/pytorch-trpo/tree/653a3357cf0461c175fb741604c0cd4ad1f4b841 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs):
super().__init__()
self.affine1 = nn.Linear(num_inputs, 64)
self.affine2 = nn.Linear(64, 64)
self.action_mean = nn.Linear(64, num_outputs)
self.action_mean.weight.data.m... |
Gate | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Gate(nn.Module):
def __init__(self, input_size, dropout=0.2):
""" To determine the importance of passage parts and
attend to the ones relevant to the question, this Gate was added
to the input of RNNCell in both Gated Attention-based Recurre... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | tailerr/R-NET-pytorch | Gate | false | 4,404 | [
"MIT"
] | 0 | a6ed4a02b0cf68bade9e9a43a93ec290a3b6fabd | https://github.com/tailerr/R-NET-pytorch/tree/a6ed4a02b0cf68bade9e9a43a93ec290a3b6fabd | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_size, dropout=0.2):
""" To determine the importance of passage parts and
attend to the ones relevant to the question, this Gate was added
to the input of RNNCell in both Gated Attention-based Recurr... |
DAInsHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from torchvision.transforms import functional as F
from torch.nn import functional as F
class DAInsHead(nn.Module):
"""
Adds a simple Instance-level Domain Classifier head
"""
def __init__(self, in_channels):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | shreyasrajesh/DA-Object-Detection | DAInsHead | false | 4,405 | [
"MIT"
] | 0 | b1919fdf49a9f1589c48c63e0a3122852e5557ce | https://github.com/shreyasrajesh/DA-Object-Detection/tree/b1919fdf49a9f1589c48c63e0a3122852e5557ce | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
from torchvision.transforms import functional as F
from torch.nn import functional as F
class Model(nn.Module):
"""
Adds a simple Instance-level Domain Classifier head
"""
def __init__(self, in_channels):
... |
StyleResidual | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.utils.data
import torch.optim
class StyleResidual(nn.Module):
"""Styling."""
def __init__(self, d_channel: 'int', d_style: 'int', kernel_size: 'int'=1):
super().__init__()
self.rs = nn.Conv1d(in_channels=d_style, out_channels=d_channel,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.utils.data
import torch.optim
assert_size_stri... | taufique74/nemotest | StyleResidual | false | 4,406 | [
"Apache-2.0"
] | 0 | 812f201913cb9922bedc1b225dff844ffc765bf1 | https://github.com/taufique74/nemotest/tree/812f201913cb9922bedc1b225dff844ffc765bf1 | import torch
from torch import nn
import torch.utils.data
import torch.optim
class Model(nn.Module):
"""Styling."""
def __init__(self, d_channel: 'int', d_style: 'int', kernel_size: 'int'=1):
super().__init__()
self.rs = nn.Conv1d(in_channels=d_style, out_channels=d_channel,
kerne... |
TorchGloVeLoss | # 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 TorchGloVeLoss(nn.Module):
def __init__(self):
super().__init__()
self.reduction = 'sum'
def forward(self, diffs, weights):
return torch.sum(0.5 * torch.mul(weights, diffs ** 2))
def get_inputs():
return [torch.ra... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | tayfuntuna/cs224u | TorchGloVeLoss | false | 4,407 | [
"Apache-2.0"
] | 0 | 4368090c679d869f21ed2393b9ca0ef217b5c404 | https://github.com/tayfuntuna/cs224u/tree/4368090c679d869f21ed2393b9ca0ef217b5c404 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
self.reduction = 'sum'
def forward(self, diffs, weights):
return torch.sum(0.5 * torch.mul(weights, diffs ** 2))
def get_inputs():
return [torch.rand([4, 4,... |
TorchGloVeModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
from torch.nn.init import xavier_uniform_
class TorchGloVeModel(nn.Module):
def __init__(self, n_words, embed_dim):
super().__init__()
self.n_words = n_words
self.embed_dim = embed_dim
self.W = self._init_weights(self.n_wo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
from torch.nn.init import xavier_u... | tayfuntuna/cs224u | TorchGloVeModel | false | 4,408 | [
"Apache-2.0"
] | 0 | 4368090c679d869f21ed2393b9ca0ef217b5c404 | https://github.com/tayfuntuna/cs224u/tree/4368090c679d869f21ed2393b9ca0ef217b5c404 | import torch
import torch.nn as nn
import torch.utils.data
from torch.nn.init import xavier_uniform_
class Model(nn.Module):
def __init__(self, n_words, embed_dim):
super().__init__()
self.n_words = n_words
self.embed_dim = embed_dim
self.W = self._init_weights(self.n_words, self.... |
PoswiseFeedForwardNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class PoswiseFeedForwardNet(nn.Module):
def __init__(self, config):
super().__init__()
self.config = config
self.conv1 = nn.Conv1d(in_channels=self.config.d_hidn, out_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 ... | star14ms/transformer-evolution | PoswiseFeedForwardNet | false | 4,409 | [
"Apache-2.0"
] | 0 | 95b57485f59a0cee4528af62e5010002e6a3448a | https://github.com/star14ms/transformer-evolution/tree/95b57485f59a0cee4528af62e5010002e6a3448a | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.config = config
self.conv1 = nn.Conv1d(in_channels=self.config.d_hidn, out_channels
=sel... |
WL1Loss | # 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 WL1Loss(nn.Module):
def __init__(self):
super(WL1Loss, self).__init__()
def forward(self, pred, target, weight):
return torch.mean(weight * torch.abs(pred - target))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4]), 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 math as tl_math
import torch.nn as nn
... | tccoin/UM-545-Machine-Learning | WL1Loss | false | 4,410 | [
"MIT"
] | 0 | 0854d7ad7e546c009edeb4a4d3e507ce95b99cf8 | https://github.com/tccoin/UM-545-Machine-Learning/tree/0854d7ad7e546c009edeb4a4d3e507ce95b99cf8 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pred, target, weight):
return torch.mean(weight * torch.abs(pred - target))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4]), torch.rand(
... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import tanh
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.a1 = nn.Conv2d(5, 16, kernel_size=3, padding=1)
self.a2 = nn.Conv2d(16, 16, kernel_size=3, padding=1)
self.a3 = nn.C... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | srivarshan-s/Neural-Chess-2D | Net | false | 4,411 | [
"MIT"
] | 0 | 81ec7eb9b4c3c82dc7f6ba5bd4313bd6ede9994e | https://github.com/srivarshan-s/Neural-Chess-2D/tree/81ec7eb9b4c3c82dc7f6ba5bd4313bd6ede9994e | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import tanh
class Model(nn.Module):
def __init__(self):
super().__init__()
self.a1 = nn.Conv2d(5, 16, kernel_size=3, padding=1)
self.a2 = nn.Conv2d(16, 16, kernel_size=3, padding=1)
self.a3 = nn.Conv2d(1... |
PointerNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 PointerNetwork(nn.Module):
def __init__(self, input_size, model_dim, attn_size=75, dropout=0.2):
""" Pointer Network
Args:
input_size(int): size of input
Input:
- **H** of shape `(passage_legth... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | tailerr/R-NET-pytorch | PointerNetwork | false | 4,412 | [
"MIT"
] | 0 | a6ed4a02b0cf68bade9e9a43a93ec290a3b6fabd | https://github.com/tailerr/R-NET-pytorch/tree/a6ed4a02b0cf68bade9e9a43a93ec290a3b6fabd | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_size, model_dim, attn_size=75, dropout=0.2):
""" Pointer Network
Args:
input_size(int): size of input
Input:
- **H** of shape `(passage_legth, batch, ... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
def set_init(layers):
for layer in layers:
nn.init.normal_(layer.weight, mean=0.0, std=0.1)
nn.init.constant_(layer.bias, 0.0)
class Net(nn.Module):
def __init__(self, s_dim, a_dim):
super(Net, self).__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | taomo/pytorch-A3C-1 | Net | false | 4,413 | [
"MIT"
] | 0 | 8e26720c75ca8b7e987b267e5e0e652d0c5d23cf | https://github.com/taomo/pytorch-A3C-1/tree/8e26720c75ca8b7e987b267e5e0e652d0c5d23cf | import torch
import torch.nn as nn
import torch.nn.functional as F
def set_init(layers):
for layer in layers:
nn.init.normal_(layer.weight, mean=0.0, std=0.1)
nn.init.constant_(layer.bias, 0.0)
class Model(nn.Module):
def __init__(self, s_dim, a_dim):
super().__init__()
self... |
GlobalWeightedAvgPool2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GlobalWeightedAvgPool2d(nn.Module):
"""
Global Weighted Average Pooling from paper "Global Weighted Average
Pooling Bridges Pixel-level Localization and Image-level Classification"
"""
def __init__(self, features: 'int', flatten=False):
super().__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.triton_helpers import math as tl_math
from torch im... | theNero93/dfdc_deepfake_challenge | GlobalWeightedAvgPool2d | false | 4,414 | [
"MIT"
] | 0 | ef275206efc6f1b0b7984b370a14bd8db61d1ec1 | https://github.com/theNero93/dfdc_deepfake_challenge/tree/ef275206efc6f1b0b7984b370a14bd8db61d1ec1 | import torch
from torch import nn
class Model(nn.Module):
"""
Global Weighted Average Pooling from paper "Global Weighted Average
Pooling Bridges Pixel-level Localization and Image-level Classification"
"""
def __init__(self, features: 'int', flatten=False):
super().__init__()
sel... |
My_SmoothL1Loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class My_SmoothL1Loss(torch.nn.Module):
def __init__(self):
super(My_SmoothL1Loss, self).__init__()
def forward(self, x, y):
total_loss = 0
assert x.shape == y.shape
z = (x - y).float()
mse_mask = (torch.abs(z) < 0.01).float()
l1_mask = (torch.abs... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
assert_size_stride = t... | theleokul/AWR-Adaptive-Weighting-Regression | My_SmoothL1Loss | false | 4,415 | [
"MIT"
] | 0 | a6c224302bab474db8b774a2d009c9497e32f6bd | https://github.com/theleokul/AWR-Adaptive-Weighting-Regression/tree/a6c224302bab474db8b774a2d009c9497e32f6bd | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
total_loss = 0
assert x.shape == y.shape
z = (x - y).float()
mse_mask = (torch.abs(z) < 0.01).float()
l1_mask = (torch.abs(z) >= 0.01).float()
ms... |
CategoricalDQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class CategoricalDQN(nn.Module):
def __init__(self, num_inputs, num_actions, args):
super(CategoricalDQN, self).__init__()
self.num_inputs = num_inputs
self.num_actions = num_a... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | tegg89/categorical_dqn | CategoricalDQN | false | 4,416 | [
"MIT"
] | 0 | 647c24ee4734450551fc446d3225f57dadd82d48 | https://github.com/tegg89/categorical_dqn/tree/647c24ee4734450551fc446d3225f57dadd82d48 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_inputs, num_actions, args):
super().__init__()
self.num_inputs = num_inputs
self.num_actions = num_actions
self.num_atoms... |
UNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch.functional import F
import torch.nn as nn
import torch.nn.functional as F
class down(nn.Module):
"""
A class for creating neural network blocks containing layers:
Average Pooling --> Convlution + Leaky ReLU --> Convolution + Leaky ReLU
This is used in the UNet Class 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
from torch.functional import ... | samuelpietri/Super-SloMo | UNet | false | 4,417 | [
"MIT"
] | 0 | e20eaa5550c30737be42b61f8e82e731cfd17457 | https://github.com/samuelpietri/Super-SloMo/tree/e20eaa5550c30737be42b61f8e82e731cfd17457 | import torch
from torch.functional import F
import torch.nn as nn
import torch.nn.functional as F
class down(nn.Module):
"""
A class for creating neural network blocks containing layers:
Average Pooling --> Convlution + Leaky ReLU --> Convolution + Leaky ReLU
This is used in the UNet Class t... |
SelfAttention2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SelfAttention2d(nn.Module):
def __init__(self, c_in, n_head=1, dropout_rate=0.1):
super().__init__()
assert c_in % n_head == 0
self.norm = nn.GroupNorm(1, c_in)
self.n_head = n_head
self.qkv_proj = nn.Conv2d(c_in, c_in * 3, 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
from torch._inductor.runtime.... | technillogue/v-diffusion-pytorch | SelfAttention2d | false | 4,418 | [
"MIT"
] | 0 | 3aa8c7f32adbde1d1ea3a9650004ffafabe5221b | https://github.com/technillogue/v-diffusion-pytorch/tree/3aa8c7f32adbde1d1ea3a9650004ffafabe5221b | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, c_in, n_head=1, dropout_rate=0.1):
super().__init__()
assert c_in % n_head == 0
self.norm = nn.GroupNorm(1, c_in)
self.n_head = n_head
self.qkv_proj = nn.Conv2d(c_in, c_in * 3, 1)
self.out... |
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
from torch import nn as nn
from torch.utils import data as data
from torch import autograd as autograd
import torch.onnx
class BCEWithLogitsLoss(nn.Module):
def __init__(self, loss_weight=1.0, **kwargs):
super(BCEWithLogitsLoss, self).__init__()
self.bce_wlogits_loss = nn.BCEWithLogi... | 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 ... | theleokul/Real-ESRGAN | BCEWithLogitsLoss | false | 4,419 | [
"BSD-3-Clause"
] | 0 | 0afbc090d012d729e6cb3ff47a80018d53bce3f6 | https://github.com/theleokul/Real-ESRGAN/tree/0afbc090d012d729e6cb3ff47a80018d53bce3f6 | import torch
from torch import nn as nn
from torch.utils import data as data
from torch import autograd as autograd
import torch.onnx
class Model(nn.Module):
def __init__(self, loss_weight=1.0, **kwargs):
super().__init__()
self.bce_wlogits_loss = nn.BCEWithLogitsLoss(**kwargs)
self.loss_... |
Emo16 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
from torch import nn
import torch.nn.functional as F
class Emo16(nn.Module):
def __init__(self, input_size: 'int', num_channels: 'int'=40):
"""
Speech emotion recognition model proposed in:
`Trigeorgis, G., Ringeval, F., Brueckner, R., Marchi, E.,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | tfyd/myEnd2you | Emo16 | false | 4,421 | [
"BSD-3-Clause"
] | 0 | 455d5404a19dd4867cb5db4f30705041d425d2b3 | https://github.com/tfyd/myEnd2you/tree/455d5404a19dd4867cb5db4f30705041d425d2b3 | import torch
import numpy as np
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size: 'int', num_channels: 'int'=40):
"""
Speech emotion recognition model proposed in:
`Trigeorgis, G., Ringeval, F., Brueckner, R., Marchi, E.,... |
ReluWithStats | # 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 ReluWithStats(nn.Module):
def __init__(self):
super(ReluWithStats, self).__init__()
self.collect_preact = True
self.avg_preacts = []
def forward(self, preact):
if self.collect_preact:
self.av... | 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
... | thudzj/SPAT | ReluWithStats | false | 4,422 | [
"MIT"
] | 0 | 65632c157f40c05c9aee59080e26457bed5b484c | https://github.com/thudzj/SPAT/tree/65632c157f40c05c9aee59080e26457bed5b484c | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.collect_preact = True
self.avg_preacts = []
def forward(self, preact):
if self.collect_preact:
self.avg_preacts.append(preact.abs... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class LayerNorm(nn.LayerNorm):
def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True):
"""Layer Norm."""
super(LayerNorm, self).__init__(normalized_shape, eps=eps,
elementwise_affine=elementwise_affine)
def forward(self, x):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | thetobysiu/transfer-pytorch-dc-tts | LayerNorm | false | 4,423 | [
"MIT"
] | 0 | 20d0c381970a01f0e343c65aeac2f325be436a7e | https://github.com/thetobysiu/transfer-pytorch-dc-tts/tree/20d0c381970a01f0e343c65aeac2f325be436a7e | import torch
import torch.nn as nn
class Model(nn.LayerNorm):
def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True):
"""Layer Norm."""
super().__init__(normalized_shape, eps=eps,
elementwise_affine=elementwise_affine)
def forward(self, x):
x = x.permute... |
FFNNClassifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 import FloatTensor
from torch.nn import Linear
from torch.nn.functional import tanh
from torch.nn.functional import log_softmax
from torch.autograd import Variable
class FFNNClassifier(Module):
def __init__(self, n_inputs, n_hidden, n_outputs):
super(FF... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | theofpa/ci-torcs | FFNNClassifier | false | 4,424 | [
"MIT"
] | 0 | fcd1e9822301f1ad8f633468ed6276059afa94b9 | https://github.com/theofpa/ci-torcs/tree/fcd1e9822301f1ad8f633468ed6276059afa94b9 | from torch.nn import Module
import torch
from torch import FloatTensor
from torch.nn import Linear
from torch.nn.functional import tanh
from torch.nn.functional import log_softmax
from torch.autograd import Variable
class Model(Module):
def __init__(self, n_inputs, n_hidden, n_outputs):
super().__init__(... |
_SepConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 _SepConv1d(nn.Module):
"""A simple separable convolution implementation.
The separable convlution is a method to reduce number of the parameters
in the deep learning network for slight decrease in predictions quality.
"""
def __init__(self, ni, no, kernel,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | thupchnsky/ModifiedBasesAnalysis | _SepConv1d | false | 4,425 | [
"MIT"
] | 0 | 904fab75eb5fdc67a050b3862d1432ecce8cf691 | https://github.com/thupchnsky/ModifiedBasesAnalysis/tree/904fab75eb5fdc67a050b3862d1432ecce8cf691 | import torch
from torch import nn
class Model(nn.Module):
"""A simple separable convolution implementation.
The separable convlution is a method to reduce number of the parameters
in the deep learning network for slight decrease in predictions quality.
"""
def __init__(self, ni, no, kernel, stri... |
Highway | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.utils
class Highway(nn.Module):
"""it is not fun"""
def __init__(self, e_word_size, drop_rate=0.3):
super(Highway, self).__init__()
self.w_proj = nn.Linear(e_word_size, e_word_size)
self.w_gate = nn.Linear(e_word_size, e_word_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | thophan92/cs224n-winter2019 | Highway | false | 4,426 | [
"MIT"
] | 0 | f3f8041b35e949e73167135d662a2bd93e7406de | https://github.com/thophan92/cs224n-winter2019/tree/f3f8041b35e949e73167135d662a2bd93e7406de | import torch
import torch.nn as nn
import torch.nn.utils
class Model(nn.Module):
"""it is not fun"""
def __init__(self, e_word_size, drop_rate=0.3):
super().__init__()
self.w_proj = nn.Linear(e_word_size, e_word_size)
self.w_gate = nn.Linear(e_word_size, e_word_size)
self.relu... |
GroupLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as f
class GroupLinear(nn.Module):
def __init__(self, groups, channels, map_size, dropout=None):
super(GroupLinear, self).__init__()
self.groups = groups
self.channels = channels
self.map_size = map_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
import torch.optim
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | tiruns/grad_proj | GroupLinear | false | 4,427 | [
"MIT"
] | 0 | 8882ff1e3205e346e972d963480c57dbf5aef407 | https://github.com/tiruns/grad_proj/tree/8882ff1e3205e346e972d963480c57dbf5aef407 | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as f
class Model(nn.Module):
def __init__(self, groups, channels, map_size, dropout=None):
super().__init__()
self.groups = groups
self.channels = channels
self.map_size = map_size
self.linear... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | thejammerr/DriveAlert | Net | false | 4,428 | [
"MIT"
] | 0 | bac025c2e2919aeb67ef717e90d3049403ecdef5 | https://github.com/thejammerr/DriveAlert/tree/bac025c2e2919aeb67ef717e90d3049403ecdef5 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
self.fc1 =... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn.functional as F
from torch import nn
def hidden_init(layer):
fan_in = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(fan_in)
return -lim, lim
class Actor(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed, fc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | tjkemp/ubik-agent | Actor | false | 4,429 | [
"MIT"
] | 0 | 34e4dd0d6319b8f5c5dba0cd9e087490720b723b | https://github.com/tjkemp/ubik-agent/tree/34e4dd0d6319b8f5c5dba0cd9e087490720b723b | import torch
import numpy as np
import torch.nn.functional as F
from torch import nn
def hidden_init(layer):
fan_in = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(fan_in)
return -lim, lim
class Model(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed, fc... |
StableBCELoss | # 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 StableBCELoss(nn.Module):
def __init__(self):
super(StableBCELoss, self).__init__()
def forward(self, input, target):
input = input.float().view(-1)
target = target.float().view(-1)
neg_abs = -input.abs()
loss = input.clamp(min... | 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
... | toandaominh1997/understanding_cloud_organization | StableBCELoss | false | 4,431 | [
"MIT"
] | 0 | 7da991ff3da557c18f4585c1b956ed799c104c7c | https://github.com/toandaominh1997/understanding_cloud_organization/tree/7da991ff3da557c18f4585c1b956ed799c104c7c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, target):
input = input.float().view(-1)
target = target.float().view(-1)
neg_abs = -input.abs()
loss = input.clamp(min=0) - input * target + (1 +... |
AngleMultipleLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import Parameter
def normalize(x, dim, p=2, eps=1e-12):
if torch.onnx.is_in_onnx_export():
return OnnxLpNormalization.apply(x, dim, p, eps)
else:
return F.normalize(x, dim=dim)
class OnnxLpNor... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | sovrasov/mmaction2 | AngleMultipleLinear | false | 4,432 | [
"Apache-2.0"
] | 0 | 055625bf6d6e06e9f811cc4f8b0332c18cebc98c | https://github.com/sovrasov/mmaction2/tree/055625bf6d6e06e9f811cc4f8b0332c18cebc98c | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import Parameter
def normalize(x, dim, p=2, eps=1e-12):
if torch.onnx.is_in_onnx_export():
return OnnxLpNormalization.apply(x, dim, p, eps)
else:
return F.normalize(x, dim=dim)
class OnnxLpNor... |
VectorQuantizer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 VectorQuantizer(nn.Module):
"""
Reference:
[1] https://github.com/deepmind/sonnet/blob/v2/sonnet/src/nets/vqvae.py
"""
def __init__(self, num_embeddings: 'int', embedding_dim: 'int', beta:
'float'=0.25):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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... | threewisemonkeys-as/PyTorch-VAE | VectorQuantizer | false | 4,433 | [
"Apache-2.0"
] | 0 | 4ed0fc7581d4792b435134aa9e06d5e35a5db118 | https://github.com/threewisemonkeys-as/PyTorch-VAE/tree/4ed0fc7581d4792b435134aa9e06d5e35a5db118 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
Reference:
[1] https://github.com/deepmind/sonnet/blob/v2/sonnet/src/nets/vqvae.py
"""
def __init__(self, num_embeddings: 'int', embedding_dim: 'int', beta:
'float'=0.25):
super().__... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn.functional as F
from torch import nn
def hidden_init(layer):
fan_in = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(fan_in)
return -lim, lim
class Critic(nn.Module):
"""Critic (Value) Model."""
def __init__(self, state_size, action_size, seed, f... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import numpy as np
from torch... | tjkemp/ubik-agent | Critic | false | 4,434 | [
"MIT"
] | 0 | 34e4dd0d6319b8f5c5dba0cd9e087490720b723b | https://github.com/tjkemp/ubik-agent/tree/34e4dd0d6319b8f5c5dba0cd9e087490720b723b | import torch
import numpy as np
import torch.nn.functional as F
from torch import nn
def hidden_init(layer):
fan_in = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(fan_in)
return -lim, lim
class Model(nn.Module):
"""Critic (Value) Model."""
def __init__(self, state_size, action_size, seed, fc... |
DeepQNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
class DeepQNetwork(nn.Module):
def __init__(self, ALPHA):
super(DeepQNetwork, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 8, stride=4, padding=1)
self.conv2 = nn.Conv2d(32, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch as T
import torc... | SuperSaiyan-God/Reinforcement-Learning | DeepQNetwork | false | 4,435 | [
"MIT"
] | 0 | b43a2997e28ec3bf437c37d060637f6deecf89c6 | https://github.com/SuperSaiyan-God/Reinforcement-Learning/tree/b43a2997e28ec3bf437c37d060637f6deecf89c6 | import torch
import torch as T
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
class Model(nn.Module):
def __init__(self, ALPHA):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, 8, stride=4, padding=1)
self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
... |
Model | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inputdim):
super(Model, self).__init__()
self.layer1 = nn.Linear(inputdim, 16)
torch.nn.init.xavier_uniform_(self.layer1.weight)
self.layer2 = nn.Linear(16, 32)
torch.nn.init.xavier_uniform_(self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | terry97-guel/POENet-ActiveLearning | Model | false | 4,436 | [
"MIT"
] | 0 | 78e959c8c5eacc5b2dc4e3334ed609d182ce7b6c | https://github.com/terry97-guel/POENet-ActiveLearning/tree/78e959c8c5eacc5b2dc4e3334ed609d182ce7b6c | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inputdim):
super(Model, self).__init__()
self.layer1 = nn.Linear(inputdim, 16)
torch.nn.init.xavier_uniform_(self.layer1.weight)
self.layer2 = nn.Linear(16, 32)
torch.nn.init.xavier_uniform_(self... |
wide_basic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def get_norm(n_filters, norm):
if norm is None:
return Identity()
elif norm == 'batch':
return nn.BatchNorm2d(n_filters, momentum=0.9)
elif norm == 'instance':
return nn.InstanceNorm2d(n_filters, affine=True)
elif norm == 'layer':
retu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | tianyi21/JEM | wide_basic | false | 4,437 | [
"Apache-2.0"
] | 0 | 59b4bb87be1b1643731540133df557edd7780a88 | https://github.com/tianyi21/JEM/tree/59b4bb87be1b1643731540133df557edd7780a88 | import torch
import torch.nn as nn
def get_norm(n_filters, norm):
if norm is None:
return Identity()
elif norm == 'batch':
return nn.BatchNorm2d(n_filters, momentum=0.9)
elif norm == 'instance':
return nn.InstanceNorm2d(n_filters, affine=True)
elif norm == 'layer':
retu... |
BhattacharyyaDistance | # 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 BhattacharyyaDistance(nn.Module):
def __init__(self):
super(BhattacharyyaDistance, self).__init__()
def forward(self, hist1, hist2):
bh_dist = torch.sqrt(hist1 * hist2).sum()
return bh_dist
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 import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | tommy90191/Find_Tiny_but_Important_Image_Changes | BhattacharyyaDistance | false | 4,438 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, hist1, hist2):
bh_dist = torch.sqrt(hist1 * hist2).sum()
return bh_dist
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_in... |
l1normalization | # 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 l1normalization(nn.Module):
def __init__(self, scale):
super(l1normalization, self).__init__()
self.scale = scale
def forward(self, x, dim=1):
return self.scale * x * x.pow(1).sum(dim).clamp(min=1e-12).rsqrt(
).expand_as(x)
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 import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | tommy90191/Find_Tiny_but_Important_Image_Changes | l1normalization | false | 4,439 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x, dim=1):
return self.scale * x * x.pow(1).sum(dim).clamp(min=1e-12).rsqrt(
).expand_as(x)
def get_inputs():
return [torch.... |
Conv2dWithConstraint | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Conv2dWithConstraint(nn.Conv2d):
def __init__(self, *args, max_norm=1, **kwargs):
self.max_norm = max_norm
super(Conv2dWithConstraint, self).__init__(*args, **kwargs)
def forward(self, x):
self.weight.data = torch.renorm(self.weight.data, p=2, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | tomMoral/braindecode | Conv2dWithConstraint | false | 4,440 | [
"BSD-3-Clause"
] | 0 | 09d63b7e32fdfcfbaac7569a003f2611721a78ca | https://github.com/tomMoral/braindecode/tree/09d63b7e32fdfcfbaac7569a003f2611721a78ca | import torch
from torch import nn
class Model(nn.Conv2d):
def __init__(self, *args, max_norm=1, **kwargs):
self.max_norm = max_norm
super().__init__(*args, **kwargs)
def forward(self, x):
self.weight.data = torch.renorm(self.weight.data, p=2, dim=0,
maxnorm=self.max_norm)... |
KLCoefficient | # 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.nn import functional as F
class KLCoefficient(nn.Module):
def __init__(self):
super(KLCoefficient, self).__init__()
def forward(self, hist1, hist2):
kl = F.kl_div(hist1, hist2)
dist = 1.0 / 1 + kl
return dist
def get_inputs():
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | tommy90191/Find_Tiny_but_Important_Image_Changes | KLCoefficient | false | 4,441 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, hist1, hist2):
kl = F.kl_div(hist1, hist2)
dist = 1.0 / 1 + kl
return dist
def get_inputs():
return [torch.rand([4, 4... |
ConstractiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
from torch.nn import functional as F
class ConstractiveLoss(nn.Module):
def __init__(self, margin=2.0, dist_flag='l2'):
super(ConstractiveLoss, self).__init__()
self.margin = margin
self.dist_flag = dist_flag
def various_distance(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import numpy as np
import to... | tommy90191/Find_Tiny_but_Important_Image_Changes | ConstractiveLoss | false | 4,442 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import numpy as np
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, margin=2.0, dist_flag='l2'):
super().__init__()
self.margin = margin
self.dist_flag = dist_flag
def various_distance(self, out_vec_t0, out_vec_t1):
... |
l2normalization | # 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 l2normalization(nn.Module):
def __init__(self, scale):
super(l2normalization, self).__init__()
self.scale = scale
def forward(self, x, dim=1):
"""out = scale * x / sqrt(\\sum x_i^2)"""
return self.scale * x * x.pow(2).sum(dim).clamp(mi... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | tommy90191/Find_Tiny_but_Important_Image_Changes | l2normalization | false | 4,443 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x, dim=1):
"""out = scale * x / sqrt(\\sum x_i^2)"""
return self.scale * x * x.pow(2).sum(dim).clamp(min=1e-12).rsqrt(
).e... |
scale_feature | # 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 scale_feature(nn.Module):
def __init__(self, scale):
super(scale_feature, self).__init__()
self.scale = scale
def forward(self, x):
return self.scale * x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
re... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | tommy90191/Find_Tiny_but_Important_Image_Changes | scale_feature | false | 4,444 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, x):
return self.scale * x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [1.0]
|
DQFFN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DQFFN(nn.Module):
def __init__(self, n):
"""
Create Feed-forward Network with n dim input and n dim output
"""
super(DQFFN, self).__init__()
self.n = n
self.l1 = nn.Linear(n * (n + 1) // 2, 20... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | thomashopkins32/RedBlueGame | DQFFN | false | 4,445 | [
"MIT"
] | 0 | dd3e759123acc02375fdfcc504892e00e6b31ef1 | https://github.com/thomashopkins32/RedBlueGame/tree/dd3e759123acc02375fdfcc504892e00e6b31ef1 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, n):
"""
Create Feed-forward Network with n dim input and n dim output
"""
super().__init__()
self.n = n
self.l1 = nn.Linear(n * (n + 1) // 2, 2048)
... |
L2Norm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from math import sqrt as sqrt
from itertools import product as product
import torch.nn as nn
import torch.nn.init as init
class L2Norm(nn.Module):
def __init__(self, n_channels, scale):
super(L2Norm, self).__init__()
self.n_channels = n_channels
self.gamma = scale or None
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from math import sqrt as sqrt
from itertools import product as product
import t... | tomgause/pytorch-ssd | L2Norm | false | 4,446 | [
"MIT"
] | 0 | e458d4319deb21c8970bcce13382e7ada70ea1a2 | https://github.com/tomgause/pytorch-ssd/tree/e458d4319deb21c8970bcce13382e7ada70ea1a2 | import torch
from math import sqrt as sqrt
from itertools import product as product
import torch.nn as nn
import torch.nn.init as init
class Model(nn.Module):
def __init__(self, n_channels, scale):
super().__init__()
self.n_channels = n_channels
self.gamma = scale or None
self.eps... |
FeatureCorrelation | # 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 FeatureCorrelation(nn.Module):
def __init__(self, scale):
super(FeatureCorrelation, self).__init__()
self.scale = scale
def forward(self, feature_A, feature_B):
b, c, h, w = feature_A.size()
feature_A = feature_A.transpose(2, 3).contig... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | tommy90191/Find_Tiny_but_Important_Image_Changes | FeatureCorrelation | false | 4,447 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, scale):
super().__init__()
self.scale = scale
def forward(self, feature_A, feature_B):
b, c, h, w = feature_A.size()
feature_A = feature_A.transpose(2, 3).contiguous().view(b, c, h * w)
feat... |
ConstractiveThresholdHingeLoss | # 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.nn import functional as F
class ConstractiveThresholdHingeLoss(nn.Module):
def __init__(self, hingethresh=0.0, margin=2.0):
super(ConstractiveThresholdHingeLoss, self).__init__()
self.threshold = hingethresh
self.margin = margin
def forwa... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | tommy90191/Find_Tiny_but_Important_Image_Changes | ConstractiveThresholdHingeLoss | false | 4,448 | [
"MIT"
] | 0 | 429d679606f96f32db4cddf167a9cfb963d3df26 | https://github.com/tommy90191/Find_Tiny_but_Important_Image_Changes/tree/429d679606f96f32db4cddf167a9cfb963d3df26 | import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, hingethresh=0.0, margin=2.0):
super().__init__()
self.threshold = hingethresh
self.margin = margin
def forward(self, out_vec_t0, out_vec_t1, label):
distance = F... |
ResNetBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ResNetBlock(nn.Module):
def __init__(self, in_channels: 'int', out_channels: 'int',
hid_channels: 'int', bias: 'bool'):
super().__init__()
self.shortcut = in_channels != out_channels
self.conv_0 = nn.Conv2d(i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | tmralmeida/VGAN | ResNetBlock | false | 4,449 | [
"MIT"
] | 0 | 103d2e7ac0b84b08ff3c3a40e0ccb16390b1e008 | https://github.com/tmralmeida/VGAN/tree/103d2e7ac0b84b08ff3c3a40e0ccb16390b1e008 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels: 'int', out_channels: 'int',
hid_channels: 'int', bias: 'bool'):
super().__init__()
self.shortcut = in_channels != out_channels
self.conv_0 = nn.Conv2d(in_chan... |
Affine | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
class Affine(nn.Module):
def __init__(self, dim):
super().__init__()
self.alpha = nn.Parameter(torch.ones((1, 1, dim)))
self.beta = nn.Parameter(torch.zeros((1, 1, dim)))
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.nn.parallel
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty... | tor4z/pytorch-image-models | Affine | false | 4,450 | [
"Apache-2.0"
] | 0 | d7bab8a6c52a72487d1bed0a28aad41e326d7622 | https://github.com/tor4z/pytorch-image-models/tree/d7bab8a6c52a72487d1bed0a28aad41e326d7622 | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.alpha = nn.Parameter(torch.ones((1, 1, dim)))
self.beta = nn.Parameter(torch.zeros((1, 1, dim)))
def forward(self, x):
... |
L1 | # 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 L1(nn.Module):
def __init__(self):
super(L1, self).__init__()
def forward(self, output, target):
lossvalue = torch.abs(output[:, None] - target).mean()
return lossvalue
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | tomrunia/flownet2-pytorch | L1 | false | 4,451 | [
"Apache-2.0"
] | 0 | 759b09c375348cf64f52f914cf3bf3e9095cc959 | https://github.com/tomrunia/flownet2-pytorch/tree/759b09c375348cf64f52f914cf3bf3e9095cc959 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, target):
lossvalue = torch.abs(output[:, None] - target).mean()
return lossvalue
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, ... |
L2 | # 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 L2(nn.Module):
def __init__(self):
super(L2, self).__init__()
def forward(self, output, target):
lossvalue = torch.norm(output[:, None] - target, p=2, dim=1).mean()
return lossvalue
def get_inputs():
return [torch.rand([4, 4, 4, 4]), tor... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | tomrunia/flownet2-pytorch | L2 | false | 4,452 | [
"Apache-2.0"
] | 0 | 759b09c375348cf64f52f914cf3bf3e9095cc959 | https://github.com/tomrunia/flownet2-pytorch/tree/759b09c375348cf64f52f914cf3bf3e9095cc959 | 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[:, None] - target, p=2, dim=1).mean()
return lossvalue
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.ra... |
AvgConsensus | # 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 AvgConsensus(nn.Module):
"""Average consensus module.
Args:
dim (int): Decide which dim consensus function to apply.
Default: 1.
"""
def __init__(self, dim=1):
super().__init__()
self.dim = dim
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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | scenarios/dev | AvgConsensus | false | 4,453 | [
"Apache-2.0"
] | 0 | 9f91ebc142cea1c31231d233571ad59460ab6fba | https://github.com/scenarios/dev/tree/9f91ebc142cea1c31231d233571ad59460ab6fba | import torch
import torch.nn as nn
class Model(nn.Module):
"""Average consensus module.
Args:
dim (int): Decide which dim consensus function to apply.
Default: 1.
"""
def __init__(self, dim=1):
super().__init__()
self.dim = dim
def forward(self, x):
"... |
WeightNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 WeightNet(nn.Module):
"""WeightNet in Temporal interlace module.
The WeightNet consists of two parts: one convolution layer
and a sigmoid function. Following the convolution layer, the sigmoid
function and rescale module can scale our output to the range (0, 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
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | scenarios/dev | WeightNet | false | 4,454 | [
"Apache-2.0"
] | 0 | 9f91ebc142cea1c31231d233571ad59460ab6fba | https://github.com/scenarios/dev/tree/9f91ebc142cea1c31231d233571ad59460ab6fba | import torch
import torch.nn as nn
class Model(nn.Module):
"""WeightNet in Temporal interlace module.
The WeightNet consists of two parts: one convolution layer
and a sigmoid function. Following the convolution layer, the sigmoid
function and rescale module can scale our output to the range (0, 2).
... |
BinaryLogisticRegressionLoss | # 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 binary_logistic_regression_loss(reg_score, label, threshold=0.5,
ratio_range=(1.05, 21), eps=1e-05):
"""Binary Logistic Regression Loss."""
label = label.view(-1)
reg_score = reg_score.contiguous().view(-1)
pmask = (label > threshold).float()
num_positive... | 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
... | scenarios/dev | BinaryLogisticRegressionLoss | false | 4,455 | [
"Apache-2.0"
] | 0 | 9f91ebc142cea1c31231d233571ad59460ab6fba | https://github.com/scenarios/dev/tree/9f91ebc142cea1c31231d233571ad59460ab6fba | import torch
import torch.nn as nn
def binary_logistic_regression_loss(reg_score, label, threshold=0.5,
ratio_range=(1.05, 21), eps=1e-05):
"""Binary Logistic Regression Loss."""
label = label.view(-1)
reg_score = reg_score.contiguous().view(-1)
pmask = (label > threshold).float()
num_positive... |
GCN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class GCN(nn.Module):
def __init__(self, num_state, num_node, bias=False):
super(GCN, self).__init__()
self.conv1 = nn.Conv1d(num_node, num_node, kernel_size=1, padding=0,
stride... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torchvision.datasets imp... | tousifulhaque/DANet | GCN | false | 4,456 | [
"MIT"
] | 0 | 1a0c91f0e551a071b5e335b4157313780a8a1b1a | https://github.com/tousifulhaque/DANet/tree/1a0c91f0e551a071b5e335b4157313780a8a1b1a | import torch
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
def __init__(self, num_state, num_node, bias=False):
super().__init__()
self.conv1 = nn.Conv1d(num_node, num_node, kernel_size=1, padding=0,
stride=1, gro... |
Normalize | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torchvision.datasets import *
import torch.nn as nn
import torch.nn.functional as F
from torchvision.transforms import *
class Normalize(nn.Module):
"""Performs :math:`L_p` normalization of inputs over specified dimension.
Does:
.. math::
v = \\frac{v}{\\max(\\lVert v \\rVert_p... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torchvision.datasets im... | tousifulhaque/DANet | Normalize | false | 4,457 | [
"MIT"
] | 0 | 1a0c91f0e551a071b5e335b4157313780a8a1b1a | https://github.com/tousifulhaque/DANet/tree/1a0c91f0e551a071b5e335b4157313780a8a1b1a | import torch
from torchvision.datasets import *
import torch.nn as nn
import torch.nn.functional as F
from torchvision.transforms import *
class Model(nn.Module):
"""Performs :math:`L_p` normalization of inputs over specified dimension.
Does:
.. math::
v = \\frac{v}{\\max(\\lVert v \\rVert_p, \\... |
OffsetNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 OffsetNet(nn.Module):
"""OffsetNet in Temporal interlace module.
The OffsetNet consists of one convolution layer and two fc layers
with a relu activation following with a sigmoid function. Following
the convolution layer, two fc layers and relu are applied to ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | scenarios/dev | OffsetNet | false | 4,458 | [
"Apache-2.0"
] | 0 | 9f91ebc142cea1c31231d233571ad59460ab6fba | https://github.com/scenarios/dev/tree/9f91ebc142cea1c31231d233571ad59460ab6fba | import torch
import torch.nn as nn
class Model(nn.Module):
"""OffsetNet in Temporal interlace module.
The OffsetNet consists of one convolution layer and two fc layers
with a relu activation following with a sigmoid function. Following
the convolution layer, two fc layers and relu are applied to the ... |
TwoPartSimpleModel | # 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 SimpleModel(nn.Module):
def forward(self, x):
return 2 * x
def prepare_for_export(self, cfg, inputs, predictor_type):
return PredictorExportConfig(model=self, data_generator=lambda x: (x,))
class TwoPartSimpleModel(nn.Module)... | 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.... | tsubauaaa/d2go | TwoPartSimpleModel | false | 4,459 | [
"Apache-2.0"
] | 0 | 9f746159ebf78ce79f644c405ca8695bc29d1075 | https://github.com/tsubauaaa/d2go/tree/9f746159ebf78ce79f644c405ca8695bc29d1075 | import torch
import torch.nn as nn
import torch.utils.data
class SimpleModel(nn.Module):
def forward(self, x):
return 2 * x
def prepare_for_export(self, cfg, inputs, predictor_type):
return PredictorExportConfig(model=self, data_generator=lambda x: (x,))
class Model(nn.Module):
"""
... |
CPAMDec | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 torchvision.datasets import *
from torch.nn import Parameter
from torch.nn import Conv2d
from torch.nn import Linear
from torch.nn import Softmax
from torchvision.transforms import *
class CPAMDec(Module):
"""
CPAM decoding module
"""
def __init__(self, i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | tousifulhaque/DANet | CPAMDec | false | 4,460 | [
"MIT"
] | 0 | 1a0c91f0e551a071b5e335b4157313780a8a1b1a | https://github.com/tousifulhaque/DANet/tree/1a0c91f0e551a071b5e335b4157313780a8a1b1a | from torch.nn import Module
import torch
from torchvision.datasets import *
from torch.nn import Parameter
from torch.nn import Conv2d
from torch.nn import Linear
from torch.nn import Softmax
from torchvision.transforms import *
class Model(Module):
"""
CPAM decoding module
"""
def __init__(self, in_... |
SplitAndConcat | # 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 SplitAndConcat(nn.Module):
"""Split the data from split_dim and concatenate in concat_dim.
@param split_dim from which axis the data will be chunk
@param concat_dim to which axis the data will be concatenated
@param chunk size of the da... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | tsubauaaa/d2go | SplitAndConcat | false | 4,461 | [
"Apache-2.0"
] | 0 | 9f746159ebf78ce79f644c405ca8695bc29d1075 | https://github.com/tsubauaaa/d2go/tree/9f746159ebf78ce79f644c405ca8695bc29d1075 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""Split the data from split_dim and concatenate in concat_dim.
@param split_dim from which axis the data will be chunk
@param concat_dim to which axis the data will be concatenated
@param chunk size of the data to be ... |
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
class GELU(nn.Module):
def forward(self, x):
return torch.sigmoid(1.702 * x) * x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | txsing/augmix | GELU | false | 4,462 | [
"Apache-2.0"
] | 0 | 9127809d8534ccb20a654f631833153e75a277fd | https://github.com/txsing/augmix/tree/9127809d8534ccb20a654f631833153e75a277fd | import torch
import torch.nn as nn
class Model(nn.Module):
def forward(self, x):
return torch.sigmoid(1.702 * x) * x
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
InstanceNormLayer | # 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 InstanceNormLayer(nn.Module):
"""Implements instance normalization layer."""
def __init__(self, epsilon=1e-08):
super().__init__()
self.epsilon = epsilon
def forward(self, x):
if len(x.shape) != 4:
raise ValueError(
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | tylerwilliams/InterFaceGAN | InstanceNormLayer | false | 4,463 | [
"MIT"
] | 0 | 120babcc0dc777aa902ef0dcdeaec7c528369dbc | https://github.com/tylerwilliams/InterFaceGAN/tree/120babcc0dc777aa902ef0dcdeaec7c528369dbc | import torch
from torch import nn
class Model(nn.Module):
"""Implements instance normalization layer."""
def __init__(self, epsilon=1e-08):
super().__init__()
self.epsilon = epsilon
def forward(self, x):
if len(x.shape) != 4:
raise ValueError(
f'The in... |
CCAMDec | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 torchvision.datasets import *
from torch.nn import Parameter
from torch.nn import Softmax
from torchvision.transforms import *
class CCAMDec(Module):
"""
CCAM decoding module
"""
def __init__(self):
super(CCAMDec, self).__init__()
self.sof... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | tousifulhaque/DANet | CCAMDec | false | 4,464 | [
"MIT"
] | 0 | 1a0c91f0e551a071b5e335b4157313780a8a1b1a | https://github.com/tousifulhaque/DANet/tree/1a0c91f0e551a071b5e335b4157313780a8a1b1a | from torch.nn import Module
import torch
from torchvision.datasets import *
from torch.nn import Parameter
from torch.nn import Softmax
from torchvision.transforms import *
class Model(Module):
"""
CCAM decoding module
"""
def __init__(self):
super().__init__()
self.softmax = Softmax(... |
Bandpass | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Bandpass(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.mean = nn.Parameter(torch.randn(1, input_dim, dtype=torch.float32)
)
self.icov = nn.Parameter(torch.eye(input_dim, input_dim, dtype=
torch.float32) ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | tsumansapkota/Input-Invex-Neural-Network | Bandpass | false | 4,465 | [
"Apache-2.0"
] | 0 | 6a14ee12b33da1d231d231c8f9631851a7668997 | https://github.com/tsumansapkota/Input-Invex-Neural-Network/tree/6a14ee12b33da1d231d231c8f9631851a7668997 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.mean = nn.Parameter(torch.randn(1, input_dim, dtype=torch.float32)
)
self.icov = nn.Parameter(torch.eye(input_dim, input_dim, dtype=
torch.float32) * 2... |
DQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 DQN(nn.Module):
def __init__(self, obs_size, action_size, seed):
super(DQN, self).__init__()
self.fc1 = nn.Linear(obs_size, 128)
self.fc2 = nn.Linear(128, 128)
self.fc3 = nn.Linear(128, sum(action_size))
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | ulyssesdotcodes/ReaL-Crowds | DQN | false | 4,466 | [
"BSD-3-Clause"
] | 0 | 9da01fe4d1858c3c26d6387e34f4e76db5385d51 | https://github.com/ulyssesdotcodes/ReaL-Crowds/tree/9da01fe4d1858c3c26d6387e34f4e76db5385d51 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, obs_size, action_size, seed):
super().__init__()
self.fc1 = nn.Linear(obs_size, 128)
self.fc2 = nn.Linear(128, 128)
self.fc3 = nn.Linear(128, sum(action_size))
def fo... |
TSA_Fusion | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
class TSA_Fusion(nn.Module):
""" Temporal Spatial Attention fusion module
Temporal: correlation;
Spatial: 3 pyramid levels.
"""
def __init__(self, nf=64, nframes=5, center=2):
super(TSA_Fusion, self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | sutkarsh/EDVR | TSA_Fusion | false | 4,467 | [
"Apache-2.0"
] | 0 | cd9f2d46edbb00333d8ffb31aebc52cfbda4b6e3 | https://github.com/sutkarsh/EDVR/tree/cd9f2d46edbb00333d8ffb31aebc52cfbda4b6e3 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
""" Temporal Spatial Attention fusion module
Temporal: correlation;
Spatial: 3 pyramid levels.
"""
def __init__(self, nf=64, nframes=5, center=2):
super().__init__()
... |
LenCompLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch
import torch.nn as nn
class LenCompLoss(nn.Module):
def __init__(self):
super(LenCompLoss, self).__init__()
self.loss = nn.L1Loss()
def forward(self, x, y):
loss = self.loss(torch.sum(x), torch.sum(y))
return loss
def get_in... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.dat... | usmanwardag/pytorch-CycleGAN-and-pix2pix | LenCompLoss | false | 4,468 | [
"BSD-3-Clause"
] | 0 | 72f2050600e7821476c9e19fcf8f1973f6a6f78c | https://github.com/usmanwardag/pytorch-CycleGAN-and-pix2pix/tree/72f2050600e7821476c9e19fcf8f1973f6a6f78c | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.loss = nn.L1Loss()
def forward(self, x, y):
loss = self.loss(torch.sum(x), torch.sum(y))
return loss
def get_inputs():
return [tor... |
FluidGravityForce | # 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 FluidGravityForce(nn.Module):
def __init__(self, gravity, maxSpeed=3):
"""
Initializes a fluid gravity model.
Arguments:
gravity: Gravity vector in the global frame (same as particle l) for the simulation
maxSpeed: The maxi... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | ucsdarclab/liquid_reconstruction | FluidGravityForce | false | 4,469 | [
"MIT"
] | 0 | 5559edbf71dba05d432d85e7dbbfe3634e650aeb | https://github.com/ucsdarclab/liquid_reconstruction/tree/5559edbf71dba05d432d85e7dbbfe3634e650aeb | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, gravity, maxSpeed=3):
"""
Initializes a fluid gravity model.
Arguments:
gravity: Gravity vector in the global frame (same as particle l) for the simulation
maxSpeed: The maximum magnitud... |
KLDivergence | # 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
class KLDivergence(th.nn.Module):
"""
Args:
min_value(float): the loss is clipped so that value below this
number don't affect the optimization.
"""
def __init__(self, min_value=0.2):
super(KLDivergence, self).__init__()
self.min_val... | 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 as th
ass... | v-a-s-a/diffvg | KLDivergence | false | 4,470 | [
"Apache-2.0"
] | 0 | 3685f3d47a5a4e5c76c68643ebf383f809ba59ed | https://github.com/v-a-s-a/diffvg/tree/3685f3d47a5a4e5c76c68643ebf383f809ba59ed | import torch
import torch as th
class Model(th.nn.Module):
"""
Args:
min_value(float): the loss is clipped so that value below this
number don't affect the optimization.
"""
def __init__(self, min_value=0.2):
super().__init__()
self.min_value = min_value
def f... |
BMNLoss | # 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
import torch.nn as nn
def binary_logistic_regression_loss(reg_score, label, threshold=0.5,
ratio_range=(1.05, 21), eps=1e-05):
"""Binary Logistic Regression Loss."""
label = label.view(-1)
reg_score = reg_score.contiguous().view(-1)
pmask = (label > thr... | 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
from torch._inductor.runtime.triton_helpers import math as tl_ma... | scenarios/dev | BMNLoss | false | 4,471 | [
"Apache-2.0"
] | 0 | 9f91ebc142cea1c31231d233571ad59460ab6fba | https://github.com/scenarios/dev/tree/9f91ebc142cea1c31231d233571ad59460ab6fba | import torch
import torch.nn.functional as F
import torch.nn as nn
def binary_logistic_regression_loss(reg_score, label, threshold=0.5,
ratio_range=(1.05, 21), eps=1e-05):
"""Binary Logistic Regression Loss."""
label = label.view(-1)
reg_score = reg_score.contiguous().view(-1)
pmask = (label > thr... |
MaxPPVPool1d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
import torch.multiprocessing
import torch
class MaxPPVPool1d(Module):
"""Drop-in replacement for AdaptiveConcatPool1d - multiplies nf by 2"""
def forward(self, x):
_max = x.max(dim=-1).values
_ppv = torch.gt(x, 0).sum(dim=-1).float() / x.shape[-1]
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn import Module
import torch.multiprocessing
import torch
assert_size_stride ... | sjdlloyd/tsai | MaxPPVPool1d | false | 4,472 | [
"Apache-2.0"
] | 0 | 98d9c02b8429708819d373b475deb9e99f0ab7df | https://github.com/sjdlloyd/tsai/tree/98d9c02b8429708819d373b475deb9e99f0ab7df | from torch.nn import Module
import torch
import torch.multiprocessing
import torch
class Model(Module):
"""Drop-in replacement for AdaptiveConcatPool1d - multiplies nf by 2"""
def forward(self, x):
_max = x.max(dim=-1).values
_ppv = torch.gt(x, 0).sum(dim=-1).float() / x.shape[-1]
ret... |
ScoringFunction | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Conv2dAct(nn.Module):
def __init__(self, in_channels, out_channels, ksize=1, activation='relu'):
super(Conv2dAct, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, ksize)
if activation == 'sigmoid':
self.act = nn.Sigmoid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | sunwhawhang/headpose-fsanet-pytorch | ScoringFunction | false | 4,473 | [
"MIT"
] | 0 | d37d39dbff649b2f607367f35d9eadba2fea18f7 | https://github.com/sunwhawhang/headpose-fsanet-pytorch/tree/d37d39dbff649b2f607367f35d9eadba2fea18f7 | import torch
import torch.nn as nn
class Conv2dAct(nn.Module):
def __init__(self, in_channels, out_channels, ksize=1, activation='relu'):
super().__init__()
self.conv = nn.Conv2d(in_channels, out_channels, ksize)
if activation == 'sigmoid':
self.act = nn.Sigmoid()
elif... |
CrossEntropy | # 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 torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class CrossEntropy(nn.Module):
def forward(self, x, y):
return F.cross_entropy(x, torch.argmax(y, -1))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | tgxs002/1-stage-wseg | CrossEntropy | false | 4,474 | [
"Apache-2.0"
] | 0 | de16c51cc6cf8cd0ef248145980434d5f6104910 | https://github.com/tgxs002/1-stage-wseg/tree/de16c51cc6cf8cd0ef248145980434d5f6104910 | import torch
import torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def forward(self, x, y):
return F.cross_entropy(x, torch.argmax(y, -1))
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_in... |
Gaussian | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.utils.data
class Gaussian(nn.Module):
def __init__(self, in_dim, z_dim):
super(Gaussian, self).__init__()
self.mu = nn.Linear(in_dim, z_dim)
self.var = nn.Linear(in_dim, z_dim)
def reparameterize(self... | 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... | userVector/GMVAE | Gaussian | false | 4,475 | [
"MIT"
] | 0 | 2d0330c4174aa614f3817888798f88798313e01f | https://github.com/userVector/GMVAE/tree/2d0330c4174aa614f3817888798f88798313e01f | import torch
from torch import nn
from torch.nn import functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_dim, z_dim):
super().__init__()
self.mu = nn.Linear(in_dim, z_dim)
self.var = nn.Linear(in_dim, z_dim)
def reparameterize(self, mu, var):
... |
VarianceC | # 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 VarianceC(nn.Module):
def __init__(self):
super(VarianceC, self).__init__()
def forward(self, x):
mean_x = torch.mean(x, dim=1, keepdim=True)
sub_x = x.sub(mean_x)
x = torch.mean(torch.mul(sub_x, sub_x), dim=1, keepdim=True)
re... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | sunwhawhang/headpose-fsanet-pytorch | VarianceC | false | 4,476 | [
"MIT"
] | 0 | d37d39dbff649b2f607367f35d9eadba2fea18f7 | https://github.com/sunwhawhang/headpose-fsanet-pytorch/tree/d37d39dbff649b2f607367f35d9eadba2fea18f7 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
mean_x = torch.mean(x, dim=1, keepdim=True)
sub_x = x.sub(mean_x)
x = torch.mean(torch.mul(sub_x, sub_x), dim=1, keepdim=True)
return x
def get_in... |
ToyRes | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.multiprocessing
class ToyResLayer(nn.Module):
""" Custom Linear layer but mimics a standard linear layer """
def __init__(self):
super().__init__()
aprime = torch.Tensor(1)
bprime = torch.Tensor(1)
self.aprime = nn.Parameter(apri... | 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.multiprocessing
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | suswei/RLCT | ToyRes | false | 4,477 | [
"MIT"
] | 0 | e9e04ca5e64250dfbb94134ec5283286dcdc4358 | https://github.com/suswei/RLCT/tree/e9e04ca5e64250dfbb94134ec5283286dcdc4358 | import torch
import torch.nn as nn
import torch.multiprocessing
class ToyResLayer(nn.Module):
""" Custom Linear layer but mimics a standard linear layer """
def __init__(self):
super().__init__()
aprime = torch.Tensor(1)
bprime = torch.Tensor(1)
self.aprime = nn.Parameter(apri... |
Tanh | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.multiprocessing
class Tanh(nn.Module):
def __init__(self, input_dim, output_dim, H):
super(Tanh, self).__init__()
self.fc1 = nn.Linear(input_dim, H, bias=False)
self.fc2 = nn.Linear(H, output_dim, bias=False)
def forward(self, x):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | suswei/RLCT | Tanh | false | 4,478 | [
"MIT"
] | 0 | e9e04ca5e64250dfbb94134ec5283286dcdc4358 | https://github.com/suswei/RLCT/tree/e9e04ca5e64250dfbb94134ec5283286dcdc4358 | import torch
import torch.nn as nn
import torch.multiprocessing
class Model(nn.Module):
def __init__(self, input_dim, output_dim, H):
super().__init__()
self.fc1 = nn.Linear(input_dim, H, bias=False)
self.fc2 = nn.Linear(H, output_dim, bias=False)
def forward(self, x):
x = to... |
GaussianMixtureReconstructionLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch as th
def gaussian_pdfs(dx, dy, params):
"""Returns the pdf at (dx, dy) for each Gaussian in the mixture.
"""
dx = dx.unsqueeze(-1)
dy = dy.unsqueeze(-1)
mu_x = params[..., 0]
mu_y = params[..., 1]
sigma_x = params[..., 2].exp()
sigma_y = pa... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import nump... | v-a-s-a/diffvg | GaussianMixtureReconstructionLoss | false | 4,479 | [
"Apache-2.0"
] | 0 | 3685f3d47a5a4e5c76c68643ebf383f809ba59ed | https://github.com/v-a-s-a/diffvg/tree/3685f3d47a5a4e5c76c68643ebf383f809ba59ed | import torch
import numpy as np
import torch as th
def gaussian_pdfs(dx, dy, params):
"""Returns the pdf at (dx, dy) for each Gaussian in the mixture.
"""
dx = dx.unsqueeze(-1)
dy = dy.unsqueeze(-1)
mu_x = params[..., 0]
mu_y = params[..., 1]
sigma_x = params[..., 2].exp()
sigma_y = pa... |
PixelNorm | # 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.cpp_extension
import torch.utils.data.distributed
class PixelNorm(nn.Module):
def __init__(self, dim):
super().__init__()
def forward(self, input):
return input * torch.rsqrt(torch.mean(input ** 2, dim=2, keepdim=
True) + 1e-0... | 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.utils.cpp_extension
import torch.utils.data.... | Pragyanstha/SummerCamp2021 | PixelNorm | false | 4,480 | [
"MIT"
] | 0 | caa8bba64020ba52bdef2b23a7a54de93e93b8af | https://github.com/Pragyanstha/SummerCamp2021/tree/caa8bba64020ba52bdef2b23a7a54de93e93b8af | import torch
import torch.nn as nn
import torch.utils.cpp_extension
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
def forward(self, input):
return input * torch.rsqrt(torch.mean(input ** 2, dim=2, keepdim=
True) + 1e-08)
... |
UpsampleConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
from torchvision.datasets import *
import torch.nn.functional as F
from torch.nn import Parameter
from torch.nn.modules.utils import _pair
from torchvision.transforms import *
class UpsampleConv2d(Module):
"""
To avoid the checkerboard artifacts of standard... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
import math
from torchvision.datasets import *
from ... | tousifulhaque/DANet | UpsampleConv2d | false | 4,481 | [
"MIT"
] | 0 | 1a0c91f0e551a071b5e335b4157313780a8a1b1a | https://github.com/tousifulhaque/DANet/tree/1a0c91f0e551a071b5e335b4157313780a8a1b1a | from torch.nn import Module
import math
import torch
from torchvision.datasets import *
import torch.nn.functional as F
from torch.nn import Parameter
from torch.nn.modules.utils import _pair
from torchvision.transforms import *
class Model(Module):
"""
To avoid the checkerboard artifacts of standard Fraction... |
Quantize | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Quantize(nn.Module):
def __init__(self, emb_dim, emb_size, decay=0.99, eps=1e-05, ema_flag=
False, bdt_flag=False):
super().__init__()
self.emb_dim = emb_dim
self.emb_size = emb_size
self.ema_flag = e... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional as F
assert_size_stride = torch... | unilight/crank | Quantize | false | 4,482 | [
"MIT"
] | 0 | 0dc5d9df17f3186155b1c9583ab604ff218ad9a6 | https://github.com/unilight/crank/tree/0dc5d9df17f3186155b1c9583ab604ff218ad9a6 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, emb_dim, emb_size, decay=0.99, eps=1e-05, ema_flag=
False, bdt_flag=False):
super().__init__()
self.emb_dim = emb_dim
self.emb_size = emb_size
self.ema_flag = ema_... |
ConvPlus | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ConvPlus(nn.Module):
def __init__(self, c1, c2, k=3, s=1, g=1, bias=True):
super(ConvPlus, self).__init__()
self.cv1 = nn.Conv2d(c1, c2, (k, 1), s, (k // 2, 0), groups=g, bias
=bias)
self.cv2 = nn.Conv2d(c1, c2, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | verchable/GenderDiversityCalc | ConvPlus | false | 4,483 | [
"Apache-2.0"
] | 0 | eb07fbc9d13e567de4efd8ea2a0aae793a06bf1d | https://github.com/verchable/GenderDiversityCalc/tree/eb07fbc9d13e567de4efd8ea2a0aae793a06bf1d | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, c1, c2, k=3, s=1, g=1, bias=True):
super().__init__()
self.cv1 = nn.Conv2d(c1, c2, (k, 1), s, (k // 2, 0), groups=g, bias
=bias)
self.cv2 = nn.Conv2d(c1, c2, (1, k), s, (0, k ... |
Mean | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Mean(nn.Module):
def __init__(self, dim, keep_dim=False):
super(Mean, self).__init__()
self.dim = dim
self.keep_dim = keep_dim
def forward(self, input):
return inp... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
assert_size_stride = torch._C._dynamo.guards.a... | tousifulhaque/DANet | Mean | false | 4,484 | [
"MIT"
] | 0 | 1a0c91f0e551a071b5e335b4157313780a8a1b1a | https://github.com/tousifulhaque/DANet/tree/1a0c91f0e551a071b5e335b4157313780a8a1b1a | import torch
from torchvision.datasets import *
import torch.nn as nn
from torchvision.transforms import *
class Model(nn.Module):
def __init__(self, dim, keep_dim=False):
super().__init__()
self.dim = dim
self.keep_dim = keep_dim
def forward(self, input):
return input.mean(s... |
cheap_cnn | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 cheap_cnn(nn.Module):
def __init__(self):
super(cheap_cnn, self).__init__()
self.cnn1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)
self.cnn2 = nn.Conv2d(in_channels=32, out_channels=64, 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_... | vaibhav117/sim2real4real | cheap_cnn | false | 4,485 | [
"MIT"
] | 0 | b1f253ef359eda0c7e3b594f89c8a35f0cf925bf | https://github.com/vaibhav117/sim2real4real/tree/b1f253ef359eda0c7e3b594f89c8a35f0cf925bf | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.cnn1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)
self.cnn2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3)
self.cnn3 = ... |
ZeroCenter | # 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 ZeroCenter(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
"""x : [B, C, H, W]"""
return x.sub_(x.flatten(1).mean(1, keepdim=True).unsqueeze(-1).
unsqueeze(-1))
def get_inputs():
return [torch.rand([4... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@triton.jit
def triton_per_fused_mean_sub_0(in_ptr0,... | vinnamkim/segmentation_models.pytorch | ZeroCenter | false | 4,486 | [
"MIT"
] | 0 | f967ded34df6fb536e8e8cba9b6491ae63b939f5 | https://github.com/vinnamkim/segmentation_models.pytorch/tree/f967ded34df6fb536e8e8cba9b6491ae63b939f5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
"""x : [B, C, H, W]"""
return x.sub_(x.flatten(1).mean(1, keepdim=True).unsqueeze(-1).
unsqueeze(-1))
def get_inputs():
return [torch.rand([4, 4, ... |
EnsembleDense | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class EnsembleDense(nn.Module):
__constants__ = ['num_ensembles', 'in_features', 'out_features']
in_features: 'int'
out_features: 'int'
weight: 'torch.Tensor'
def __init__(self, num_ensembles: 'int', in_features: 'int',
out_features: 'int', 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 math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.as... | vermouth1992/rlutils | EnsembleDense | false | 4,487 | [
"Apache-2.0"
] | 0 | a326373b9e39dbf147c6c4261b82a688d4dc3e78 | https://github.com/vermouth1992/rlutils/tree/a326373b9e39dbf147c6c4261b82a688d4dc3e78 | import math
import torch
from torch import nn
class Model(nn.Module):
__constants__ = ['num_ensembles', 'in_features', 'out_features']
in_features: 'int'
out_features: 'int'
weight: 'torch.Tensor'
def __init__(self, num_ensembles: 'int', in_features: 'int',
out_features: 'int', bias: 'boo... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torchvision.datasets.folder import *
class FocalLoss(nn.Module):
def __init__(self, gamma=0, eps=1e-07):
super(FocalLoss, self).__init__()
self.gamma = gamma
self.eps = eps
self.ce = torch.nn.CrossEntropyLoss()
def forward(self, input, 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 math as tl_math
from torch import nn
f... | tks1998/Pytorch-Face-recongition-state-of-the-art-Qmul-surveface- | FocalLoss | false | 4,488 | [
"MIT"
] | 0 | e4068db0c53a4c6b8e81127191687662806af8d8 | https://github.com/tks1998/Pytorch-Face-recongition-state-of-the-art-Qmul-surveface-/tree/e4068db0c53a4c6b8e81127191687662806af8d8 | import torch
from torch import nn
from torchvision.datasets.folder import *
class Model(nn.Module):
def __init__(self, gamma=0, eps=1e-07):
super().__init__()
self.gamma = gamma
self.eps = eps
self.ce = torch.nn.CrossEntropyLoss()
def forward(self, input, target):
log... |
Simple_AUG | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 import autograd as autograd
import torch.fft
from itertools import product as product
class Simple_AUG(nn.Module):
def __init__(self, in_nc=3, out_nc=3, nf=5):
super(Simple_AUG, self).__init__()
self.c1 = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | varun-jois/KAIR | Simple_AUG | false | 4,489 | [
"MIT"
] | 0 | 90c04671c6eb32a6765edfec94f7db3ba1f53f1e | https://github.com/varun-jois/KAIR/tree/90c04671c6eb32a6765edfec94f7db3ba1f53f1e | import torch
import torch.nn as nn
from torch import autograd as autograd
import torch.fft
from itertools import product as product
class Model(nn.Module):
def __init__(self, in_nc=3, out_nc=3, nf=5):
super().__init__()
self.c1 = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.c2 = nn.Conv2... |
Normalize | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as functional
class Normalize(nn.Module):
def __init__(self, dim: 'int', p: 'int'):
super().__init__()
self.dim = dim
self.p = p
def forward(self, inputs):
outputs = functional.normalize(inputs, dim=self.dim, p=sel... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | uripatish/torchup | Normalize | false | 4,490 | [
"MIT"
] | 0 | 0b7bee031fc99e536342331ba567c523a790d742 | https://github.com/uripatish/torchup/tree/0b7bee031fc99e536342331ba567c523a790d742 | import torch
import torch.nn as nn
import torch.nn.functional as functional
class Model(nn.Module):
def __init__(self, dim: 'int', p: 'int'):
super().__init__()
self.dim = dim
self.p = p
def forward(self, inputs):
outputs = functional.normalize(inputs, dim=self.dim, p=self.p)... |
ProteinBertPooler | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 ProteinBertPooler(nn.Module):
def __init__(self, config):
super().__init__()
self.trainable_encoder = config.trainable_encoder
if self.trainable_encoder:
self.dense = nn.Linear(config.hidden... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | StephanHeijl/tape | ProteinBertPooler | false | 4,491 | [
"BSD-3-Clause"
] | 0 | ec631ca53217686605477cf31af4fb8846ff660f | https://github.com/StephanHeijl/tape/tree/ec631ca53217686605477cf31af4fb8846ff660f | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.trainable_encoder = config.trainable_encoder
if self.trainable_encoder:
self.dense = nn.Linear(config.hidden_size, confi... |
Q | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class Q(nn.Module):
def __init__(self, state_dim, action_dim, hidden):
super(Q, self).__init__()
self.fc1 = nn.Linear(state_dim + action_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
self.fc3 = nn.Linear(hidden... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | victorkich/agaragan | Q | false | 4,492 | [
"MIT"
] | 0 | 64e312fc4fa42f5952f3ce997bafe674306a9419 | https://github.com/victorkich/agaragan/tree/64e312fc4fa42f5952f3ce997bafe674306a9419 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, state_dim, action_dim, hidden):
super().__init__()
self.fc1 = nn.Linear(state_dim + action_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
self.fc3 = nn.Linear(hidden, 1... |
ActorSAC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class ActorSAC(nn.Module):
def __init__(self, state_dim, hidden, min_log_std=-20, max_log_std=2):
super(ActorSAC, self).__init__()
self.fc1 = nn.Linear(state_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
self.m... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | victorkich/agaragan | ActorSAC | false | 4,493 | [
"MIT"
] | 0 | 64e312fc4fa42f5952f3ce997bafe674306a9419 | https://github.com/victorkich/agaragan/tree/64e312fc4fa42f5952f3ce997bafe674306a9419 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, state_dim, hidden, min_log_std=-20, max_log_std=2):
super().__init__()
self.fc1 = nn.Linear(state_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
self.mu_head = nn.Linea... |
PAM_Module | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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.serialization
import torch
import torch.utils.data
from torch.nn import Conv2d
from torch.nn import Parameter
from torch.nn import Softmax
class PAM_Module(Module):
""" Position attention module"""
def __init__(self, in_dim):
super(PAM_Module, sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | vis-opt-group/GTANet | PAM_Module | false | 4,494 | [
"MIT"
] | 0 | 269ff4418ee5f0267987e1fa4c69bda13e5cb00d | https://github.com/vis-opt-group/GTANet/tree/269ff4418ee5f0267987e1fa4c69bda13e5cb00d | from torch.nn import Module
import torch
import torch.serialization
import torch
import torch.utils.data
from torch.nn import Conv2d
from torch.nn import Parameter
from torch.nn import Softmax
class Model(Module):
""" Position attention module"""
def __init__(self, in_dim):
super().__init__()
... |
SE_layer_3d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.multiprocessing
class SE_layer_3d(nn.Module):
def __init__(self, num_channels, reduction_ratio=2):
super(SE_layer_3d, self).__init__()
num_channels_reduced = num_channels // reduction_ratio
self.reduction_ratio = reduction_ratio
self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | vinbigdata-medical/abdomen-phases | SE_layer_3d | false | 4,495 | [
"MIT"
] | 0 | 4adf5b8bf13aec85247d74e3cd3789c52cb88b92 | https://github.com/vinbigdata-medical/abdomen-phases/tree/4adf5b8bf13aec85247d74e3cd3789c52cb88b92 | import torch
import torch.nn as nn
import torch.multiprocessing
class Model(nn.Module):
def __init__(self, num_channels, reduction_ratio=2):
super().__init__()
num_channels_reduced = num_channels // reduction_ratio
self.reduction_ratio = reduction_ratio
self.fc1 = nn.Linear(num_ch... |
Mean | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class Mean(nn.Module):
def __init__(self, *args):
super(Mean, self).__init__()
self.shape = args
def forward(self, x):
return x.mean(self.shape)
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
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | vitskvara/shape-guided-anomaly-detection | Mean | false | 4,496 | [
"MIT"
] | 0 | 6685b2e0b97968a6d0f478d2920486da107b277f | https://github.com/vitskvara/shape-guided-anomaly-detection/tree/6685b2e0b97968a6d0f478d2920486da107b277f | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, *args):
super().__init__()
self.shape = args
def forward(self, x):
return x.mean(self.shape)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
HighwayLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.onnx.operators
class HighwayLayer(nn.Module):
def __init__(self, input_dim, transform_activation=F.relu,
gate_activation=F.softmax, gate_bias=-2):
super().__init__()
self.highway_transform_activation = transfo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | vincentLiangBerkeley/translate | HighwayLayer | false | 4,497 | [
"BSD-3-Clause"
] | 0 | 734ae1ad9dfb778935e4825b5ce2687e2df559ea | https://github.com/vincentLiangBerkeley/translate/tree/734ae1ad9dfb778935e4825b5ce2687e2df559ea | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx.operators
class Model(nn.Module):
def __init__(self, input_dim, transform_activation=F.relu,
gate_activation=F.softmax, gate_bias=-2):
super().__init__()
self.highway_transform_activation = transform_acti... |
Patch2Image | # 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 Patch2Image(nn.Module):
""" take in patch and copy n_up times to form the full image"""
def __init__(self, patch_sz, n_up):
super(Patch2Image, self).__init__()
self.patch_sz = patch_sz
self.n_up = n_up
def forward(self, x):
assert x... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | vitskvara/shape-guided-anomaly-detection | Patch2Image | false | 4,498 | [
"MIT"
] | 0 | 6685b2e0b97968a6d0f478d2920486da107b277f | https://github.com/vitskvara/shape-guided-anomaly-detection/tree/6685b2e0b97968a6d0f478d2920486da107b277f | import torch
from torch import nn
class Model(nn.Module):
""" take in patch and copy n_up times to form the full image"""
def __init__(self, patch_sz, n_up):
super().__init__()
self.patch_sz = patch_sz
self.n_up = n_up
def forward(self, x):
assert x.shape[-1
]... |
Feature | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.serialization
import torch
import torch.utils.data
class ResBlock(torch.nn.Module):
def __init__(self):
super(ResBlock, self).__init__()
self.conv1 = torch.nn.Conv2d(in_channels=64, out_channels=64,
kernel_size=3, stride=1, padding=1)
self.conv2 = tor... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.serialization
im... | vis-opt-group/GTANet | Feature | false | 4,499 | [
"MIT"
] | 0 | 269ff4418ee5f0267987e1fa4c69bda13e5cb00d | https://github.com/vis-opt-group/GTANet/tree/269ff4418ee5f0267987e1fa4c69bda13e5cb00d | import torch
import torch.serialization
import torch
import torch.utils.data
class ResBlock(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(in_channels=64, out_channels=64,
kernel_size=3, stride=1, padding=1)
self.conv2 = torch.nn.Conv2d(i... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.