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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
UpSample | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 UpSample(nn.Sequential):
def __init__(self, skip_input, output_features):
super(UpSample, self).__init__()
self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3,
stride=1, padding=1)
self.leak... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | varun-affinsys/Monocular-Depth-Estimation-with-Transfer-Learning-pretrained-MobileNetV2 | UpSample | false | 16,669 | [
"MIT"
] | 70 | 9b20c5b3d7a9f90e1dc6f40e17ee31d9b3dee684 | https://github.com/varun-affinsys/Monocular-Depth-Estimation-with-Transfer-Learning-pretrained-MobileNetV2/tree/9b20c5b3d7a9f90e1dc6f40e17ee31d9b3dee684 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Sequential):
def __init__(self, skip_input, output_features):
super().__init__()
self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3,
stride=1, padding=1)
self.leakyreluA = nn.Leaky... |
GTConv_2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
from torch import nn
import torch.utils.data
import torch.onnx.operators
import torch.optim
import torch.optim.lr_scheduler
class GTConv_2(nn.Module):
def __init__(self, in_channels, out_channels):
super(GTConv_2, self).__init__()
self.in_channels = 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
from torch import nn
i... | verashira/TSPNet | GTConv_2 | false | 16,670 | [
"MIT"
] | 83 | ee454165dcc61cdbbff19565364e2221727ed2b8 | https://github.com/verashira/TSPNet/tree/ee454165dcc61cdbbff19565364e2221727ed2b8 | import torch
import torch.nn.functional as F
from torch import nn
import torch.utils.data
import torch.onnx.operators
import torch.optim
import torch.optim.lr_scheduler
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.in_channels = in_channels
... |
TemporalBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.onnx.operators
import torch.optim
import torch.optim.lr_scheduler
def TemporalConvLayer(input_channels, output_channels, kernel_size):
m = nn.Conv1d(in_channels=input_channels, out_channels=output_channels,
kernel_size=kernel_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
import t... | verashira/TSPNet | TemporalBlock | false | 16,671 | [
"MIT"
] | 83 | ee454165dcc61cdbbff19565364e2221727ed2b8 | https://github.com/verashira/TSPNet/tree/ee454165dcc61cdbbff19565364e2221727ed2b8 | import torch
from torch import nn
import torch.utils.data
import torch.onnx.operators
import torch.optim
import torch.optim.lr_scheduler
def TemporalConvLayer(input_channels, output_channels, kernel_size):
m = nn.Conv1d(in_channels=input_channels, out_channels=output_channels,
kernel_size=kernel_size)
... |
SoftmaxAllocator | # 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 SoftmaxAllocator(torch.nn.Module):
"""Portfolio creation by computing a softmax over the asset dimension with temperature.
Parameters
----------
temperature : None or float
If None, then needs to be provided per sample during forward pass. If ``float`` then assumed
... | 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... | vishalbelsare/deepdow | SoftmaxAllocator | false | 16,672 | [
"Apache-2.0"
] | 511 | cbb99347fba9a447d4fcae64fe5137c203643e44 | https://github.com/vishalbelsare/deepdow/tree/cbb99347fba9a447d4fcae64fe5137c203643e44 | import torch
class Model(torch.nn.Module):
"""Portfolio creation by computing a softmax over the asset dimension with temperature.
Parameters
----------
temperature : None or float
If None, then needs to be provided per sample during forward pass. If ``float`` then assumed
to be alway... |
TransformerEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.utils.data
import torch.distributions
class TransformerEncoderLayer(nn.Module):
def __init__(self, embed_dim, num_heads, hidden_size, dropout=0.0,
attention_dropout=0.0, activation_dropout=0.0):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | vengalraoguttha/EGG | TransformerEncoderLayer | false | 16,673 | [
"MIT"
] | 254 | e4f8412f197543ec7f1f00cf89b5a364b038dc57 | https://github.com/vengalraoguttha/EGG/tree/e4f8412f197543ec7f1f00cf89b5a364b038dc57 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.utils.data
import torch.distributions
class Model(nn.Module):
def __init__(self, embed_dim, num_heads, hidden_size, dropout=0.0,
attention_dropout=0.0, activation_dropout=0.0):
super().__init_... |
SpatialCrossMapLRN | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.parallel
class SpatialCrossMapLRN(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, k=1,
ACROSS_CHANNELS=True):
super(SpatialCrossMapLRN, self).__init__()
self.ACROSS_CHANNELS = ACROSS_CHANNELS
if ACROSS_CHANNELS:... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.nn.parallel
assert_size_stride = torch._C._d... | vfdev-5/models-comparison.pytorch | SpatialCrossMapLRN | false | 16,674 | [
"BSD-3-Clause"
] | 174 | 6a09c41c1ed6160af0734924700a9150249c3df6 | https://github.com/vfdev-5/models-comparison.pytorch/tree/6a09c41c1ed6160af0734924700a9150249c3df6 | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, k=1,
ACROSS_CHANNELS=True):
super().__init__()
self.ACROSS_CHANNELS = ACROSS_CHANNELS
if ACROSS_CHANNELS:
self.average = nn.AvgPoo... |
Symmetric | # 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 NonSquareError(ValueError):
def __init__(self, name, size):
super().__init__(
'The {} parametrization can just be applied to square matrices. Got a tensor of size {}'
.format(name, size))
class VectorError(ValueError):
def __init__(se... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | vishalbelsare/geotorch | Symmetric | false | 16,675 | [
"MIT"
] | 422 | ba38d406c245d609fee4b4dac3f6427bf6d73a8e | https://github.com/vishalbelsare/geotorch/tree/ba38d406c245d609fee4b4dac3f6427bf6d73a8e | import torch
from torch import nn
class NonSquareError(ValueError):
def __init__(self, name, size):
super().__init__(
'The {} parametrization can just be applied to square matrices. Got a tensor of size {}'
.format(name, size))
class VectorError(ValueError):
def __init__(se... |
Cov2Corr | # 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 Cov2Corr(nn.Module):
"""Conversion from covariance matrix to correlation matrix."""
def forward(self, covmat):
"""Convert.
Parameters
----------
covmat : torch.Tensor
Covariance matrix of shape (n_samples, n_assets, n_asset... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | vishalbelsare/deepdow | Cov2Corr | false | 16,676 | [
"Apache-2.0"
] | 511 | cbb99347fba9a447d4fcae64fe5137c203643e44 | https://github.com/vishalbelsare/deepdow/tree/cbb99347fba9a447d4fcae64fe5137c203643e44 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Conversion from covariance matrix to correlation matrix."""
def forward(self, covmat):
"""Convert.
Parameters
----------
covmat : torch.Tensor
Covariance matrix of shape (n_samples, n_assets, n_assets).... |
InformedSender | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.nn.parallel
import torch.utils.data
import torch.distributions
class InformedSender(nn.Module):
def __init__(self, game_size, feat_size, embedding_size, hidden_size,
vocab_size=100, temp=1.0):
super(InformedSender, se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | vengalraoguttha/EGG | InformedSender | false | 16,677 | [
"MIT"
] | 254 | e4f8412f197543ec7f1f00cf89b5a364b038dc57 | https://github.com/vengalraoguttha/EGG/tree/e4f8412f197543ec7f1f00cf89b5a364b038dc57 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.utils.data
import torch.distributions
class Model(nn.Module):
def __init__(self, game_size, feat_size, embedding_size, hidden_size,
vocab_size=100, temp=1.0):
super().__init__()
self.g... |
Skew | # 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 NonSquareError(ValueError):
def __init__(self, name, size):
super().__init__(
'The {} parametrization can just be applied to square matrices. Got a tensor of size {}'
.format(name, size))
class VectorError(ValueError):
def __init__(se... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | vishalbelsare/geotorch | Skew | false | 16,678 | [
"MIT"
] | 422 | ba38d406c245d609fee4b4dac3f6427bf6d73a8e | https://github.com/vishalbelsare/geotorch/tree/ba38d406c245d609fee4b4dac3f6427bf6d73a8e | import torch
from torch import nn
class NonSquareError(ValueError):
def __init__(self, name, size):
super().__init__(
'The {} parametrization can just be applied to square matrices. Got a tensor of size {}'
.format(name, size))
class VectorError(ValueError):
def __init__(se... |
Naked | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
class Naked(Module):
"""Returns a tensor filled with the scalar value zero.
Args:
out_features (int, default=1): Size of each output sample.
Shape:
- Input: :math:`(N, *, H_{\\text{in}})` where
:math:`*` means an... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._em... | vishalbelsare/pfhedge | Naked | false | 16,679 | [
"MIT"
] | 81 | 4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | https://github.com/vishalbelsare/pfhedge/tree/4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | from torch.nn import Module
import torch
from torch import Tensor
class Model(Module):
"""Returns a tensor filled with the scalar value zero.
Args:
out_features (int, default=1): Size of each output sample.
Shape:
- Input: :math:`(N, *, H_{\\text{in}})` where
:math:`*` means an... |
GatingMechanism | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class GatingMechanism(torch.nn.Module):
def __init__(self, d_input, bg=0.1):
super(GatingMechanism, self).__init__()
self.Wr = torch.nn.Linear(d_input, d_input)
self.Ur = torch.nn.Linear(d_input, d_input)
self.Wz = torch.nn.Linear(d_input, d_input)
self.Uz = 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.triton_helpers import libdevice
assert_size_stride ... | victor-psiori/Transformers-RL | GatingMechanism | false | 16,680 | [
"MIT"
] | 50 | 85b3f2376ba473a45ca18c969aebb1ae82cf8475 | https://github.com/victor-psiori/Transformers-RL/tree/85b3f2376ba473a45ca18c969aebb1ae82cf8475 | import torch
class Model(torch.nn.Module):
def __init__(self, d_input, bg=0.1):
super().__init__()
self.Wr = torch.nn.Linear(d_input, d_input)
self.Ur = torch.nn.Linear(d_input, d_input)
self.Wz = torch.nn.Linear(d_input, d_input)
self.Uz = torch.nn.Linear(d_input, d_input... |
EntropicLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
from typing import Callable
from typing import Union
from abc import ABC
def _format_float(value: 'float') ->str:
"""
>>> _format_float(1)
'1'
>>> _format_float(1.0)
'1.'
>>> _format_float(1e-4)
'1.0000e-04'
"""
tens... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch.nn import Module
from torch import Tensor
from typing import C... | vishalbelsare/pfhedge | EntropicLoss | false | 16,681 | [
"MIT"
] | 81 | 4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | https://github.com/vishalbelsare/pfhedge/tree/4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | from torch.nn import Module
import torch
from torch import Tensor
from typing import Callable
from typing import Union
from abc import ABC
def _format_float(value: 'float') ->str:
"""
>>> _format_float(1)
'1'
>>> _format_float(1.0)
'1.'
>>> _format_float(1e-4)
'1.0000e-04'
"""
tens... |
ActorNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 ActorNetwork(nn.Module):
def __init__(self, state_size, action_size, hidden_size, seed=1412):
super(ActorNetwork, self).__init__()
self.seed = torch.manual_seed(seed)
self.fc1 = nn.Linear(state_size, hidden_size)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | vlgiitr/Workshop-Spring-2022 | ActorNetwork | false | 16,682 | [
"MIT"
] | 69 | 003ed62c75a876e946eaa481c27224dd38914015 | https://github.com/vlgiitr/Workshop-Spring-2022/tree/003ed62c75a876e946eaa481c27224dd38914015 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_size, action_size, hidden_size, seed=1412):
super().__init__()
self.seed = torch.manual_seed(seed)
self.fc1 = nn.Linear(state_size, hidden_size)
self.fc2 = nn.Linear... |
SphereEmbedded | # 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
def _extra_repr(**kwargs):
if 'n' in kwargs:
ret = 'n={}'.format(kwargs['n'])
elif 'dim' in kwargs:
ret = 'dim={}'.format(kwargs['dim'])
else:
ret = ''
if 'k' in kwargs:
ret += ', k={}'.format(kwargs['k'])
if 'rank' in kwargs:
... | 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... | vishalbelsare/geotorch | SphereEmbedded | false | 16,683 | [
"MIT"
] | 422 | ba38d406c245d609fee4b4dac3f6427bf6d73a8e | https://github.com/vishalbelsare/geotorch/tree/ba38d406c245d609fee4b4dac3f6427bf6d73a8e | import torch
from torch import nn
def _extra_repr(**kwargs):
if 'n' in kwargs:
ret = 'n={}'.format(kwargs['n'])
elif 'dim' in kwargs:
ret = 'dim={}'.format(kwargs['dim'])
else:
ret = ''
if 'k' in kwargs:
ret += ', k={}'.format(kwargs['k'])
if 'rank' in kwargs:
... |
Decoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 collections import OrderedDict
class Decoder(nn.Module):
def __init__(self, style_dim, class_dim):
super(Decoder, self).__init__()
self.linear_model = nn.Sequential(OrderedDict([('linear_1', nn.
Linear(in_features=style_dim + class_dim, out_feat... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | vicissitude1999/multi-level-vae | Decoder | false | 16,684 | [
"MIT"
] | 68 | 83bc98fbe5046c61941298d4fd49b08fd868ee89 | https://github.com/vicissitude1999/multi-level-vae/tree/83bc98fbe5046c61941298d4fd49b08fd868ee89 | import torch
import torch.nn as nn
from collections import OrderedDict
class Model(nn.Module):
def __init__(self, style_dim, class_dim):
super().__init__()
self.linear_model = nn.Sequential(OrderedDict([('linear_1', nn.
Linear(in_features=style_dim + class_dim, out_features=500,
... |
MixtureDensityHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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
from torch.autograd import Variable
from torch.distributions import Categorical
class MixtureDensityHead(nn.Module):
def __init__(self, config: 'DictConfig', **kwargs):
self.hparams = config
super().__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | robburdon/pytorch_tabular | MixtureDensityHead | false | 16,685 | [
"MIT"
] | 560 | 9bf75f22c6e1b3033ad699713e77c283d55f3555 | https://github.com/robburdon/pytorch_tabular/tree/9bf75f22c6e1b3033ad699713e77c283d55f3555 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch.distributions import Categorical
class Model(nn.Module):
def __init__(self, config: 'DictConfig', **kwargs):
self.hparams = config
super().__init__()
self._build... |
EntropicRiskMeasure | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
from typing import Callable
from typing import Union
from abc import ABC
def _format_float(value: 'float') ->str:
"""
>>> _format_float(1)
'1'
>>> _format_float(1.0)
'1.'
>>> _format_float(1e-4)
'1.0000e-04'
"""
tens... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch.nn import Module
from torch import Tensor
from typing import C... | vishalbelsare/pfhedge | EntropicRiskMeasure | false | 16,686 | [
"MIT"
] | 81 | 4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | https://github.com/vishalbelsare/pfhedge/tree/4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | from torch.nn import Module
import torch
from torch import Tensor
from typing import Callable
from typing import Union
from abc import ABC
def _format_float(value: 'float') ->str:
"""
>>> _format_float(1)
'1'
>>> _format_float(1.0)
'1.'
>>> _format_float(1e-4)
'1.0000e-04'
"""
tens... |
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 Tensor
from torch import nn
import torch.nn.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:
'fl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 Tensor
from... | vipavlovic/pyprobml | VectorQuantizer | false | 16,687 | [
"MIT"
] | 4,895 | 59a2edc682d0163955db5e2f27491ad772b60141 | https://github.com/vipavlovic/pyprobml/tree/59a2edc682d0163955db5e2f27491ad772b60141 | import torch
from torch import Tensor
from torch import nn
import torch.nn.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)... |
Warp | # 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 Warp(torch.nn.Module):
"""Custom warping layer."""
def __init__(self, mode='bilinear', padding_mode='reflection'):
super().__init__()
self.mode = mode
self.padding_mode = padding_mode
def forward(self, x, tform):
"""Warp the tensor... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
assert_size... | vishalbelsare/deepdow | Warp | false | 16,688 | [
"Apache-2.0"
] | 511 | cbb99347fba9a447d4fcae64fe5137c203643e44 | https://github.com/vishalbelsare/deepdow/tree/cbb99347fba9a447d4fcae64fe5137c203643e44 | import torch
import torch.nn as nn
class Model(torch.nn.Module):
"""Custom warping layer."""
def __init__(self, mode='bilinear', padding_mode='reflection'):
super().__init__()
self.mode = mode
self.padding_mode = padding_mode
def forward(self, x, tform):
"""Warp the tenso... |
BertLayerNormNoVar | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class BertLayerNormNoVar(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
super(BertLayerNormNoVar, self).__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.bias = nn.Parameter(torch.zeros(hidden_size))
self.variance_epsil... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | vtu81/auto_LiRPA | BertLayerNormNoVar | false | 16,689 | [
"BSD-3-Clause"
] | 161 | 294152077c0abfafb5d62fee39335e60eff087b4 | https://github.com/vtu81/auto_LiRPA/tree/294152077c0abfafb5d62fee39335e60eff087b4 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size, eps=1e-12):
super().__init__()
self.weight = nn.Parameter(torch.ones(hidden_size))
self.bias = nn.Parameter(torch.zeros(hidden_size))
self.variance_epsilon = eps
def forward(self, x):
... |
ExpectedShortfall | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
from typing import Callable
from typing import Union
from typing import Optional
from abc import ABC
from math import ceil
def bisect(fn: 'Callable[[Tensor], Tensor]', target: 'Tensor', lower:
'Union[float, Tensor]', upper: 'Union[float, Tensor]', ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
from torch import Tensor
from typing import Callable
from typing import Union
from typing import Optional
from a... | vishalbelsare/pfhedge | ExpectedShortfall | false | 16,690 | [
"MIT"
] | 81 | 4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | https://github.com/vishalbelsare/pfhedge/tree/4d7ff173995e0795942bc6ec55f3fdc5bfb7a5f1 | from torch.nn import Module
import torch
from torch import Tensor
from typing import Callable
from typing import Union
from typing import Optional
from abc import ABC
from math import ceil
def bisect(fn: 'Callable[[Tensor], Tensor]', target: 'Tensor', lower:
'Union[float, Tensor]', upper: 'Union[float, Tensor]', ... |
MultiHeadDenseLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 tensorflow as tf
import torch.nn as nn
import torch.nn.functional as F
def get_activation(activ):
if callable(activ):
return activ
if activ is None:
return lambda x: x
if activ == 'tanh':
return F.tanh
elif activ == 'relu':
return F.relu
elif act... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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 tensorflow as tf
import torch.nn as nn
import torch.nn.functional as F
as... | ishine/neurst | MultiHeadDenseLayer | false | 16,691 | [
"Apache-2.0"
] | 208 | 2ba322393fcfed4261b33f4a657e12bbe321baaa | https://github.com/ishine/neurst/tree/2ba322393fcfed4261b33f4a657e12bbe321baaa | import torch
import tensorflow as tf
import torch.nn as nn
import torch.nn.functional as F
def get_activation(activ):
if callable(activ):
return activ
if activ is None:
return lambda x: x
if activ == 'tanh':
return F.tanh
elif activ == 'relu':
return F.relu
elif act... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from matplotlib.font_manager import *
class FocalLoss(nn.Module):
"""
Focal loss: focus more on hard samples
"""
def __init__(self, gamma=0, eps=1e-07):
"""
:param gamma:
:param eps:
"""
super(FocalLoss, self).__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | wang-tf/RepNet-MDNet-VehicleReID | FocalLoss | false | 16,692 | [
"MIT"
] | 226 | d3d184331206ca4bdb5ea399e5b90a9ccc53b400 | https://github.com/wang-tf/RepNet-MDNet-VehicleReID/tree/d3d184331206ca4bdb5ea399e5b90a9ccc53b400 | import torch
import torch.nn as nn
from matplotlib.font_manager import *
class Model(nn.Module):
"""
Focal loss: focus more on hard samples
"""
def __init__(self, gamma=0, eps=1e-07):
"""
:param gamma:
:param eps:
"""
super().__init__()
self.gamma = gam... |
L1DepthLoss | # 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 _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class L1DepthLoss(nn.Module):
"""Custom L1 loss for depth sequences."""
def __init__(self, args):
super(L1DepthLoss, self).__init__()
self.args = args
self.word_dim = 1
def forward(self, predictions,... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | wanyao1992/structural-probes | L1DepthLoss | false | 16,693 | [
"Apache-2.0"
] | 357 | 3071c93b23601d834628d79a74e46e8ab5e5a66b | https://github.com/wanyao1992/structural-probes/tree/3071c93b23601d834628d79a74e46e8ab5e5a66b | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
"""Custom L1 loss for depth sequences."""
def __init__(self, args):
super().__init__()
self.args = args
self.word_dim = 1
def forward(self, predictions, label_batch, length_ba... |
HLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
from torch import nn
class HLoss(nn.Module):
"""
returning the negative entropy of an input tensor
"""
def __init__(self, is_maximization=False):
super(HLoss, self).__init__()
self.is_neg = is_maximization
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 import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
a... | vt-vl-lab/SDN | HLoss | false | 16,694 | [
"MIT"
] | 88 | d1f0a448acf720b9b86527f808cb17d30ed2f4e9 | https://github.com/vt-vl-lab/SDN/tree/d1f0a448acf720b9b86527f808cb17d30ed2f4e9 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
"""
returning the negative entropy of an input tensor
"""
def __init__(self, is_maximization=False):
super().__init__()
self.is_neg = is_maximization
def forward(self, x):
b = F.... |
Align | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class Align(torch.nn.Module):
def __init__(self, p):
super(Align, self).__init__()
self.p = p
def forward(self, e1, e2):
pred = -torch.norm(e1 - e2, p=self.p, dim=1)
return pred
def only_pos_loss(self, e1, r, e2):
retu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn.functional as F
assert_size_stride = torch._C._dynamo.guards.as... | weihangzhang/EAkit | Align | false | 16,695 | [
"MIT"
] | 102 | dde8e914480cd1a3585271f70db11d567d9c2a04 | https://github.com/weihangzhang/EAkit/tree/dde8e914480cd1a3585271f70db11d567d9c2a04 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self, p):
super().__init__()
self.p = p
def forward(self, e1, e2):
pred = -torch.norm(e1 - e2, p=self.p, dim=1)
return pred
def only_pos_loss(self, e1, r, e2):
return -F.logsi... |
N_TransE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class N_TransE(torch.nn.Module):
def __init__(self, p, params):
super(N_TransE, self).__init__()
self.p = p
self.params = params
def forward(self, e1, r, e2):
pred = -torch.norm(e1 + r - e2, p=self.p, dim=1)
return pred
... | 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.functional as F
assert_size_stride = torch._C._dynamo.guards.as... | weihangzhang/EAkit | N_TransE | false | 16,696 | [
"MIT"
] | 102 | dde8e914480cd1a3585271f70db11d567d9c2a04 | https://github.com/weihangzhang/EAkit/tree/dde8e914480cd1a3585271f70db11d567d9c2a04 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self, p, params):
super().__init__()
self.p = p
self.params = params
def forward(self, e1, r, e2):
pred = -torch.norm(e1 + r - e2, p=self.p, dim=1)
return pred
def loss(self, ... |
L1DistanceLoss | # 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 _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class L1DistanceLoss(nn.Module):
"""Custom L1 loss for distance matrices."""
def __init__(self, args):
super(L1DistanceLoss, self).__init__()
self.args = args
self.word_pair_dims = 1, 2
def forward(s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | wanyao1992/structural-probes | L1DistanceLoss | false | 16,697 | [
"Apache-2.0"
] | 357 | 3071c93b23601d834628d79a74e46e8ab5e5a66b | https://github.com/wanyao1992/structural-probes/tree/3071c93b23601d834628d79a74e46e8ab5e5a66b | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
"""Custom L1 loss for distance matrices."""
def __init__(self, args):
super().__init__()
self.args = args
self.word_pair_dims = 1, 2
def forward(self, predictions, label_batch... |
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
class LayerNorm(torch.nn.Module):
def __init__(self, input_dim):
super(LayerNorm, self).__init__()
self.gamma = torch.nn.Parameter(torch.ones(input_dim))
self.beta = torch.nn.Parameter(torch.zeros(input_dim))
self.eps = 1e-06
def forward(self, x, mask):
m... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | watchernyu/MatchLSTM-Analyze-Adversarial-Training | LayerNorm | false | 16,698 | [
"MIT"
] | 50 | 00bd33d3dd22d5291dc2c1ec5feef5eb93b59b3a | https://github.com/watchernyu/MatchLSTM-Analyze-Adversarial-Training/tree/00bd33d3dd22d5291dc2c1ec5feef5eb93b59b3a | import torch
class Model(torch.nn.Module):
def __init__(self, input_dim):
super().__init__()
self.gamma = torch.nn.Parameter(torch.ones(input_dim))
self.beta = torch.nn.Parameter(torch.zeros(input_dim))
self.eps = 1e-06
def forward(self, x, mask):
mean = x.mean(-1, ke... |
StructuredAttention_bi | # 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 StructuredAttention_bi(nn.Module):
def __init__(self, dropout=0.1, scale=100):
super(StructuredAttention_bi, self).__init__()
self.dropout = dropout
self.scale = scale
def forward(self, C, Q, c_mask, q_mask):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | vivekrajput566/03testing2022 | StructuredAttention_bi | false | 16,699 | [
"MIT"
] | 49 | f7e04f921c6607d383806ca2bbb85d2de84e0369 | https://github.com/vivekrajput566/03testing2022/tree/f7e04f921c6607d383806ca2bbb85d2de84e0369 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dropout=0.1, scale=100):
super().__init__()
self.dropout = dropout
self.scale = scale
def forward(self, C, Q, c_mask, q_mask):
_bsz, _, _num_img, _num_region, _hsz = ... |
AlignEA | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class AlignEA(torch.nn.Module):
def __init__(self, p, feat_drop, params):
super(AlignEA, self).__init__()
self.params = params
def forward(self, e1, r, e2):
return torch.sum(torch.pow(e1 + r - e2, 2), 1)
def only_pos_loss(self, e1, r,... | 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.functional as F
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards... | weihangzhang/EAkit | AlignEA | false | 16,700 | [
"MIT"
] | 102 | dde8e914480cd1a3585271f70db11d567d9c2a04 | https://github.com/weihangzhang/EAkit/tree/dde8e914480cd1a3585271f70db11d567d9c2a04 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self, p, feat_drop, params):
super().__init__()
self.params = params
def forward(self, e1, r, e2):
return torch.sum(torch.pow(e1 + r - e2, 2), 1)
def only_pos_loss(self, e1, r, e2):
r... |
N_R_Align | # 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 N_R_Align(torch.nn.Module):
def __init__(self, params):
super(N_R_Align, self).__init__()
self.params = params
self.cos_sim = nn.CosineSimilarity(dim=1, eps=1e-06)
def forward(self, e1, e2, n1, n2):
return self.params * torch.sigmoid(s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | weihangzhang/EAkit | N_R_Align | false | 16,701 | [
"MIT"
] | 102 | dde8e914480cd1a3585271f70db11d567d9c2a04 | https://github.com/weihangzhang/EAkit/tree/dde8e914480cd1a3585271f70db11d567d9c2a04 | import torch
import torch.nn as nn
class Model(torch.nn.Module):
def __init__(self, params):
super().__init__()
self.params = params
self.cos_sim = nn.CosineSimilarity(dim=1, eps=1e-06)
def forward(self, e1, e2, n1, n2):
return self.params * torch.sigmoid(self.cos_sim(n1, n2)... |
HLoss | # 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 HLoss(nn.Module):
def __init__(self):
super(HLoss, self).__init__()
def forward(self, x):
b = x * torch.log(x)
b[torch.isnan(b)] = 0
b = -1.0 * b.sum()
return b
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def ge... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | wengong-jin/chemprop | HLoss | false | 16,702 | [
"MIT"
] | 77 | 3ad3577367d8a53f28aade0be41b56b1f25b6125 | https://github.com/wengong-jin/chemprop/tree/3ad3577367d8a53f28aade0be41b56b1f25b6125 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
b = x * torch.log(x)
b[torch.isnan(b)] = 0
b = -1.0 * b.sum()
return b
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inpu... |
depthwise_block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class depthwise_conv(nn.Module):
def __init__(self, kernel_size=3, stride=1, padding=1):
super(depthwise_conv, self).__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=kernel_size, stride=
stride, padding=padding)
de... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | whiteking64/lang-seg | depthwise_block | false | 16,703 | [
"MIT"
] | 202 | 9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | https://github.com/whiteking64/lang-seg/tree/9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | import torch
import torch.nn as nn
import torch.utils.data
class depthwise_conv(nn.Module):
def __init__(self, kernel_size=3, stride=1, padding=1):
super().__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=kernel_size, stride=
stride, padding=padding)
def forward(self, x):
... |
AttentionCollapse | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AttentionCollapse(nn.Module):
"""Collapsing over the channels with attention.
Parameters
----------
n_channels : int
Number of input channels.
Attributes
----------
affine : nn.Module
Fully connected layer performing linear mapping... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | vishalbelsare/deepdow | AttentionCollapse | false | 16,704 | [
"Apache-2.0"
] | 511 | cbb99347fba9a447d4fcae64fe5137c203643e44 | https://github.com/vishalbelsare/deepdow/tree/cbb99347fba9a447d4fcae64fe5137c203643e44 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Collapsing over the channels with attention.
Parameters
----------
n_channels : int
Number of input channels.
Attributes
----------
affine : nn.Module
Fully connected layer performing linear mapping.
conte... |
Gating | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Gating(nn.Module):
"""
FCN architecture for large scale scene coordiante regression.
"""
def __init__(self, num_experts, capacity=1):
"""
Constructor.
"""
super(Gating, self).__init__()
self.capacity = cap... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | vislearn/esac | Gating | false | 16,705 | [
"BSD-3-Clause"
] | 62 | 4004b251525fa238a1cb6e1043fb41a4719a4ff2 | https://github.com/vislearn/esac/tree/4004b251525fa238a1cb6e1043fb41a4719a4ff2 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
FCN architecture for large scale scene coordiante regression.
"""
def __init__(self, num_experts, capacity=1):
"""
Constructor.
"""
super().__init__()
self.capacity = capacity
... |
LearnedKernel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 LearnedKernel(nn.Module):
def __init__(self, args: 'Namespace'):
super(LearnedKernel, self).__init__()
self.A = nn.Linear(args.ffn_hidden_size, args.ffn_hidden_size)
def forward(self, encodings: 'torch.Ten... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | wengong-jin/chemprop | LearnedKernel | false | 16,706 | [
"MIT"
] | 77 | 3ad3577367d8a53f28aade0be41b56b1f25b6125 | https://github.com/wengong-jin/chemprop/tree/3ad3577367d8a53f28aade0be41b56b1f25b6125 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, args: 'Namespace'):
super().__init__()
self.A = nn.Linear(args.ffn_hidden_size, args.ffn_hidden_size)
def forward(self, encodings: 'torch.Tensor'):
return (self... |
depthwise_clipseg_conv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 depthwise_clipseg_conv(nn.Module):
def __init__(self):
super(depthwise_clipseg_conv, self).__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=3, padding=1)
def depthwise_clipseg(self, x, channels):
x = torch.cat([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.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | whiteking64/lang-seg | depthwise_clipseg_conv | false | 16,707 | [
"MIT"
] | 202 | 9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | https://github.com/whiteking64/lang-seg/tree/9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=3, padding=1)
def depthwise_clipseg(self, x, channels):
x = torch.cat([self.depthwise(x[:, i].unsqueeze(1)) for i in ... |
SAModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SAModule(nn.Module):
"""Spatial Attention Module"""
def __init__(self):
super(SAModule, self).__init__()
self.conv = nn.Conv2d(2, 1, kernel_size=3, padding=1, bias=False)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
input = x
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | whkwls2653/Pytorch_Face_Recognition- | SAModule | false | 16,708 | [
"MIT"
] | 62 | 60f3849def589957d9080457a1a9833112a71f6c | https://github.com/whkwls2653/Pytorch_Face_Recognition-/tree/60f3849def589957d9080457a1a9833112a71f6c | import torch
import torch.nn as nn
class Model(nn.Module):
"""Spatial Attention Module"""
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(2, 1, kernel_size=3, padding=1, bias=False)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
input = x
avg_c = t... |
BoundaryDecoderAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def masked_softmax(x, m=None, axis=-1):
"""
Softmax with mask (optional)
"""
x = torch.clamp(x, min=-15.0, max=15.0)
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=axis, keepdim=True)[0])
if m is not None:
e_x = e_x * m
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | watchernyu/MatchLSTM-Analyze-Adversarial-Training | BoundaryDecoderAttention | false | 16,709 | [
"MIT"
] | 50 | 00bd33d3dd22d5291dc2c1ec5feef5eb93b59b3a | https://github.com/watchernyu/MatchLSTM-Analyze-Adversarial-Training/tree/00bd33d3dd22d5291dc2c1ec5feef5eb93b59b3a | import torch
def masked_softmax(x, m=None, axis=-1):
"""
Softmax with mask (optional)
"""
x = torch.clamp(x, min=-15.0, max=15.0)
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=axis, keepdim=True)[0])
if m is not None:
e_x = e_x * m
... |
VertexConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Transform(nn.Module):
"""
A Vertex Transformation module
Permutation invariant transformation: (N, k, d) -> (N, k, d)
"""
def __init__(self, dim_in, k):
"""
:param dim_in: input feature dimension
:param k: k neighbors
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | weiyx15/DHGNN | VertexConv | false | 16,710 | [
"MIT"
] | 124 | 870a1763c34af6ee9a7a3207fed4a5e6bdb95d23 | https://github.com/weiyx15/DHGNN/tree/870a1763c34af6ee9a7a3207fed4a5e6bdb95d23 | import torch
from torch import nn
class Transform(nn.Module):
"""
A Vertex Transformation module
Permutation invariant transformation: (N, k, d) -> (N, k, d)
"""
def __init__(self, dim_in, k):
"""
:param dim_in: input feature dimension
:param k: k neighbors
"""
... |
Transform | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Transform(nn.Module):
"""
A Vertex Transformation module
Permutation invariant transformation: (N, k, d) -> (N, k, d)
"""
def __init__(self, dim_in, k):
"""
:param dim_in: input feature dimension
:param k: k neighbors
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | weiyx15/DHGNN | Transform | false | 16,711 | [
"MIT"
] | 124 | 870a1763c34af6ee9a7a3207fed4a5e6bdb95d23 | https://github.com/weiyx15/DHGNN/tree/870a1763c34af6ee9a7a3207fed4a5e6bdb95d23 | import torch
from torch import nn
class Model(nn.Module):
"""
A Vertex Transformation module
Permutation invariant transformation: (N, k, d) -> (N, k, d)
"""
def __init__(self, dim_in, k):
"""
:param dim_in: input feature dimension
:param k: k neighbors
"""
... |
ScaledDotProductAttention | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask (optional)
"""
x = torch.clamp(x, min=-15.0, max=15.0)
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim=True)[0])
if m is not None:
e_x = e_x * m
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | wjurayj/commonsense-rl | ScaledDotProductAttention | false | 16,712 | [
"Apache-2.0"
] | 55 | fbbe4fa4a21865095783845fce2f0c4f4346e40f | https://github.com/wjurayj/commonsense-rl/tree/fbbe4fa4a21865095783845fce2f0c4f4346e40f | import torch
def masked_softmax(x, m=None, dim=-1):
"""
Softmax with mask (optional)
"""
x = torch.clamp(x, min=-15.0, max=15.0)
if m is not None:
m = m.float()
x = x * m
e_x = torch.exp(x - torch.max(x, dim=dim, keepdim=True)[0])
if m is not None:
e_x = e_x * m
... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Attention(nn.Module):
""" Applies attention mechanism on the `context` using the `query`.
**Thank you** to IBM for their initial implementation of :class:`Attention`. Here is
their `License
<https://github.com/IBM/pytorch-seq2seq/blob/master/LICENSE>`__.
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wjurayj/commonsense-rl | Attention | false | 16,713 | [
"Apache-2.0"
] | 55 | fbbe4fa4a21865095783845fce2f0c4f4346e40f | https://github.com/wjurayj/commonsense-rl/tree/fbbe4fa4a21865095783845fce2f0c4f4346e40f | import torch
import torch.nn as nn
class Model(nn.Module):
""" Applies attention mechanism on the `context` using the `query`.
**Thank you** to IBM for their initial implementation of :class:`Attention`. Here is
their `License
<https://github.com/IBM/pytorch-seq2seq/blob/master/LICENSE>`__.
Args... |
bottleneck_block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class depthwise_conv(nn.Module):
def __init__(self, kernel_size=3, stride=1, padding=1):
super(depthwise_conv, self).__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=kernel_size, stride=
stride, padding=padding)
de... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | whiteking64/lang-seg | bottleneck_block | false | 16,714 | [
"MIT"
] | 202 | 9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | https://github.com/whiteking64/lang-seg/tree/9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | import torch
import torch.nn as nn
import torch.utils.data
class depthwise_conv(nn.Module):
def __init__(self, kernel_size=3, stride=1, padding=1):
super().__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=kernel_size, stride=
stride, padding=padding)
def forward(self, x):
... |
depthwise_conv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 depthwise_conv(nn.Module):
def __init__(self, kernel_size=3, stride=1, padding=1):
super(depthwise_conv, self).__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=kernel_size, stride=
stride, padding=padding)
de... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | whiteking64/lang-seg | depthwise_conv | false | 16,715 | [
"MIT"
] | 202 | 9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | https://github.com/whiteking64/lang-seg/tree/9d063b126f1b64e38ddb20cc75fc74435bfdcbd3 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, kernel_size=3, stride=1, padding=1):
super().__init__()
self.depthwise = nn.Conv2d(1, 1, kernel_size=kernel_size, stride=
stride, padding=padding)
def forward(self, x):
C... |
MNACLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
def mnac(x, W, mode='prod'):
out_size, in_size = W.size()
x = x.view(x.size()[0], in_size, 1)
W = W.t().view(1, in_s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import collections
import math
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = ... | wlm2019/Neural-Arithmetic-Units | MNACLayer | false | 16,716 | [
"MIT"
] | 147 | f9de9d004bb2dc2ee28577cd1760d0a00c185836 | https://github.com/wlm2019/Neural-Arithmetic-Units/tree/f9de9d004bb2dc2ee28577cd1760d0a00c185836 | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
def mnac(x, W, mode='prod'):
out_size, in_size = W.size()
x = x.view(x.size()[0], in_size, 1)
W = W.t().view(1, in_s... |
GaussLinearStandardized | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 torch.nn.modules import Module
from torch.nn.parameter import Parameter
import torch.nn.functional as F
class GaussLinearStandardized(Module):
def __init__(self, in_features, out_features, bias=True,
raw_weight_variance=1.0, raw_bias_variance=1.0)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
from torch.nn.modules import Module
from torch.nn.pa... | widedeepnetworks/widedeepnetworks | GaussLinearStandardized | false | 16,717 | [
"Apache-2.0"
] | 50 | 81a8629d62d31643f3d598992ac6376a8fc5c48a | https://github.com/widedeepnetworks/widedeepnetworks/tree/81a8629d62d31643f3d598992ac6376a8fc5c48a | from torch.nn import Module
import math
import torch
from torch.nn.modules import Module
from torch.nn.parameter import Parameter
import torch.nn.functional as F
class Model(Module):
def __init__(self, in_features, out_features, bias=True,
raw_weight_variance=1.0, raw_bias_variance=1.0):
super().... |
PosNACLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import collections
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
class SummaryWriterNamespaceNoLoggingScope:
def __init__(self, writer):
self._writer = writer
def __enter__(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 collections
import torch.utils.data
assert_size_stride = torch._C._dynamo... | wlm2019/Neural-Arithmetic-Units | PosNACLayer | false | 16,718 | [
"MIT"
] | 147 | f9de9d004bb2dc2ee28577cd1760d0a00c185836 | https://github.com/wlm2019/Neural-Arithmetic-Units/tree/f9de9d004bb2dc2ee28577cd1760d0a00c185836 | import collections
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
class SummaryWriterNamespaceNoLoggingScope:
def __init__(self, writer):
self._writer = writer
def __enter__(self):
... |
GumbelMNACLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import collections
import torch
import torch.utils.data
def mnac(x, W, mode='prod'):
out_size, in_size = W.size()
x = x.view(x.size()[0], in_size, 1)
W = W.t().view(1, in_size, out_size)
if mode == 'prod':
return torch.prod(x * W + 1 - W, -2)
elif mode == 'exp-log':
return torch.ex... | 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.triton_helpers import math as tl_math
import collections
import torch.utils.data
asser... | wlm2019/Neural-Arithmetic-Units | GumbelMNACLayer | false | 16,719 | [
"MIT"
] | 147 | f9de9d004bb2dc2ee28577cd1760d0a00c185836 | https://github.com/wlm2019/Neural-Arithmetic-Units/tree/f9de9d004bb2dc2ee28577cd1760d0a00c185836 | import collections
import torch
import torch.utils.data
def mnac(x, W, mode='prod'):
out_size, in_size = W.size()
x = x.view(x.size()[0], in_size, 1)
W = W.t().view(1, in_size, out_size)
if mode == 'prod':
return torch.prod(x * W + 1 - W, -2)
elif mode == 'exp-log':
return torch.ex... |
ReRegualizedLinearMNACLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
def mnac(x, W, mode='prod'):
out_size, in_size = W.size()
x = x.view(x.size()[0], in_size, 1)
W = W.t().view(1, in_s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import collections
import math
import torch.utils.data
assert_size_stride = torch._C._dyn... | wlm2019/Neural-Arithmetic-Units | ReRegualizedLinearMNACLayer | false | 16,720 | [
"MIT"
] | 147 | f9de9d004bb2dc2ee28577cd1760d0a00c185836 | https://github.com/wlm2019/Neural-Arithmetic-Units/tree/f9de9d004bb2dc2ee28577cd1760d0a00c185836 | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
def mnac(x, W, mode='prod'):
out_size, in_size = W.size()
x = x.view(x.size()[0], in_size, 1)
W = W.t().view(1, in_s... |
Gain | # AOT ID: ['1_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 random
import torch
from torchaudio.transforms import Vol
class Gain(torch.nn.Module):
def __init__(self, min_gain: 'float'=-20.0, max_gain: 'float'=-1):
super().__init__()
self.min_gain = min_gain
self.max_gain = max_gain
def forward(self, audio: 'torch.Tensor') ->torch.Tenso... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | wesbz/torchaudio-augmentations | Gain | false | 16,721 | [
"MIT"
] | 112 | e7b379be60376bb4a44f72a6840358871b3ff06d | https://github.com/wesbz/torchaudio-augmentations/tree/e7b379be60376bb4a44f72a6840358871b3ff06d | import random
import torch
from torchaudio.transforms import Vol
class Model(torch.nn.Module):
def __init__(self, min_gain: 'float'=-20.0, max_gain: 'float'=-1):
super().__init__()
self.min_gain = min_gain
self.max_gain = max_gain
def forward(self, audio: 'torch.Tensor') ->torch.Tens... |
VisionLanguageFusionModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
import torch.utils.data
import torch
from torch import nn
from typing import Optional
class VisionLanguageFusionModule(nn.Module):
def __init__(self, d_model, nhead, dropout=0.0):
super().__init__()
self.multihead_attn = nn.MultiheadAttention(d_model, nhead, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wjn922/ReferFormer | VisionLanguageFusionModule | false | 16,722 | [
"Apache-2.0"
] | 125 | 17ca2d8024116068ecae66d0e7155e1d4429b204 | https://github.com/wjn922/ReferFormer/tree/17ca2d8024116068ecae66d0e7155e1d4429b204 | import torch
from torch import Tensor
import torch.utils.data
import torch
from torch import nn
from typing import Optional
class Model(nn.Module):
def __init__(self, d_model, nhead, dropout=0.0):
super().__init__()
self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout
=... |
Task | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
class Task(nn.Module):
def __init__(self):
super().__init__()
self.p = nn.Parameter(torch.ones(2, 2))
def forward(self, x):
retur... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.dat... | woqidaideshi/bagua | Task | false | 16,723 | [
"MIT"
] | 635 | 0ee96da598685748519d58d24ce983499cb36721 | https://github.com/woqidaideshi/bagua/tree/0ee96da598685748519d58d24ce983499cb36721 | import torch
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
self.p = nn.Parameter(torch.ones(2, 2))
def forward(self, x):
retu... |
ModuleForDdpCommHook | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
class Task(nn.Module):
def __init__(self):
super().__init__()
self.p = nn.Parameter(torch.ones(2, 2))
def forward(self, x):
retur... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.dat... | woqidaideshi/bagua | ModuleForDdpCommHook | false | 16,724 | [
"MIT"
] | 635 | 0ee96da598685748519d58d24ce983499cb36721 | https://github.com/woqidaideshi/bagua/tree/0ee96da598685748519d58d24ce983499cb36721 | import torch
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
class Task(nn.Module):
def __init__(self):
super().__init__()
self.p = nn.Parameter(torch.ones(2, 2))
def forward(self, x):
retur... |
ReRegualizedLinearPosNACLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
class SummaryWriterNamespaceNoLoggingScope:
def __init__(self, writer):
self._writer = writer
def __enter__(se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import collections
import mat... | wlm2019/Neural-Arithmetic-Units | ReRegualizedLinearPosNACLayer | false | 16,725 | [
"MIT"
] | 147 | f9de9d004bb2dc2ee28577cd1760d0a00c185836 | https://github.com/wlm2019/Neural-Arithmetic-Units/tree/f9de9d004bb2dc2ee28577cd1760d0a00c185836 | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
class SummaryWriterNamespaceNoLoggingScope:
def __init__(self, writer):
self._writer = writer
def __enter__(se... |
ReRegualizedLinearNACLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
class SummaryWriterNamespaceNoLoggingScope:
def __init__(self, writer):
self._writer = writer
def __enter__(se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import collections
import mat... | wlm2019/Neural-Arithmetic-Units | ReRegualizedLinearNACLayer | false | 16,726 | [
"MIT"
] | 147 | f9de9d004bb2dc2ee28577cd1760d0a00c185836 | https://github.com/wlm2019/Neural-Arithmetic-Units/tree/f9de9d004bb2dc2ee28577cd1760d0a00c185836 | import collections
import math
import torch
import torch.utils.data
def sparsity_error(W):
W_error = torch.min(torch.abs(W), torch.abs(1 - torch.abs(W)))
return torch.max(W_error)
class SummaryWriterNamespaceNoLoggingScope:
def __init__(self, writer):
self._writer = writer
def __enter__(se... |
GAT | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class GraphAttentionLayer(nn.Module):
"""
Simple GAT layer, similar to https://arxiv.org/abs/1710.10903
"""
def __init__(self, in_features, out_features, dropout, alpha, concat=True):
super(GraphAttentionLayer, 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
from torch._inductor.runtime.... | wjurayj/commonsense-rl | GAT | false | 16,727 | [
"Apache-2.0"
] | 55 | fbbe4fa4a21865095783845fce2f0c4f4346e40f | https://github.com/wjurayj/commonsense-rl/tree/fbbe4fa4a21865095783845fce2f0c4f4346e40f | import torch
import torch.nn as nn
import torch.nn.functional as F
class GraphAttentionLayer(nn.Module):
"""
Simple GAT layer, similar to https://arxiv.org/abs/1710.10903
"""
def __init__(self, in_features, out_features, dropout, alpha, concat=True):
super().__init__()
self.dropout = ... |
GL | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 GL(nn.Module):
def __init__(self, dim):
super().__init__()
self.gl_conv = nn.Conv2d(dim, dim, kernel_size=3, padding=1, groups=dim
)
def forward(self, x):
return x + self.gl_conv(x)
def get_inputs():
return [torch.rand([4, 4,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | wofmanaf/ResT | GL | false | 16,728 | [
"Apache-2.0"
] | 178 | 508e30b28036e2cb882a03d24268dc70eb0c82a3 | https://github.com/wofmanaf/ResT/tree/508e30b28036e2cb882a03d24268dc70eb0c82a3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.gl_conv = nn.Conv2d(dim, dim, kernel_size=3, padding=1, groups=dim
)
def forward(self, x):
return x + self.gl_conv(x)
def get_inputs():
return [torch.rand([4,... |
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
from torch.nn import Parameter
class HighWay(torch.nn.Module):
def __init__(self, f_in, f_out, bias=True):
super(HighWay, self).__init__()
self.w = Parameter(torch.Tensor(f_in, f_out))
nn.init.xavier_uniform_(self.w)
if bias:
self.bia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.nn import Parameter
assert_size_stride = torch.... | weihangzhang/EAkit | HighWay | false | 16,729 | [
"MIT"
] | 102 | dde8e914480cd1a3585271f70db11d567d9c2a04 | https://github.com/weihangzhang/EAkit/tree/dde8e914480cd1a3585271f70db11d567d9c2a04 | import torch
import torch.nn as nn
from torch.nn import Parameter
class Model(torch.nn.Module):
def __init__(self, f_in, f_out, bias=True):
super().__init__()
self.w = Parameter(torch.Tensor(f_in, f_out))
nn.init.xavier_uniform_(self.w)
if bias:
self.bias = Parameter(t... |
SobelConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SobelConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=0, dilation=1, groups=1, bias=True, requires_grad=True):
assert kernel_size % 2 == 1, "SobelConv2d's kernel_size must be ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | workingcoder/EDCNN | SobelConv2d | false | 16,730 | [
"Apache-2.0"
] | 117 | 68305f465d2b731b60ce78bd0c95c7742d9f52d1 | https://github.com/workingcoder/EDCNN/tree/68305f465d2b731b60ce78bd0c95c7742d9f52d1 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=0, dilation=1, groups=1, bias=True, requires_grad=True):
assert kernel_size % 2 == 1, "SobelConv2d's kernel_size must be odd."
... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
import torch.utils.data
import torch.nn.parallel
import torch.optim
class ContrastiveLoss(torch.nn.Module):
def __init__(self, margin=2.0):
super(ContrastiveLoss, self).__init__()
self.margin = margin
def forward(self, output1, output2, label):
... | 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... | wenqingchu/Semantic-CariGANs | ContrastiveLoss | false | 16,731 | [
"BSD-3-Clause"
] | 50 | d6c2fc2046ee62b42dd70fa8892775e33337bbdf | https://github.com/wenqingchu/Semantic-CariGANs/tree/d6c2fc2046ee62b42dd70fa8892775e33337bbdf | import torch
import torch.nn.functional as F
import torch.utils.data
import torch.nn.parallel
import torch.optim
class Model(torch.nn.Module):
def __init__(self, margin=2.0):
super().__init__()
self.margin = margin
def forward(self, output1, output2, label):
euclidean_distance = F.pa... |
My_loss | # 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
import torch.nn.parallel
import torch.optim
from torch.autograd import Variable as Variable
import torch.utils.data
import torch._utils
class My_loss(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
vx = x - torch.mean(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn as nn
i... | wtomin/MIMA-Net | My_loss | false | 16,732 | [
"MIT"
] | 58 | c0330777313ac04b25e53b137dbecd78b5c8dde6 | https://github.com/wtomin/MIMA-Net/tree/c0330777313ac04b25e53b137dbecd78b5c8dde6 | import torch
from torch import nn as nn
import torch.nn.parallel
import torch.optim
from torch.autograd import Variable as Variable
import torch.utils.data
import torch._utils
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x, y):
vx = x - torch.mean(x)... |
FusionMax | # 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 Fusion(nn.Module):
""" Base Fusion Class"""
def __init__(self, input_dim=3):
super().__init__()
self.input_dim = input_dim
def tile_x2(self, x1, x2, x2_proj=None):
if x2_proj:
x2 = x2_proj(x2)
x2 = x2.unsqueeze(-1).unsq... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | wx-b/cliport | FusionMax | false | 16,733 | [
"Apache-2.0"
] | 110 | c29b0c4b6b1c4e4da5bda6c7f8c718e36f28a6e8 | https://github.com/wx-b/cliport/tree/c29b0c4b6b1c4e4da5bda6c7f8c718e36f28a6e8 | import torch
import torch.nn as nn
class Fusion(nn.Module):
""" Base Fusion Class"""
def __init__(self, input_dim=3):
super().__init__()
self.input_dim = input_dim
def tile_x2(self, x1, x2, x2_proj=None):
if x2_proj:
x2 = x2_proj(x2)
x2 = x2.unsqueeze(-1).unsq... |
LossBasic | # 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 TensorGradient(nn.Module):
"""
the gradient of tensor
"""
def __init__(self, L1=True):
super(TensorGradient, self).__init__()
self.L1 = L1
def forward(self, img):
w, h = img.size(-2), img.size(-1)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | xenbaloch/efficientderain | LossBasic | false | 16,734 | [
"MIT"
] | 109 | d5646815fd14a5a03c859102ecd2f298db7e53be | https://github.com/xenbaloch/efficientderain/tree/d5646815fd14a5a03c859102ecd2f298db7e53be | import torch
import torch.nn as nn
import torch.nn.functional as F
class TensorGradient(nn.Module):
"""
the gradient of tensor
"""
def __init__(self, L1=True):
super().__init__()
self.L1 = L1
def forward(self, img):
w, h = img.size(-2), img.size(-1)
l = F.pad(img,... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
class Attention(nn.Module):
def __init__(self, hidden_size):
super(Attention, self).__init__()
self.hidden_size = hidden_size
self.attn = nn.Linear(hidden_size * 2, hidden_size)
self.v = nn.Parameter(torch.rand(hidden_size), requires_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wptoux/attention-ocr | Attention | false | 16,735 | [
"MIT"
] | 57 | ed08719db86a2aaf7e0cbae6169d9919835879d7 | https://github.com/wptoux/attention-ocr/tree/ed08719db86a2aaf7e0cbae6169d9919835879d7 | import math
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.hidden_size = hidden_size
self.attn = nn.Linear(hidden_size * 2, hidden_size)
self.v = nn.Parameter(torch.rand(hidden_size), requires_grad=True)
... |
ConvNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
class ConvNet(nn.Module):
def __init__(self, gpus, layouts, dtypes):
super(ConvNet, self).__init__()
self.dtypes = dtypes
if isinstanc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import... | woqidaideshi/bagua | ConvNet | false | 16,737 | [
"MIT"
] | 635 | 0ee96da598685748519d58d24ce983499cb36721 | https://github.com/woqidaideshi/bagua/tree/0ee96da598685748519d58d24ce983499cb36721 | import torch
import torch.nn
import torch.utils.data.distributed
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
class Model(nn.Module):
def __init__(self, gpus, layouts, dtypes):
super().__init__()
self.dtypes = dtypes
if isinstance(gpus, list):
... |
TripletLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
from torch.optim.lr_scheduler import *
def _batch_hard(mat_distance, mat_similarity, indice=False):
sorted_mat_distance, positive_indices = torch.sort(mat_distance + -
9999999.0 * (1 - mat_similarity), dim=1, descending=True)
hard_p = s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | xmy0916/IDM | TripletLoss | false | 16,738 | [
"MIT"
] | 68 | ab29fbd6d3d8c4650f3dbe41a7d21f745d6167ee | https://github.com/xmy0916/IDM/tree/ab29fbd6d3d8c4650f3dbe41a7d21f745d6167ee | import torch
from torch import nn
import torch.nn.functional as F
from torch.optim.lr_scheduler import *
def _batch_hard(mat_distance, mat_similarity, indice=False):
sorted_mat_distance, positive_indices = torch.sort(mat_distance + -
9999999.0 * (1 - mat_similarity), dim=1, descending=True)
hard_p = s... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 32, (3, 3))
self.pool1 = nn.MaxPool2d((2, 2))
self.conv2 = nn.Conv2d(32, 32, (3, 3... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | wikfeldt/intro-to-dl | Net | false | 16,739 | [
"MIT"
] | 59 | 7fb1fb6c520941143000c5e1b46c48c95db17ed6 | https://github.com/wikfeldt/intro-to-dl/tree/7fb1fb6c520941143000c5e1b46c48c95db17ed6 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 32, (3, 3))
self.pool1 = nn.MaxPool2d((2, 2))
self.conv2 = nn.Conv2d(32, 32, (3, 3))
... |
Attention_Decoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class Attention_Decoder(nn.Module):
def __init__(self, dim, num_heads=1, qkv_bias=False, qk_scale=None,
attn_drop=0.0, proj_drop=0.0):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
self.scal... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | xieenze/Trans2Seg | Attention_Decoder | false | 16,740 | [
"Apache-2.0"
] | 149 | 3972916bba7f985ca1aabc047fea56bdec9e9e5d | https://github.com/xieenze/Trans2Seg/tree/3972916bba7f985ca1aabc047fea56bdec9e9e5d | import torch
import torch.nn as nn
import torch._utils
class Model(nn.Module):
def __init__(self, dim, num_heads=1, qkv_bias=False, qk_scale=None,
attn_drop=0.0, proj_drop=0.0):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
self.scale = qk_scale... |
_Enc | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class _NestedEnc(torch.nn.Module):
def __init__(self, f):
super().__init__()
self.f = f
def forward(self, x):
return self.f(x)
class _Enc(torch.nn.Module):
def ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch... | xuanyuzhou98/higher | _Enc | false | 16,741 | [
"Apache-2.0"
] | 1,401 | a28b488d8d4c80b38d3a2d322258233d74a89656 | https://github.com/xuanyuzhou98/higher/tree/a28b488d8d4c80b38d3a2d322258233d74a89656 | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class _NestedEnc(torch.nn.Module):
def __init__(self, f):
super().__init__()
self.f = f
def forward(self, x):
return self.f(x)
class Model(torch.nn.Module):
def... |
MyConv3d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 MyConv3d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
bias=True):
super(MyConv3d, self).__init__()
self.kernel_size = kernel_size
self.conv = nn.Conv3d(in_channels=in_chann... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | xinxindefeiyu/S2VD-master_RESID | MyConv3d | false | 16,742 | [
"MIT"
] | 48 | b075d6873842d70f1d8d3215daf0565f8c0ffe9a | https://github.com/xinxindefeiyu/S2VD-master_RESID/tree/b075d6873842d70f1d8d3215daf0565f8c0ffe9a | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1,
bias=True):
super().__init__()
self.kernel_size = kernel_size
self.conv = nn.Conv3d(in_channels=in_channels, out_channels... |
LossFunc | # 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 TensorGradient(nn.Module):
"""
the gradient of tensor
"""
def __init__(self, L1=True):
super(TensorGradient, self).__init__()
self.L1 = L1
def forward(self, img):
w, h = img.size(-2), img.size(-1)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | xenbaloch/efficientderain | LossFunc | false | 16,743 | [
"MIT"
] | 109 | d5646815fd14a5a03c859102ecd2f298db7e53be | https://github.com/xenbaloch/efficientderain/tree/d5646815fd14a5a03c859102ecd2f298db7e53be | import torch
import torch.nn as nn
import torch.nn.functional as F
class TensorGradient(nn.Module):
"""
the gradient of tensor
"""
def __init__(self, L1=True):
super().__init__()
self.L1 = L1
def forward(self, img):
w, h = img.size(-2), img.size(-1)
l = F.pad(img,... |
SuperpointDescriptor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SuperpointDescriptor(nn.Module):
""" Descriptor decoder based on the SuperPoint arcihtecture. """
def __init__(self, input_feat_dim=128):
super(SuperpointDescriptor, self).__init__()
self.relu = torch.nn.ReLU(inplace=True)
self.convPa = torch.n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | wx-b/SOLD2 | SuperpointDescriptor | false | 16,744 | [
"MIT"
] | 347 | 71c3243f9d3a695788d0a6bfd134b9849425900a | https://github.com/wx-b/SOLD2/tree/71c3243f9d3a695788d0a6bfd134b9849425900a | import torch
import torch.nn as nn
class Model(nn.Module):
""" Descriptor decoder based on the SuperPoint arcihtecture. """
def __init__(self, input_feat_dim=128):
super().__init__()
self.relu = torch.nn.ReLU(inplace=True)
self.convPa = torch.nn.Conv2d(input_feat_dim, 256, kernel_size... |
LossAnneal | # 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 TensorGradient(nn.Module):
"""
the gradient of tensor
"""
def __init__(self, L1=True):
super(TensorGradient, self).__init__()
self.L1 = L1
def forward(self, img):
w, h = img.size(-2), img.size(-1)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | xenbaloch/efficientderain | LossAnneal | false | 16,745 | [
"MIT"
] | 109 | d5646815fd14a5a03c859102ecd2f298db7e53be | https://github.com/xenbaloch/efficientderain/tree/d5646815fd14a5a03c859102ecd2f298db7e53be | import torch
import torch.nn as nn
import torch.nn.functional as F
class TensorGradient(nn.Module):
"""
the gradient of tensor
"""
def __init__(self, L1=True):
super().__init__()
self.L1 = L1
def forward(self, img):
w, h = img.size(-2), img.size(-1)
l = F.pad(img,... |
SuperpointDecoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SuperpointDecoder(nn.Module):
""" Junction decoder based on the SuperPoint architecture. """
def __init__(self, input_feat_dim=128, backbone_name='lcnn'):
super(SuperpointDecoder, self).__init__()
self.relu = torch.nn.ReLU(inplace=True)
if back... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | wx-b/SOLD2 | SuperpointDecoder | false | 16,746 | [
"MIT"
] | 347 | 71c3243f9d3a695788d0a6bfd134b9849425900a | https://github.com/wx-b/SOLD2/tree/71c3243f9d3a695788d0a6bfd134b9849425900a | import torch
import torch.nn as nn
class Model(nn.Module):
""" Junction decoder based on the SuperPoint architecture. """
def __init__(self, input_feat_dim=128, backbone_name='lcnn'):
super().__init__()
self.relu = torch.nn.ReLU(inplace=True)
if backbone_name == 'lcnn':
se... |
WingLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.onnx
from torch.nn.modules.loss import _Loss
class WingLoss(_Loss):
def __init__(self, width=10, curvature=2.0, reduction='mean'):
super(WingLoss, self).__init__(reduction=reduction)
self.width = width
self.curvature = curvature
def forward(self,... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import math
import torch.onnx
from torch.nn.modules.loss import _Loss
ass... | xuguozhi/Peppa-Facial-Landmark-PyTorch | WingLoss | false | 16,747 | [
"Apache-2.0"
] | 163 | 238063317fd31c4c21c5c43692e6a5d769970370 | https://github.com/xuguozhi/Peppa-Facial-Landmark-PyTorch/tree/238063317fd31c4c21c5c43692e6a5d769970370 | import math
import torch
import torch.onnx
from torch.nn.modules.loss import _Loss
class Model(_Loss):
def __init__(self, width=10, curvature=2.0, reduction='mean'):
super().__init__(reduction=reduction)
self.width = width
self.curvature = curvature
def forward(self, prediction, targ... |
FC_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 as nn
import torch.nn.functional as F
class FC_Q(nn.Module):
def __init__(self, state_dim, num_actions):
super(FC_Q, self).__init__()
self.q1 = nn.Linear(state_dim, 256)
self.q2 = nn.Linear(256, 256)
self.q3 = nn.Linear(256, num_actions)
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.... | xtwentian3/BCQ | FC_Q | false | 16,748 | [
"MIT"
] | 402 | e114f8c474c57a36d9af78c42a06f612831afda2 | https://github.com/xtwentian3/BCQ/tree/e114f8c474c57a36d9af78c42a06f612831afda2 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, num_actions):
super().__init__()
self.q1 = nn.Linear(state_dim, 256)
self.q2 = nn.Linear(256, 256)
self.q3 = nn.Linear(256, num_actions)
self.i1 = nn.Li... |
EDCNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SobelConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=0, dilation=1, groups=1, bias=True, requires_grad=True):
assert kernel_size % 2 == 1, "SobelConv2d's kernel_size must be ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional as F
assert_size_stride = torch... | workingcoder/EDCNN | EDCNN | false | 16,749 | [
"Apache-2.0"
] | 117 | 68305f465d2b731b60ce78bd0c95c7742d9f52d1 | https://github.com/workingcoder/EDCNN/tree/68305f465d2b731b60ce78bd0c95c7742d9f52d1 | import torch
import torch.nn as nn
import torch.nn.functional as F
class SobelConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,
padding=0, dilation=1, groups=1, bias=True, requires_grad=True):
assert kernel_size % 2 == 1, "SobelConv2d's kernel_size must be ... |
Whitening2d | # 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.cuda.amp import custom_fwd
from torch.nn.functional import conv2d
class Whitening2d(nn.Module):
def __init__(self, output_dim: 'int', eps: 'float'=0.0):
"""Layer that computes hard whitening for W-MSE using the Cholesky decomposition.
Args:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | xwyzsn/solo-learn | Whitening2d | false | 16,750 | [
"MIT"
] | 693 | 16d021d8053439a3de205337ab2a11d191500b09 | https://github.com/xwyzsn/solo-learn/tree/16d021d8053439a3de205337ab2a11d191500b09 | import torch
import torch.nn as nn
from torch.cuda.amp import custom_fwd
from torch.nn.functional import conv2d
class Model(nn.Module):
def __init__(self, output_dim: 'int', eps: 'float'=0.0):
"""Layer that computes hard whitening for W-MSE using the Cholesky decomposition.
Args:
out... |
SkipConnection | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
def _init_weights(layer):
"""
Init weights of the layer
:param layer:
:return:
"""
nn.init.xavier_uniform_(layer.weight)
if layer.bias is not None:
nn.init.zeros_(layer.bias)
class SkipConnection(nn.Module):
"""
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
import torch.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dyn... | xyc1207/benchmarking-gnns | SkipConnection | false | 16,751 | [
"MIT"
] | 1,809 | 9ba25a2825e8c155a93730d6e8f8752090292942 | https://github.com/xyc1207/benchmarking-gnns/tree/9ba25a2825e8c155a93730d6e8f8752090292942 | import torch
import torch.utils.data
import torch.nn as nn
def _init_weights(layer):
"""
Init weights of the layer
:param layer:
:return:
"""
nn.init.xavier_uniform_(layer.weight)
if layer.bias is not None:
nn.init.zeros_(layer.bias)
class Model(nn.Module):
"""
Connects t... |
SuperpointBackbone | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 SuperpointBackbone(nn.Module):
""" SuperPoint backbone. """
def __init__(self):
super(SuperpointBackbone, self).__init__()
self.relu = torch.nn.ReLU(inplace=True)
self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)
c1, c2, c3, c4 = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | wx-b/SOLD2 | SuperpointBackbone | false | 16,752 | [
"MIT"
] | 347 | 71c3243f9d3a695788d0a6bfd134b9849425900a | https://github.com/wx-b/SOLD2/tree/71c3243f9d3a695788d0a6bfd134b9849425900a | import torch
import torch.nn as nn
class Model(nn.Module):
""" SuperPoint backbone. """
def __init__(self):
super().__init__()
self.relu = torch.nn.ReLU(inplace=True)
self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)
c1, c2, c3, c4 = 64, 64, 128, 128
self.conv1a ... |
GateLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.optim.lr_scheduler import *
class GateLayer(nn.Module):
def __init__(self, dim, target_dim=None, dropout=None):
super(GateLayer, self).__init__()
if target_dim is None:
target_dim = dim
self.line... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.optim.lr_scheduler import *
assert_size_stride ... | xycforgithub/MultiTask-MRC | GateLayer | false | 16,753 | [
"BSD-3-Clause"
] | 105 | 6e5fe8b3cbc40058784cecad73219390e3c2a922 | https://github.com/xycforgithub/MultiTask-MRC/tree/6e5fe8b3cbc40058784cecad73219390e3c2a922 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim.lr_scheduler import *
class Model(nn.Module):
def __init__(self, dim, target_dim=None, dropout=None):
super().__init__()
if target_dim is None:
target_dim = dim
self.linear_transform = Fals... |
C3D_td5 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Path(object):
@staticmethod
def db_dir(database):
if database == 'ucf101':
root_dir = (
'/Users/pingaowang/Google Drive/study/video_classification_research/datasets/UCF-101'
)
output_dir = DATA_PATH
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | pingaowang/pytorch-video-recognition | C3D_td5 | false | 16,754 | [
"MIT"
] | 946 | 096267f88d96a77a74ff743fb0115d997e2cdafd | https://github.com/pingaowang/pytorch-video-recognition/tree/096267f88d96a77a74ff743fb0115d997e2cdafd | import torch
import torch.nn as nn
class Path(object):
@staticmethod
def db_dir(database):
if database == 'ucf101':
root_dir = (
'/Users/pingaowang/Google Drive/study/video_classification_research/datasets/UCF-101'
)
output_dir = DATA_PATH
... |
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.utils.data
import torch.nn as nn
class LayerNorm(nn.Module):
def __init__(self, d):
super().__init__()
self.a = nn.Parameter(torch.ones(d).unsqueeze(0).unsqueeze(0))
self.b = nn.Parameter(torch.zeros(d).unsqueeze(0).unsqueeze(0))
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.utils.data
import torch.nn as nn
assert_size_stride = torch._C._dy... | xyc1207/benchmarking-gnns | LayerNorm | false | 16,755 | [
"MIT"
] | 1,809 | 9ba25a2825e8c155a93730d6e8f8752090292942 | https://github.com/xyc1207/benchmarking-gnns/tree/9ba25a2825e8c155a93730d6e8f8752090292942 | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d):
super().__init__()
self.a = nn.Parameter(torch.ones(d).unsqueeze(0).unsqueeze(0))
self.b = nn.Parameter(torch.zeros(d).unsqueeze(0).unsqueeze(0))
def forward(self, x):
me... |
PSA_p | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def kaiming_init(module, a=0, mode='fan_out', nonlinearity='relu', bias=0,
distribution='normal'):
assert distribution in ['uniform', 'normal']
if distribution == 'uniform':
nn.init.kaiming_uniform_(module.weight, a=a, mode=mode,
n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | xuewengeophysics/PSA | PSA_p | false | 16,756 | [
"Apache-2.0"
] | 175 | 06ee556de4e88ecc2a162bd89f9dd494407e3051 | https://github.com/xuewengeophysics/PSA/tree/06ee556de4e88ecc2a162bd89f9dd494407e3051 | import torch
import torch.nn as nn
import torch._utils
def kaiming_init(module, a=0, mode='fan_out', nonlinearity='relu', bias=0,
distribution='normal'):
assert distribution in ['uniform', 'normal']
if distribution == 'uniform':
nn.init.kaiming_uniform_(module.weight, a=a, mode=mode,
n... |
ZeroConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 import init
class ZeroConv2d(nn.Module):
def __init__(self, in_channel, out_channel):
super().__init__()
self.conv = nn.Conv2d(in_channel, out_channel, 1, padding=0)
init.uniform_(self.conv.weight, -0.001, 0.001)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | yhgon/NanoFlow | ZeroConv2d | false | 16,757 | [
"BSD-3-Clause"
] | 62 | 73b24dfd4d607e73d6167897b83e9f61fcaaca3b | https://github.com/yhgon/NanoFlow/tree/73b24dfd4d607e73d6167897b83e9f61fcaaca3b | import torch
import torch.nn as nn
import torch.utils.data
from torch.nn import init
class Model(nn.Module):
def __init__(self, in_channel, out_channel):
super().__init__()
self.conv = nn.Conv2d(in_channel, out_channel, 1, padding=0)
init.uniform_(self.conv.weight, -0.001, 0.001)
... |
ManifoldPropagation | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 shift(x, direction, amount):
if direction == 'left':
ret = F.pad(x, (amount, 0, 0, 0, 0, 0, 0, 0))[:, :, :, :-amount]
elif direction == 'right':
ret = F.pad(x, (0, amount, 0, 0, 0, 0, 0, 0))[:, :, :, amount:]
elif direc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | wonkyunglee/MPNet | ManifoldPropagation | false | 16,758 | [
"MIT"
] | 1,280 | 3a6821a88a5e3db5bd97121761dbb361d9518bc2 | https://github.com/wonkyunglee/MPNet/tree/3a6821a88a5e3db5bd97121761dbb361d9518bc2 | import torch
import torch.nn as nn
import torch.nn.functional as F
def shift(x, direction, amount):
if direction == 'left':
ret = F.pad(x, (amount, 0, 0, 0, 0, 0, 0, 0))[:, :, :, :-amount]
elif direction == 'right':
ret = F.pad(x, (0, amount, 0, 0, 0, 0, 0, 0))[:, :, :, amount:]
elif direc... |
Model | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs):
super(Model, self).__init__()
h_size_1 = 100
h_size_2 = 100
self.p_fc1 = nn.Linear(num_inputs, h_size_1)
self.p_fc2 = nn.Linear(h_size_1,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
im... | yanjiajia-september/Pytorch-DPPO | Model | false | 16,759 | [
"MIT"
] | 179 | 5e1a75b6dfc6a170270253a35d10109718240e97 | https://github.com/yanjiajia-september/Pytorch-DPPO/tree/5e1a75b6dfc6a170270253a35d10109718240e97 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_inputs, num_outputs):
super(Model, self).__init__()
h_size_1 = 100
h_size_2 = 100
self.p_fc1 = nn.Linear(num_inputs, h_size_1)
self.p_fc2 = nn.Linear(h_size_1,... |
PoolFormerBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import warnings
import torch.nn as nn
def _no_grad_trunc_normal_(tensor, mean, std, a, b):
"""Copy & paste from PyTorch official master until it's in a few official releases - RW
Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
"""
def n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
import ... | xwyzsn/solo-learn | PoolFormerBlock | false | 16,760 | [
"MIT"
] | 693 | 16d021d8053439a3de205337ab2a11d191500b09 | https://github.com/xwyzsn/solo-learn/tree/16d021d8053439a3de205337ab2a11d191500b09 | import math
import torch
import warnings
import torch.nn as nn
def _no_grad_trunc_normal_(tensor, mean, std, a, b):
"""Copy & paste from PyTorch official master until it's in a few official releases - RW
Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
"""
def n... |
EqualLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
from torch import nn
class EqualLinear(nn.Module):
def __init__(self, in_dim, out_dim, lr_mul=1, bias=True):
super().__init__()
self.weight = nn.Parameter(torch.randn(out_dim, in_dim))
if bias:
self.bias = nn.Parameter(torch.zeros(o... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | yoona-ai/stylegan2-pytorch | EqualLinear | false | 16,761 | [
"MIT"
] | 2,954 | eceb8aacb669f19b79cc74c7160a85252b1086d6 | https://github.com/yoona-ai/stylegan2-pytorch/tree/eceb8aacb669f19b79cc74c7160a85252b1086d6 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Module):
def __init__(self, in_dim, out_dim, lr_mul=1, bias=True):
super().__init__()
self.weight = nn.Parameter(torch.randn(out_dim, in_dim))
if bias:
self.bias = nn.Parameter(torch.zeros(out_dim... |
KeypointsMSESmoothLoss | # 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 KeypointsMSESmoothLoss(nn.Module):
def __init__(self, threshold=400):
super().__init__()
self.threshold = threshold
def forward(self, output, target, target_weight):
batch_size = output.size(0)
num_... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cud... | yihui-he2020/epipolar-transformers | KeypointsMSESmoothLoss | false | 16,762 | [
"MIT"
] | 360 | 6824f4345b2998500fbacd0f4e30f67f8e3da7b8 | https://github.com/yihui-he2020/epipolar-transformers/tree/6824f4345b2998500fbacd0f4e30f67f8e3da7b8 | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, threshold=400):
super().__init__()
self.threshold = threshold
def forward(self, output, target, target_weight):
batch_size = output.size(0)
num_joints = output.s... |
Conv2D | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class Conv2D(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, dilation_h
=1, dilation_w=1, causal=True, use_wn_bias=True):
super(Conv2D, self).__init__()
self.causal = causal
self.use_wn_bias = use_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | yhgon/NanoFlow | Conv2D | false | 16,763 | [
"BSD-3-Clause"
] | 62 | 73b24dfd4d607e73d6167897b83e9f61fcaaca3b | https://github.com/yhgon/NanoFlow/tree/73b24dfd4d607e73d6167897b83e9f61fcaaca3b | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=3, dilation_h
=1, dilation_w=1, causal=True, use_wn_bias=True):
super().__init__()
self.causal = causal
self.use_wn_bias = use_wn_bias
... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class LayerNorm(nn.Module):
"""
LayerNorm that supports inputs of size B, C, T
"""
def __init__(self, num_channels, eps=1e-05, affine=True, device=None,
dtype=None):
super().__init__()
factory_kwargs = {'device': devic... | 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.data
assert_size_stride = torch._C._dy... | yjh0410/actionformer_release | LayerNorm | false | 16,764 | [
"MIT"
] | 61 | 7a97422111d3e29c8d2e14088c850c6975855ea7 | https://github.com/yjh0410/actionformer_release/tree/7a97422111d3e29c8d2e14088c850c6975855ea7 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
LayerNorm that supports inputs of size B, C, T
"""
def __init__(self, num_channels, eps=1e-05, affine=True, device=None,
dtype=None):
super().__init__()
factory_kwargs = {'device': device, '... |
AffineDropPath | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
def drop_path(x, drop_prob=0.0, training=False):
"""
Stochastic Depth per sample.
"""
if drop_prob == 0.0 or not training:
return x
keep_prob = 1 - drop_prob
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
mask = keep_prob + to... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | yjh0410/actionformer_release | AffineDropPath | false | 16,765 | [
"MIT"
] | 61 | 7a97422111d3e29c8d2e14088c850c6975855ea7 | https://github.com/yjh0410/actionformer_release/tree/7a97422111d3e29c8d2e14088c850c6975855ea7 | import torch
import torch.nn as nn
import torch.utils.data
def drop_path(x, drop_prob=0.0, training=False):
"""
Stochastic Depth per sample.
"""
if drop_prob == 0.0 or not training:
return x
keep_prob = 1 - drop_prob
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
mask = keep_prob + to... |
IA_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
import torch.nn as nn
class IA_gate(nn.Module):
def __init__(self, in_dim, out_dim):
super(IA_gate, self).__init__()
self.IA = nn.Linear(in_dim, out_dim)
def forward(self, x, IA_head):
a = self.IA(IA_head)
a = 1.0 + torch.tanh(a)
a = a.unsqueeze(-1).unsqu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | yoxu515/CFBI | IA_gate | false | 16,766 | [
"BSD-3-Clause"
] | 312 | 0bab1e3c9fc3e3ba0629f716d60221e8f8d9d586 | https://github.com/yoxu515/CFBI/tree/0bab1e3c9fc3e3ba0629f716d60221e8f8d9d586 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_dim, out_dim):
super().__init__()
self.IA = nn.Linear(in_dim, out_dim)
def forward(self, x, IA_head):
a = self.IA(IA_head)
a = 1.0 + torch.tanh(a)
a = a.unsqueeze(-1).unsqueeze(-1)
... |
FocalLossSigmoid | # 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 math import sqrt as sqrt
from itertools import product as product
class FocalLossSigmoid(nn.Module):
"""
sigmoid version focal loss
"""
def __init__(self, alpha=0.25, gamma=2, size_average=False):
super(FocalLossSigmoid, self).__init__()
self.al... | 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
... | yqyao/SSD_Pytorch | FocalLossSigmoid | false | 16,767 | [
"MIT"
] | 163 | 6060bbb650e7a1df7c12d7c9650a38eaba4ab6a8 | https://github.com/yqyao/SSD_Pytorch/tree/6060bbb650e7a1df7c12d7c9650a38eaba4ab6a8 | import torch
import torch.nn as nn
from math import sqrt as sqrt
from itertools import product as product
class Model(nn.Module):
"""
sigmoid version focal loss
"""
def __init__(self, alpha=0.25, gamma=2, size_average=False):
super().__init__()
self.alpha = alpha
self.gamma = ... |
WeightMseLoss | # 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 WeightMseLoss(nn.Module):
def __init__(self, size_average=True):
super(WeightMseLoss, self).__init__()
self.size_average = size_average
def forward(self, inputs, targets, weights):
""" inputs is N * C
targets is N * C
w... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | yqyao/YOLOv3_Pytorch | WeightMseLoss | false | 16,768 | [
"MIT"
] | 55 | ea392f7d418be94605f86ba2b5d167ec30611def | https://github.com/yqyao/YOLOv3_Pytorch/tree/ea392f7d418be94605f86ba2b5d167ec30611def | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, size_average=True):
super().__init__()
self.size_average = size_average
def forward(self, inputs, targets, weights):
""" inputs is N * C
targets is N * C
weights is N * C
"""... |
DownsampleA | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.init
class DownsampleA(nn.Module):
def __init__(self, nIn, nOut, stride):
super(DownsampleA, self).__init__()
self.avg = nn.AvgPool2d(kernel_s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.n... | yuanjef/imagenet-fast | DownsampleA | false | 16,769 | [
"Apache-2.0"
] | 298 | 4c1cb1ec11c3444982913fc6526720a0d29b97c5 | https://github.com/yuanjef/imagenet-fast/tree/4c1cb1ec11c3444982913fc6526720a0d29b97c5 | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torch.nn.init
class Model(nn.Module):
def __init__(self, nIn, nOut, stride):
super().__init__()
self.avg = nn.AvgPool2d(kernel_size=1, stride=stride)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.