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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
FourierConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FourierConv1d(torch.nn.Module):
def __init__(self, in_channels, out_channels, size, bias=True, periodic
=False):
super(FourierConv1d, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
if not periodic:
self.size ... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty... | julian-parker/DAFX22_FNO | FourierConv1d | false | 3,782 | [
"MIT"
] | 0 | 72f30144317a3f8ba8ea23ecf9a0333c81fc87db | https://github.com/julian-parker/DAFX22_FNO/tree/72f30144317a3f8ba8ea23ecf9a0333c81fc87db | import torch
class Model(torch.nn.Module):
def __init__(self, in_channels, out_channels, size, bias=True, periodic
=False):
super().__init__()
self.in_channels = in_channels
self.out_channels = out_channels
if not periodic:
self.size = size
else:
... |
Duel_QNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Duel_QNetwork(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed):
"""Initialize parameters and build model.
Params
======
state_size (int): Dimension of each sta... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | jsztompka/DuelDQN | Duel_QNetwork | false | 3,783 | [
"MIT"
] | 0 | 3b1234425b66034ef233ac988305dc13ffbf7ace | https://github.com/jsztompka/DuelDQN/tree/3b1234425b66034ef233ac988305dc13ffbf7ace | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed):
"""Initialize parameters and build model.
Params
======
state_size (int): Dimension of each state
... |
VAE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class Encoder(nn.Module):
def __init__(self, latent_size):
super().__init__()
self.latent_size = latent_size
self.conv1 = nn.Conv2d(3, 32, 4, stride=2)
self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
self.c... | import torch
from torch import device
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from... | jinyeom/ga-plastic-models | VAE | false | 3,784 | [
"MIT"
] | 0 | e38b245ae51c35a5f32679cc9f215463a3d58f1a | https://github.com/jinyeom/ga-plastic-models/tree/e38b245ae51c35a5f32679cc9f215463a3d58f1a | import torch
from torch import nn
from torch.nn import functional as F
class Encoder(nn.Module):
def __init__(self, latent_size):
super().__init__()
self.latent_size = latent_size
self.conv1 = nn.Conv2d(3, 32, 4, stride=2)
self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
self.c... |
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
from torchvision import transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
class ContrastiveLoss(nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torchvision import tran... | justinluyao/phd_thesis | ContrastiveLoss | false | 3,785 | [
"MIT"
] | 0 | 0a61f5deaac86dd34839ce24c2ad89e1411a8540 | https://github.com/justinluyao/phd_thesis/tree/0a61f5deaac86dd34839ce24c2ad89e1411a8540 | import torch
from torchvision import transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin):
super().__... |
MultiHeadSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
from torch.nn import Dropout
from torch.nn import Linear
def masked_softmax(vector: 'torch.Tensor', mask: 'torch.Tensor', dim: 'int'=-1
) ->torch.Tensor:
"""
``torch.nn.functional.softmax(vector)`` does not work if some elements of ``vector`` should be
masked. ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | jsonW0/StrokeOrderEmbeddings | MultiHeadSelfAttention | false | 3,786 | [
"Apache-2.0"
] | 0 | aa73b216a118de2efba1d299b96990ba9244fa3f | https://github.com/jsonW0/StrokeOrderEmbeddings/tree/aa73b216a118de2efba1d299b96990ba9244fa3f | from torch.nn import Module
import torch
from torch.nn import Dropout
from torch.nn import Linear
def masked_softmax(vector: 'torch.Tensor', mask: 'torch.Tensor', dim: 'int'=-1
) ->torch.Tensor:
"""
``torch.nn.functional.softmax(vector)`` does not work if some elements of ``vector`` should be
masked. ... |
CustomGruCell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
from torch import nn
class CustomGruCell(nn.Module):
"""
A forward only GRU cell.
Input should be: (sequence length x batch size x input_size).
The output is the output of the final forward call.
It's not clear if it would be possible to use the output from each cel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 numpy as np
... | juharris/PySyft | CustomGruCell | false | 3,787 | [
"Apache-2.0"
] | 0 | dbb70f24cc55a7dca032fb06f1a8662cb15092a9 | https://github.com/juharris/PySyft/tree/dbb70f24cc55a7dca032fb06f1a8662cb15092a9 | import torch
import numpy as np
from torch import nn
class Model(nn.Module):
"""
A forward only GRU cell.
Input should be: (sequence length x batch size x input_size).
The output is the output of the final forward call.
It's not clear if it would be possible to use the output from each cell in a P... |
EncoderImagePrecomp | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
from collections import OrderedDict
import torch.nn as nn
import torch.nn.init
def l2norm(X):
"""L2-normalize columns of X
"""
norm = torch.pow(X, 2).sum(dim=1, keepdim=True).sqrt()
a = norm.expand_as(X)
X = torch.div(X, a)
return X
class EncoderImagePrecomp(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 numpy as np
... | jwehrmann/seamretrieval | EncoderImagePrecomp | false | 3,788 | [
"Apache-2.0"
] | 0 | ff94dccc28d56ffbbb7813832c0adbab7b7c6107 | https://github.com/jwehrmann/seamretrieval/tree/ff94dccc28d56ffbbb7813832c0adbab7b7c6107 | import torch
import numpy as np
from collections import OrderedDict
import torch.nn as nn
import torch.nn.init
def l2norm(X):
"""L2-normalize columns of X
"""
norm = torch.pow(X, 2).sum(dim=1, keepdim=True).sqrt()
a = norm.expand_as(X)
X = torch.div(X, a)
return X
class Model(nn.Module):
... |
ATANLoss | # 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 ATANLoss(nn.Module):
def __init__(self):
super(ATANLoss, self).__init__()
def forward(self, inputs, targets):
loss = torch.mean(torch.atan(torch.abs(inputs - targets)))
return loss
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torc... | 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... | kamomehz/waveletCodingCNN | ATANLoss | false | 3,789 | [
"MIT"
] | 0 | 50c7db9d986039ded38999b7e4f4265e2250fb90 | https://github.com/kamomehz/waveletCodingCNN/tree/50c7db9d986039ded38999b7e4f4265e2250fb90 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, inputs, targets):
loss = torch.mean(torch.atan(torch.abs(inputs - targets)))
return loss
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, ... |
Hidden2DiscreteDeal | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.init
class Hidden2DiscreteDeal(nn.Module):
def __init__(self, input_size, z_size, is_lstm=False, has_bias=True):
super(Hidden2DiscreteDeal, self).__init__()
self.z_size = z_size
latent_size = self.z_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.... | justinchiu/NeuralDialog | Hidden2DiscreteDeal | false | 3,790 | [
"Apache-2.0"
] | 0 | f272cc2e12ffdd44c94263ee373208a22c057129 | https://github.com/justinchiu/NeuralDialog/tree/f272cc2e12ffdd44c94263ee373208a22c057129 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init
class Model(nn.Module):
def __init__(self, input_size, z_size, is_lstm=False, has_bias=True):
super().__init__()
self.z_size = z_size
latent_size = self.z_size
if is_lstm:
self.p_h ... |
ConvDenoiser | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.init
import torch.nn as nn
import torch.nn.functional as F
class ConvDenoiser(nn.Module):
def __init__(self):
super(ConvDenoiser, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
self.conv2 = nn.Conv2d(32, 16, 3, padding=1)
self.conv3 = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn.init
import t... | joydeba/autocount | ConvDenoiser | false | 3,791 | [
"MIT"
] | 0 | 52ddb47726fa34d5f54e2850dc6690b67c768728 | https://github.com/joydeba/autocount/tree/52ddb47726fa34d5f54e2850dc6690b67c768728 | import torch
import torch.nn.init
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
self.conv2 = nn.Conv2d(32, 16, 3, padding=1)
self.conv3 = nn.Conv2d(16, 8, 3, padding=... |
SelfAttn | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class SelfAttn(nn.Module):
"""
self-attention with learnable parameters
"""
def __init__(self, dhid):
super().__init__()
self.scorer = nn.Linear(dhid, 1)
def forward(self, inp):
scores = F.softmax(self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jzhanson/alfred | SelfAttn | false | 3,792 | [
"MIT"
] | 0 | d5b540e7c9b53d3f70cc2907503935fecff00018 | https://github.com/jzhanson/alfred/tree/d5b540e7c9b53d3f70cc2907503935fecff00018 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
self-attention with learnable parameters
"""
def __init__(self, dhid):
super().__init__()
self.scorer = nn.Linear(dhid, 1)
def forward(self, inp):
scores = F.softmax(self.sc... |
FourierConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 FourierConv2d(torch.nn.Module):
def __init__(self, in_channels, out_channels, size_x, size_y, bias=True,
periodic=False):
super(FourierConv2d, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
if not periodic:
s... | 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty... | julian-parker/DAFX22_FNO | FourierConv2d | false | 3,793 | [
"MIT"
] | 0 | 72f30144317a3f8ba8ea23ecf9a0333c81fc87db | https://github.com/julian-parker/DAFX22_FNO/tree/72f30144317a3f8ba8ea23ecf9a0333c81fc87db | import torch
class Model(torch.nn.Module):
def __init__(self, in_channels, out_channels, size_x, size_y, bias=True,
periodic=False):
super().__init__()
self.in_channels = in_channels
self.out_channels = out_channels
if not periodic:
self.size_x = size_x
... |
RMSELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class RMSELoss(nn.Module):
def __init__(self):
super(RMSELoss, self).__init__()
def forward(self, inputs, targets):
tmp = (inputs - targets) ** 2
loss = torch.mean(tmp)
return torch.sqrt(loss)
def get_inputs():
return [torch.rand([4, 4... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | kamomehz/waveletCodingCNN | RMSELoss | false | 3,794 | [
"MIT"
] | 0 | 50c7db9d986039ded38999b7e4f4265e2250fb90 | https://github.com/kamomehz/waveletCodingCNN/tree/50c7db9d986039ded38999b7e4f4265e2250fb90 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, inputs, targets):
tmp = (inputs - targets) ** 2
loss = torch.mean(tmp)
return torch.sqrt(loss)
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.r... |
Net_L2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net_L2(nn.Module):
def __init__(self, inputSize, kernel=64):
super(Net_L2, self).__init__()
self.inputSize = inputSize
self.kernel = kernel
self.fc1 = nn.Linear(self.inputSize, 256)
self.fc2 = nn.Line... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | kamomehz/waveletCodingCNN | Net_L2 | false | 3,795 | [
"MIT"
] | 0 | 50c7db9d986039ded38999b7e4f4265e2250fb90 | https://github.com/kamomehz/waveletCodingCNN/tree/50c7db9d986039ded38999b7e4f4265e2250fb90 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, inputSize, kernel=64):
super().__init__()
self.inputSize = inputSize
self.kernel = kernel
self.fc1 = nn.Linear(self.inputSize, 256)
self.fc2 = nn.Linear(256, 32)
... |
ToContinuous | # 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.utils.data
class ToContinuous(nn.Module):
def __init__(self):
super(ToContinuous, self).__init__()
def forward(self, x):
"""
:param x: tensor with dimension opt(batch x _ x bins x H x W
:return:
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty... | kampta/multiview-shapes | ToContinuous | false | 3,796 | [
"MIT"
] | 0 | a79eb4b492be8c2c279e2c69b13d5a19dff1621b | https://github.com/kampta/multiview-shapes/tree/a79eb4b492be8c2c279e2c69b13d5a19dff1621b | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
"""
:param x: tensor with dimension opt(batch x _ x bins x H x W
:return:
"""
assert len(x.... |
DGMNConv3DLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.init as init
class DGMNConv3DLayer(nn.Module):
def __init__(self, args):
self.args = args
super(DGMNConv3DLayer, self).__init__()
self.conv1 = nn.Conv3d(in_channels=1, out_channels=32, kernel_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | Coldog2333/DGMN-pytorch | DGMNConv3DLayer | false | 3,797 | [
"Apache-2.0"
] | 0 | c34248afca516625c2ac2fc6d6f4ce8fe2988c99 | https://github.com/Coldog2333/DGMN-pytorch/tree/c34248afca516625c2ac2fc6d6f4ce8fe2988c99 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
import torch.nn.init as init
class Model(nn.Module):
def __init__(self, args):
self.args = args
super().__init__()
self.conv1 = nn.Conv3d(in_channels=1, out_channels=32, kernel_size=
(3, 3, 3), st... |
teacherNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 teacherNet(nn.Module):
def __init__(self):
super(teacherNet, self).__init__()
self.fc1 = nn.Linear(28 * 28, 1200)
self.fc2 = nn.Linear(1200, 1200)
self.fc3 = nn.Linear(1200, 10)
def forward(self, x):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | kamiyakenta/knowledge-distillation-pytorch | teacherNet | false | 3,798 | [
"MIT"
] | 0 | 749c6bb353961147718371b2b694046af0a6e3f1 | https://github.com/kamiyakenta/knowledge-distillation-pytorch/tree/749c6bb353961147718371b2b694046af0a6e3f1 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(28 * 28, 1200)
self.fc2 = nn.Linear(1200, 1200)
self.fc3 = nn.Linear(1200, 10)
def forward(self, x):
x = x.view(-1, 2... |
ToRGB | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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.autograd import Function
import math
import torch
import torch.nn as nn
from torch.nn import functional as F
import torch.nn.parallel
import torch.utils.data
def make_kernel(k):
k = torch.tensor(k, dtype=torch.float32)
if k.ndim == 1:
k = k[None, :] * k[:, None]
k /= k.sum()
return ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.autograd import Function
import math
import torch.nn as nn
from torch... | kampta/multiview-shapes | ToRGB | false | 3,799 | [
"MIT"
] | 0 | a79eb4b492be8c2c279e2c69b13d5a19dff1621b | https://github.com/kampta/multiview-shapes/tree/a79eb4b492be8c2c279e2c69b13d5a19dff1621b | from torch.autograd import Function
import math
import torch
import torch.nn as nn
from torch.nn import functional as F
import torch.nn.parallel
import torch.utils.data
def make_kernel(k):
k = torch.tensor(k, dtype=torch.float32)
if k.ndim == 1:
k = k[None, :] * k[:, None]
k /= k.sum()
return ... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def hidden_init(layer):
fan_in = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(fan_in)
return -lim, lim
class Actor(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, input_size, output_size, seed, f... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kangjie-chen/deep-reinforcement-learning | Actor | false | 3,801 | [
"MIT"
] | 0 | 0706f136834ecafc7391f483a6b3c84365a349eb | https://github.com/kangjie-chen/deep-reinforcement-learning/tree/0706f136834ecafc7391f483a6b3c84365a349eb | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def hidden_init(layer):
fan_in = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(fan_in)
return -lim, lim
class Model(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, input_size, output_size, seed, f... |
Feature_extraction | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torchvision import transforms as transforms
import torch.nn as nn
class Feature_extraction(nn.Module):
def __init__(self, k, p):
super(Feature_extraction, self).__init__()
self.conv_1 = nn.Conv2d(3, 64, kernel_size=5, padding=2)
self.conv_2 = nn.Conv2d(64, 64, kernel_siz... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torchvision import trans... | justinluyao/phd_thesis | Feature_extraction | false | 3,803 | [
"MIT"
] | 0 | 0a61f5deaac86dd34839ce24c2ad89e1411a8540 | https://github.com/justinluyao/phd_thesis/tree/0a61f5deaac86dd34839ce24c2ad89e1411a8540 | import torch
from torchvision import transforms as transforms
import torch.nn as nn
class Model(nn.Module):
def __init__(self, k, p):
super().__init__()
self.conv_1 = nn.Conv2d(3, 64, kernel_size=5, padding=2)
self.conv_2 = nn.Conv2d(64, 64, kernel_size=k, padding=p)
self.conv_3 =... |
CmapPafHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.optim
class UpsampleCBR(torch.nn.Sequential):
def __init__(self, input_channels, output_channels, count=1, num_flat=0):
layers = []
for i in range(count):
if i == 0:
inch = input_channels
els... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | intflow/trt_openpose | CmapPafHeadAttention | false | 3,805 | [
"MIT"
] | 0 | 526b1b0d463f1c86a45ca4d4cd77a41732c7654b | https://github.com/intflow/trt_openpose/tree/526b1b0d463f1c86a45ca4d4cd77a41732c7654b | import torch
import torch.utils.data
import torch.nn
import torch.optim
class UpsampleCBR(torch.nn.Sequential):
def __init__(self, input_channels, output_channels, count=1, num_flat=0):
layers = []
for i in range(count):
if i == 0:
inch = input_channels
els... |
KLNormal | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
class KLNormal(nn.Module):
def __init__(self):
super(KLNormal, self).__init__()
def forward(self, qm, qv, pm, pv):
element_wise = 0.5 * (torch.log(pv) - torch.log(qv) + qv / pv + (qm -
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
import torch.utils.data
import torch.utils.data.dis... | kayburns/craftassist | KLNormal | false | 3,806 | [
"MIT"
] | 0 | 07909493d320afc2c9ff428d0891bc3acd4dc68f | https://github.com/kayburns/craftassist/tree/07909493d320afc2c9ff428d0891bc3acd4dc68f | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, qm, qv, pm, pv):
element_wise = 0.5 * (torch.log(pv) - torch.log(qv) + qv / pv + (qm -
pm).pow(2) / pv -... |
LabelSmoothingBCE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
class LabelSmoothingBCE(nn.Module):
def __init__(self, smoothing=0.0):
super(LabelSmoothingBCE, self).__init__()
self.criterion = nn.BCEWithLogitsLoss(reduction='none')
self.confidence = 1.0 - 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, math as tl_math
import torc... | kayburns/craftassist | LabelSmoothingBCE | false | 3,810 | [
"MIT"
] | 0 | 07909493d320afc2c9ff428d0891bc3acd4dc68f | https://github.com/kayburns/craftassist/tree/07909493d320afc2c9ff428d0891bc3acd4dc68f | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, smoothing=0.0):
super().__init__()
self.criterion = nn.BCEWithLogitsLoss(reduction='none')
self.confidence = 1.0 - smoothing
self.smoothing = s... |
HighwayLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
def my_xavier_init(m, gain=1):
for p in m.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p, gain)
else:
nn.init.constant_(p, 0)
class HighwayLayer(torch.nn.Module):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | kayburns/craftassist | HighwayLayer | false | 3,811 | [
"MIT"
] | 0 | 07909493d320afc2c9ff428d0891bc3acd4dc68f | https://github.com/kayburns/craftassist/tree/07909493d320afc2c9ff428d0891bc3acd4dc68f | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
def my_xavier_init(m, gain=1):
for p in m.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p, gain)
else:
nn.init.constant_(p, 0)
class Model(torch.nn.Module):
def __i... |
HighwayNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.utils.data.distributed
class HighwayNetwork(nn.Module):
def __init__(self, in_dim, out_dim):
super(HighwayNetwork, self).__init__()
self.gate_proj = nn.Linear(in_dim, out_dim)
self.lin_proj = nn.Linear(in_dim, out_dim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | kayburns/craftassist | HighwayNetwork | false | 3,813 | [
"MIT"
] | 0 | 07909493d320afc2c9ff428d0891bc3acd4dc68f | https://github.com/kayburns/craftassist/tree/07909493d320afc2c9ff428d0891bc3acd4dc68f | import torch
import torch.nn as nn
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, in_dim, out_dim):
super().__init__()
self.gate_proj = nn.Linear(in_dim, out_dim)
self.lin_proj = nn.Linear(in_dim, out_dim)
self.nonlin_proj = ... |
SoftmaxRegression | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
class SoftmaxRegression(torch.nn.Module):
def __init__(self, num_features, num_classes):
super(SoftmaxRegression, self).__init__()
self.linear = torch.nn.Linear(num_features, num_classes)
def forward(self, x):
logits = self.linear(x)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | kbrezinski/stat-453-deep-learning | SoftmaxRegression | false | 3,817 | [
"BSD-3-Clause"
] | 0 | b10240b5c3a970231dcea9221d3d179d26fc197d | https://github.com/kbrezinski/stat-453-deep-learning/tree/b10240b5c3a970231dcea9221d3d179d26fc197d | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self, num_features, num_classes):
super().__init__()
self.linear = torch.nn.Linear(num_features, num_classes)
def forward(self, x):
logits = self.linear(x)
probas = F.softmax(logits, dim=1... |
CustomizedNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.distributed
class CustomizedNet(nn.Module):
def __init__(self, dropout, input_size, input_feature_num, hidden_dim,
output_size):
"""
Simply use linear layers for multi-variate single-step forecasting.
"""
super()._... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | jason-dai/BigDL | CustomizedNet | false | 3,818 | [
"Apache-2.0"
] | 0 | 81ee60a73707d91c58d9bcd5b17c8e5731741a85 | https://github.com/jason-dai/BigDL/tree/81ee60a73707d91c58d9bcd5b17c8e5731741a85 | import torch
import torch.nn as nn
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, dropout, input_size, input_feature_num, hidden_dim,
output_size):
"""
Simply use linear layers for multi-variate single-step forecasting.
"""
super().__init__(... |
DQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class DQN(nn.Module):
def __init__(self, obs_size: 'int', num_actions: 'int', hidden_size:
'int'=20):
super(DQN, self).__init__()
self.l1 = nn.Linear(obs_size, hidden_size)
self.n1 = nn.LayerNorm(hidden_size, elementwise_affine=True)
self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | kcorder/vcg_dqn | DQN | false | 3,819 | [
"MIT"
] | 0 | da43892f701fe88a4c751f209da2743fd824d2f5 | https://github.com/kcorder/vcg_dqn/tree/da43892f701fe88a4c751f209da2743fd824d2f5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, obs_size: 'int', num_actions: 'int', hidden_size:
'int'=20):
super().__init__()
self.l1 = nn.Linear(obs_size, hidden_size)
self.n1 = nn.LayerNorm(hidden_size, elementwise_affine=True)
self.l3 = n... |
ActorNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def init_hidden(layer):
"""
Initialize NN layers
"""
input_size = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(input_size)
return -lim, lim
class ActorNN(nn.Module):
"""
Actor Class
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | kaustav1987/Tennis-Collaboration-and-Competition-Continuous-Control | ActorNN | false | 3,821 | [
"MIT"
] | 0 | d724e09d7a5948e2023fb86bf977455f3c507054 | https://github.com/kaustav1987/Tennis-Collaboration-and-Competition-Continuous-Control/tree/d724e09d7a5948e2023fb86bf977455f3c507054 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def init_hidden(layer):
"""
Initialize NN layers
"""
input_size = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(input_size)
return -lim, lim
class Model(nn.Module):
"""
Actor Class
"""
de... |
FeaturewiseAffine | # 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 typing import Union
import torch.nn as nn
class FeaturewiseAffine(nn.Module):
"""Feature-wise affine layer."""
def __init__(self):
super().__init__()
def forward(self, x, scale: 'Union[float, torch.Tensor]', shift:
'Union[float, torch.Tensor]'):
res = scale * x ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | ketan0/ddim | FeaturewiseAffine | false | 3,822 | [
"MIT"
] | 0 | 26f2de1107885a3f332dd8435b73a1eaedbe10a8 | https://github.com/ketan0/ddim/tree/26f2de1107885a3f332dd8435b73a1eaedbe10a8 | import torch
from typing import Union
import torch.nn as nn
class Model(nn.Module):
"""Feature-wise affine layer."""
def __init__(self):
super().__init__()
def forward(self, x, scale: 'Union[float, torch.Tensor]', shift:
'Union[float, torch.Tensor]'):
res = scale * x + shift
... |
BiAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 typing import Optional
import torch.nn as nn
from torch.nn.parameter import Parameter
class BiAttention(nn.Module):
def __init__(self, input_size_encoder: 'int', input_size_decoder: 'int',
num_labels: 'int', biaffine: 'bool'=True, **kwargs) ->None:
super(BiAttention, self).__ini... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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.parameter import Parameter
assert_size_strid... | katie0809/KLUE-baseline | BiAttention | false | 3,823 | [
"Apache-2.0"
] | 0 | 144973359e9dc3bbbb3ce7a0cc765b0207f63775 | https://github.com/katie0809/KLUE-baseline/tree/144973359e9dc3bbbb3ce7a0cc765b0207f63775 | import torch
from typing import Optional
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, input_size_encoder: 'int', input_size_decoder: 'int',
num_labels: 'int', biaffine: 'bool'=True, **kwargs) ->None:
super().__init__()
self.inpu... |
Mish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
from torch.nn import functional as F
class Mish(nn.Module):
def forward(self, x):
return x.mul_(F.softplus(x).tanh())
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch import nn
assert_size_stride = torch._C._dynamo.gua... | khayliang/single_person_tracking | Mish | false | 3,824 | [
"MIT"
] | 0 | d93aae3742ba3c77f00b3917b182784f03b5d597 | https://github.com/khayliang/single_person_tracking/tree/d93aae3742ba3c77f00b3917b182784f03b5d597 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def forward(self, x):
return x.mul_(F.softplus(x).tanh())
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
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
import torch.utils.data
import torch
import torch.nn as nn
class TripletLoss(nn.Module):
def __init__(self, margin=1.0):
super(TripletLoss, self).__init__()
self.margin = margin
def calc_euclidean(self, x1, x2):
return (x1 - x2).pow(2).sum(1)
def forward(self, ancho... | 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.utils.data
import torch
import torch.nn as nn
assert_size_stride = torch._C.... | ketan-lambat/contrastive-unpaired-translation | TripletLoss | false | 3,825 | [
"BSD-3-Clause"
] | 0 | ea71b3a9603a51b97f1fa8426d5a1beae9260a0d | https://github.com/ketan-lambat/contrastive-unpaired-translation/tree/ea71b3a9603a51b97f1fa8426d5a1beae9260a0d | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, margin=1.0):
super().__init__()
self.margin = margin
def calc_euclidean(self, x1, x2):
return (x1 - x2).pow(2).sum(1)
def forward(self, anchor: 'torch.Tensor', posi... |
CriticNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def init_hidden(layer):
"""
Initialize NN layers
"""
input_size = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(input_size)
return -lim, lim
class CriticNN(nn.Module):
"""
Critic class
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import numpy as np
import tor... | kaustav1987/Tennis-Collaboration-and-Competition-Continuous-Control | CriticNN | false | 3,826 | [
"MIT"
] | 0 | d724e09d7a5948e2023fb86bf977455f3c507054 | https://github.com/kaustav1987/Tennis-Collaboration-and-Competition-Continuous-Control/tree/d724e09d7a5948e2023fb86bf977455f3c507054 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
def init_hidden(layer):
"""
Initialize NN layers
"""
input_size = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(input_size)
return -lim, lim
class Model(nn.Module):
"""
Critic class
"""
d... |
AmdimNCELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def tanh_clip(x, clip_val=10.0):
"""
soft clip values to the range [-clip_val, +clip_val]
"""
if clip_val is not None:
x_clip = clip_val * torch.tanh(1.0 / clip_val * x)
else:
x_clip = x
return x_clip
class AmdimNCELoss(nn.Module):
"""
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jfrancis71/pytorch-lightning-bolts | AmdimNCELoss | false | 3,827 | [
"Apache-2.0"
] | 0 | 8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | https://github.com/jfrancis71/pytorch-lightning-bolts/tree/8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | import torch
import torch.nn as nn
def tanh_clip(x, clip_val=10.0):
"""
soft clip values to the range [-clip_val, +clip_val]
"""
if clip_val is not None:
x_clip = clip_val * torch.tanh(1.0 / clip_val * x)
else:
x_clip = x
return x_clip
class Model(nn.Module):
"""
Comp... |
Swish | # 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 Swish(nn.Module):
def forward(self, x):
return x.mul_(torch.sigmoid(x))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@triton.jit
def triton_poi_fused_mul_sigmoid_0(in_ptr... | khayliang/single_person_tracking | Swish | false | 3,828 | [
"MIT"
] | 0 | d93aae3742ba3c77f00b3917b182784f03b5d597 | https://github.com/khayliang/single_person_tracking/tree/d93aae3742ba3c77f00b3917b182784f03b5d597 | import torch
from torch import nn
class Model(nn.Module):
def forward(self, x):
return x.mul_(torch.sigmoid(x))
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
FakeRKHSConvNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
import torch.nn as nn
class MaybeBatchNorm2d(nn.Module):
def __init__(self, n_ftr, affine, use_bn):
super(MaybeBatchNorm2d, self).__init__()
self.bn = nn.BatchNorm2d(n_ftr, affine=affine)
self.use_bn = use_bn
def forward(self, x):
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.... | jfrancis71/pytorch-lightning-bolts | FakeRKHSConvNet | false | 3,829 | [
"Apache-2.0"
] | 0 | 8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | https://github.com/jfrancis71/pytorch-lightning-bolts/tree/8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | import math
import torch
import numpy as np
import torch.nn as nn
class MaybeBatchNorm2d(nn.Module):
def __init__(self, n_ftr, affine, use_bn):
super().__init__()
self.bn = nn.BatchNorm2d(n_ftr, affine=affine)
self.use_bn = use_bn
def forward(self, x):
if self.use_bn:
... |
SchedulerTestNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.nn import functional as F
class SchedulerTestNet(torch.nn.Module):
"""
adapted from: https://github.com/pytorch/pytorch/blob/master/test/test_optim.py
"""
def __init__(self):
super(SchedulerTestNet, self).__init__()
self.conv1 = torch.nn.Conv2d(1, 1, 1)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C... | jfrancis71/pytorch-lightning-bolts | SchedulerTestNet | false | 3,830 | [
"Apache-2.0"
] | 0 | 8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | https://github.com/jfrancis71/pytorch-lightning-bolts/tree/8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | import torch
from torch.nn import functional as F
class Model(torch.nn.Module):
"""
adapted from: https://github.com/pytorch/pytorch/blob/master/test/test_optim.py
"""
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(1, 1, 1)
self.conv2 = torch.nn.Conv2d(1, ... |
InverseSigmoid | # 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
def inverseSigmoid(y):
"""
inverse of y=torch.sigmoid(y)
:param y:
:return: x
"""
return torch.log(-y / (y - 1))
class InverseSigmoid(torch.nn.Module):
def forward(self, y):
return inverseSigmoid(y)
def get_inputs():
return [torch.rand([4, 4, 4... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.asse... | khoehlein/fV-SRN | InverseSigmoid | false | 3,831 | [
"MIT"
] | 0 | 601f3e952b090df92e875c233c2c9ca646523948 | https://github.com/khoehlein/fV-SRN/tree/601f3e952b090df92e875c233c2c9ca646523948 | import torch
import torch.utils.data
def inverseSigmoid(y):
"""
inverse of y=torch.sigmoid(y)
:param y:
:return: x
"""
return torch.log(-y / (y - 1))
class Model(torch.nn.Module):
def forward(self, y):
return inverseSigmoid(y)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
... |
InverseSoftplus | # 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
def inverseSoftplus(y, beta=1, threshold=20):
"""
inverse of y=torch.nn.functional.softplus(x, beta, threshold)
:param y: the output of the softplus
:param beta: the smoothness of the step
:param threshold: the threshold after which a linear function is used
:return:... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.data
assert_size_stride = torch._C._dynamo.guards.asse... | khoehlein/fV-SRN | InverseSoftplus | false | 3,832 | [
"MIT"
] | 0 | 601f3e952b090df92e875c233c2c9ca646523948 | https://github.com/khoehlein/fV-SRN/tree/601f3e952b090df92e875c233c2c9ca646523948 | import torch
import torch.utils.data
def inverseSoftplus(y, beta=1, threshold=20):
"""
inverse of y=torch.nn.functional.softplus(x, beta, threshold)
:param y: the output of the softplus
:param beta: the smoothness of the step
:param threshold: the threshold after which a linear function is used
:return:... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
import torch.nn.functional as F
class MultiHeadAttention(nn.Module):
def __init__(self, emb_size, n_heads=8, mask=False):
"""
Arguments:
emb_size: Size of input Embeddings
n_heads: Number of heads for MultiHead Attention
Laye... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | kcmankar/TransformerFromScratch | MultiHeadAttention | false | 3,833 | [
"MIT"
] | 0 | 4c68d507f3b0b9713822964e3769283ca0ddc685 | https://github.com/kcmankar/TransformerFromScratch/tree/4c68d507f3b0b9713822964e3769283ca0ddc685 | import math
import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, emb_size, n_heads=8, mask=False):
"""
Arguments:
emb_size: Size of input Embeddings
n_heads: Number of heads for MultiHead Attention
Layers:
... |
decoder3 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.nn as nn
class decoder3(nn.Module):
def __init__(self, W, v2):
super(decoder3, self).__init__()
self.reflecPad7 = nn.ZeroPad2d((1, 1, 1, 1))
self.conv7 = nn.Conv2d(int(256 * W), int(128 * W), 3, 1, 0)
self.relu7 = nn.ReLU(inpl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn
import torch
... | kamieen03/style-transfer-server | decoder3 | false | 3,834 | [
"BSD-2-Clause"
] | 0 | 91727ec62080215a0b870ce043faf0657137b84b | https://github.com/kamieen03/style-transfer-server/tree/91727ec62080215a0b870ce043faf0657137b84b | import torch
import torch.nn
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, W, v2):
super().__init__()
self.reflecPad7 = nn.ZeroPad2d((1, 1, 1, 1))
self.conv7 = nn.Conv2d(int(256 * W), int(128 * W), 3, 1, 0)
self.relu7 = nn.ReLU(inplace=True)
... |
LReluCustom | # 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 LReluCustom(nn.Module):
def __init__(self, leak=0.1):
super(LReluCustom, self).__init__()
self.leak = leak
def forward(self, x):
return torch.max(x, self.leak * x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | kkulczak/phrases_reconstruction_GAN | LReluCustom | false | 3,835 | [
"MIT"
] | 0 | 5cf273416eb714f813a8d603942a442f0933cbff | https://github.com/kkulczak/phrases_reconstruction_GAN/tree/5cf273416eb714f813a8d603942a442f0933cbff | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, leak=0.1):
super().__init__()
self.leak = leak
def forward(self, x):
return torch.max(x, self.leak * x)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
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
class TripletLoss(nn.Module):
"""
Triplet loss
Takes embeddings of an anchor sample, a positive sample and a negative sample
"""
def __init__(self, margin=2.0):
super(TripletLoss, self).__init__()
self.margin = marg... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | kmi-robots/object_reasoner | TripletLoss | false | 3,836 | [
"Apache-2.0"
] | 0 | 2d45bdb3ee745e0d866a152e8d81cbb375fa2985 | https://github.com/kmi-robots/object_reasoner/tree/2d45bdb3ee745e0d866a152e8d81cbb375fa2985 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Triplet loss
Takes embeddings of an anchor sample, a positive sample and a negative sample
"""
def __init__(self, margin=2.0):
super().__init__()
self.margin = margin
def forward(sel... |
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
class Net(torch.nn.Module):
def __init__(self, n_input, n_hidden, n_output):
super(Net, self).__init__()
self.layer1 = torch.nn.Linear(n_input, n_hidden)
self.layer2 = torch.nn.Linear(n_hidden, n_hidden)
self.layer3 = torch.nn.Linear(n_hidden, n_hidden)
self.l... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride ... | kimukook/variable_length_oscillating_pendulum | Net | false | 3,837 | [
"MIT"
] | 0 | 486aa95fe4b9cbaa6cbeb542209259484f48e191 | https://github.com/kimukook/variable_length_oscillating_pendulum/tree/486aa95fe4b9cbaa6cbeb542209259484f48e191 | import torch
class Model(torch.nn.Module):
def __init__(self, n_input, n_hidden, n_output):
super().__init__()
self.layer1 = torch.nn.Linear(n_input, n_hidden)
self.layer2 = torch.nn.Linear(n_hidden, n_hidden)
self.layer3 = torch.nn.Linear(n_hidden, n_hidden)
self.layer4 =... |
Discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
from torch.nn import functional as F
class Discriminator(nn.Module):
def __init__(self, img_shape, hidden_dim=1024):
super().__init__()
in_dim = int(np.prod(img_shape))
self.fc1 = nn.Linear(in_dim, hidden_dim)
self.fc2 = nn.Lin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import numpy as np
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | jfrancis71/pytorch-lightning-bolts | Discriminator | false | 3,838 | [
"Apache-2.0"
] | 0 | 8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | https://github.com/jfrancis71/pytorch-lightning-bolts/tree/8a4cf8f61644c28d6df54ccffe3a52d6f5fce5a6 | import torch
import numpy as np
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, img_shape, hidden_dim=1024):
super().__init__()
in_dim = int(np.prod(img_shape))
self.fc1 = nn.Linear(in_dim, hidden_dim)
self.fc2 = nn.Linear(self... |
ResidualSineLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.utils.data
class ResidualSineLayer(nn.Module):
"""
From Lu & Berger 2021, Compressive Neural Representations of Volumetric Scalar Fields
https://github.com/matthewberger/neurcomp/blob/main/siren.py
"""
def __init__(self, features:... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 numpy ... | khoehlein/fV-SRN | ResidualSineLayer | false | 3,839 | [
"MIT"
] | 0 | 601f3e952b090df92e875c233c2c9ca646523948 | https://github.com/khoehlein/fV-SRN/tree/601f3e952b090df92e875c233c2c9ca646523948 | import torch
import numpy as np
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
From Lu & Berger 2021, Compressive Neural Representations of Volumetric Scalar Fields
https://github.com/matthewberger/neurcomp/blob/main/siren.py
"""
def __init__(self, features: 'int', bias... |
BertPredictionHeadTransform | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
def gelu(x):
"""Gaussian Error Linear Unitという活性化関数です。
LeLUが0でカクっと不連続なので、そこを連続になるように滑らかにした形のLeLUです。
"""
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
class BertLayerNorm(nn.Module):
def __init__(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | kimihitosugiyama/text_analysis | BertPredictionHeadTransform | false | 3,840 | [
"Apache-2.0"
] | 0 | 8f51022957928c31e52af1e0fd407daca3addb40 | https://github.com/kimihitosugiyama/text_analysis/tree/8f51022957928c31e52af1e0fd407daca3addb40 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
def gelu(x):
"""Gaussian Error Linear Unitという活性化関数です。
LeLUが0でカクっと不連続なので、そこを連続になるように滑らかにした形のLeLUです。
"""
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
class BertLayerNorm(nn.Module):
def __init__(... |
BertPreTrainingHeads | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
def gelu(x):
"""Gaussian Error Linear Unitという活性化関数です。
LeLUが0でカクっと不連続なので、そこを連続になるように滑らかにした形のLeLUです。
"""
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
class BertLayerNorm(nn.Module):
def __init__(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
from to... | kimihitosugiyama/text_analysis | BertPreTrainingHeads | false | 3,841 | [
"Apache-2.0"
] | 0 | 8f51022957928c31e52af1e0fd407daca3addb40 | https://github.com/kimihitosugiyama/text_analysis/tree/8f51022957928c31e52af1e0fd407daca3addb40 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
def gelu(x):
"""Gaussian Error Linear Unitという活性化関数です。
LeLUが0でカクっと不連続なので、そこを連続になるように滑らかにした形のLeLUです。
"""
return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
class BertLayerNorm(nn.Module):
def __init__(... |
MSELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def reduction_batch_based(image_loss, M):
divisor = torch.sum(M)
if divisor == 0:
return 0
else:
return torch.sum(image_loss) / divisor
def mse_loss(prediction, target, mask, reduction=reduction_batch_based):
M = torch.sum(mask, (1, 2))
res = pr... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | kopetri/MIDAS_pytorch | MSELoss | false | 3,842 | [
"MIT"
] | 0 | 9e933bd241ee18b487dcd2b65c28a55d8a923292 | https://github.com/kopetri/MIDAS_pytorch/tree/9e933bd241ee18b487dcd2b65c28a55d8a923292 | import torch
import torch.nn as nn
def reduction_batch_based(image_loss, M):
divisor = torch.sum(M)
if divisor == 0:
return 0
else:
return torch.sum(image_loss) / divisor
def mse_loss(prediction, target, mask, reduction=reduction_batch_based):
M = torch.sum(mask, (1, 2))
res = pr... |
QNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class QNetwork(nn.Module):
def __init__(self, statedim, actiondim, hiddendim, init_w=0.0003):
super().__init__()
self.linear1 = nn.Linear(statedim + actiondim, hiddendim)
self.linear2 = nn.Linear(hiddendim, hiddendim)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | kiranprasad/multiagent-particle-envs | QNetwork | false | 3,843 | [
"MIT"
] | 0 | e28e3ff6606e80f11ee16bb2c42f21c442ad29a8 | https://github.com/kiranprasad/multiagent-particle-envs/tree/e28e3ff6606e80f11ee16bb2c42f21c442ad29a8 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, statedim, actiondim, hiddendim, init_w=0.0003):
super().__init__()
self.linear1 = nn.Linear(statedim + actiondim, hiddendim)
self.linear2 = nn.Linear(hiddendim, hiddendim)
... |
FFN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Conv(nn.Module):
"""
Convolution Module
"""
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=0, dilation=1, bias=True, w_init='linear'):
"""
:param in_channels: dimension of input
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | kidconan/fast_speech_trans | FFN | false | 3,844 | [
"MIT"
] | 0 | 4d1d8fe0a871e37165e2a6333a11751ce2a017c0 | https://github.com/kidconan/fast_speech_trans/tree/4d1d8fe0a871e37165e2a6333a11751ce2a017c0 | import torch
import torch.nn as nn
import torch.utils.data
class Conv(nn.Module):
"""
Convolution Module
"""
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=0, dilation=1, bias=True, w_init='linear'):
"""
:param in_channels: dimension of input
... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class ContrastiveLoss(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super(ContrastiveLoss, self).__init__()
self.margin =... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._... | kornellewy/face_one_shot_learing | ContrastiveLoss | false | 3,845 | [
"MIT"
] | 0 | 4cd8c8b1807717f921853043858a6f7ad5259917 | https://github.com/kornellewy/face_one_shot_learing/tree/4cd8c8b1807717f921853043858a6f7ad5259917 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super().__init__()
self.margin = margin
def forward(self, ... |
EmbedNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torchvision.transforms import functional as F
import torch.utils.data
from torch import nn
import torch.nn.functional as F
class EmbedNet(nn.Module):
def __init__(self, cfg):
super(EmbedNet, self).__init__()
self.embed_conv1 = nn.Con... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
from ... | hwfan/mega.pytorch | EmbedNet | false | 3,846 | [
"BSD-2-Clause"
] | 0 | a07b2267daad73c9482233cfe754d59b8ae2f688 | https://github.com/hwfan/mega.pytorch/tree/a07b2267daad73c9482233cfe754d59b8ae2f688 | from _paritybench_helpers import _mock_config
import torch
from torchvision.transforms import functional as F
import torch.utils.data
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, cfg):
super().__init__()
self.embed_conv1 = nn.Conv2d(1024, 512, ke... |
CAM_Use | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 CAM_Use(nn.Module):
""" Channel attention module"""
def __init__(self, in_dim):
super(CAM_Use, self).__init__()
self.chanel_in = in_dim
self.gamma = nn.Parameter(torch.zeros(1))
def forward(self, x, attention):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | jbcnrlz/san | CAM_Use | false | 3,847 | [
"MIT"
] | 0 | 1eab20f83d3c7dba5607e22d1c70768905b62b12 | https://github.com/jbcnrlz/san/tree/1eab20f83d3c7dba5607e22d1c70768905b62b12 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
""" Channel attention module"""
def __init__(self, in_dim):
super().__init__()
self.chanel_in = in_dim
self.gamma = nn.Parameter(torch.zeros(1))
def forward(self, x, attention):
"""
... |
CAM_Calculate | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class CAM_Calculate(nn.Module):
""" Channel attention module"""
def __init__(self, in_dim):
super(CAM_Calculate, self).__init__()
self.chanel_in = in_dim
self.softmax = nn.Softmax(dim=-1)
def forward(self, x):
"""... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | jbcnrlz/san | CAM_Calculate | false | 3,848 | [
"MIT"
] | 0 | 1eab20f83d3c7dba5607e22d1c70768905b62b12 | https://github.com/jbcnrlz/san/tree/1eab20f83d3c7dba5607e22d1c70768905b62b12 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
""" Channel attention module"""
def __init__(self, in_dim):
super().__init__()
self.chanel_in = in_dim
self.softmax = nn.Softmax(dim=-1)
def forward(self, x):
"""
inputs :
... |
FFN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 as t
class Conv(nn.Module):
"""
Convolution Module
"""
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=0, dilation=1, bias=True, w_init='linear'):
"""
:param in_channels: dimension of input
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | kongziyue1234/mooc | FFN | false | 3,849 | [
"MIT"
] | 0 | 3b0c822dd55c1066cbc829137e6c424dcda5067e | https://github.com/kongziyue1234/mooc/tree/3b0c822dd55c1066cbc829137e6c424dcda5067e | import torch
import torch.nn as nn
import torch as t
class Conv(nn.Module):
"""
Convolution Module
"""
def __init__(self, in_channels, out_channels, kernel_size=1, stride=1,
padding=0, dilation=1, bias=True, w_init='linear'):
"""
:param in_channels: dimension of input
... |
PairwiseRankingLoss | # 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 PairwiseRankingLoss(nn.Module):
"""
Pairwise ranking loss
"""
def __init__(self, margin):
super(PairwiseRankingLoss, self).__init__()
self.margin = margin
def forward(self, anchor1, anchor2, img_sentc, sent_imgc):
cost_sent = torch... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | ktodorov/uva-semantics-19 | PairwiseRankingLoss | false | 3,850 | [
"MIT"
] | 0 | c20e4f1d00f6693a8a46dd1d5576cfd3adced896 | https://github.com/ktodorov/uva-semantics-19/tree/c20e4f1d00f6693a8a46dd1d5576cfd3adced896 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Pairwise ranking loss
"""
def __init__(self, margin):
super().__init__()
self.margin = margin
def forward(self, anchor1, anchor2, img_sentc, sent_imgc):
cost_sent = torch.clamp(self.margin - anchor1 + img_sent... |
MeanEncoder | # 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 BaseEncoder(nn.Module):
def __init__(self):
super(BaseEncoder, self).__init__()
self._input_dimensions = 0
@property
def input_dimensions(self):
return self._input_dimensions
class MeanEncoder(BaseEncoder):
def __init__(self):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | ktodorov/uva-semantics-19 | MeanEncoder | false | 3,851 | [
"MIT"
] | 0 | c20e4f1d00f6693a8a46dd1d5576cfd3adced896 | https://github.com/ktodorov/uva-semantics-19/tree/c20e4f1d00f6693a8a46dd1d5576cfd3adced896 | import torch
import torch.nn as nn
class BaseEncoder(nn.Module):
def __init__(self):
super().__init__()
self._input_dimensions = 0
@property
def input_dimensions(self):
return self._input_dimensions
class Model(BaseEncoder):
def __init__(self):
super().__init__()
... |
OneConv3d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import logging
import torch
class OneConv3d(torch.nn.Module):
"""OneConv3d.
"""
def __init__(self, out_channels=2):
super().__init__()
self.layer = torch.nn.Conv3d(in_channels=1, out_channels=
out_channels, kernel_size=3, padding=1)
def forward(self, x):
logging.d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
@triton.jit
de... | kirchhausenlab/incasem | OneConv3d | false | 3,852 | [
"BSD-3-Clause"
] | 0 | ee9e007c5c04571e547e2fb5af5e800bd2d2b435 | https://github.com/kirchhausenlab/incasem/tree/ee9e007c5c04571e547e2fb5af5e800bd2d2b435 | import logging
import torch
class Model(torch.nn.Module):
"""OneConv3d.
"""
def __init__(self, out_channels=2):
super().__init__()
self.layer = torch.nn.Conv3d(in_channels=1, out_channels=
out_channels, kernel_size=3, padding=1)
def forward(self, x):
logging.debug... |
encoder4 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.nn as nn
class encoder4(nn.Module):
def __init__(self):
super(encoder4, self).__init__()
self.conv1 = nn.Conv2d(3, 3, 1, 1, 0)
self.reflecPad1 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv2 = nn.Conv2d(3, 64, 3, 1, 0)
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.... | kamieen03/style-transfer-server | encoder4 | false | 3,853 | [
"BSD-2-Clause"
] | 0 | 91727ec62080215a0b870ce043faf0657137b84b | https://github.com/kamieen03/style-transfer-server/tree/91727ec62080215a0b870ce043faf0657137b84b | import torch
import torch.nn
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 3, 1, 1, 0)
self.reflecPad1 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv2 = nn.Conv2d(3, 64, 3, 1, 0)
self.relu2 = nn.Re... |
AlexNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 AlexNet(nn.Module):
"""
Our first more "succesful" network, slightly modified AlexNet
that accepts images in with 1 channel (i.e. grayscale).
Attributes
----------
c: torch.nn.modules.conv.Conv2d
Applies a 2D convolution over an input signal co... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | jamessoni/x-ray-ML-classification | AlexNet | false | 3,854 | [
"MIT"
] | 0 | 6934f37631d367cdbe813fa6a2cbdc673c64c503 | https://github.com/jamessoni/x-ray-ML-classification/tree/6934f37631d367cdbe813fa6a2cbdc673c64c503 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Our first more "succesful" network, slightly modified AlexNet
that accepts images in with 1 channel (i.e. grayscale).
Attributes
----------
c: torch.nn.modules.conv.Conv2d
Applies a 2D convolution over an input signal comp... |
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
import torch as t
class Linear(nn.Module):
"""
Linear Module
"""
def __init__(self, in_dim, out_dim, bias=True, w_init='linear'):
"""
:param in_dim: dimension of input
:param out_dim: dimension of output
:param bias: boole... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | kongziyue1234/mooc | Attention | false | 3,855 | [
"MIT"
] | 0 | 3b0c822dd55c1066cbc829137e6c424dcda5067e | https://github.com/kongziyue1234/mooc/tree/3b0c822dd55c1066cbc829137e6c424dcda5067e | import math
import torch
import torch.nn as nn
import torch as t
class Linear(nn.Module):
"""
Linear Module
"""
def __init__(self, in_dim, out_dim, bias=True, w_init='linear'):
"""
:param in_dim: dimension of input
:param out_dim: dimension of output
:param bias: boole... |
OrientedIOUloss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class OrientedIOUloss(nn.Module):
def __init__(self, reduction='none', loss_type='iou'):
super(OrientedIOUloss, self).__init__()
self.reduction = reduction
self.loss_type = loss_type
self.loss_mse = nn.MSELoss(reduction=re... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | kuazhangxiaoai/YOLOX | OrientedIOUloss | false | 3,856 | [
"Apache-2.0"
] | 0 | 7aff49b25a8a80c4c33e941da416500eda72b1a2 | https://github.com/kuazhangxiaoai/YOLOX/tree/7aff49b25a8a80c4c33e941da416500eda72b1a2 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, reduction='none', loss_type='iou'):
super().__init__()
self.reduction = reduction
self.loss_type = loss_type
self.loss_mse = nn.MSELoss(reduction=reduction)
def forward(self,... |
ReduceMax | # 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 ReduceMax(torch.nn.Module):
def forward(self, inputs, mask=None):
return torch.amax(inputs, dim=1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | jimthompson5802/ludwig | ReduceMax | false | 3,857 | [
"Apache-2.0"
] | 0 | 8a369328a3f839d9cdb3710be315952c7891d7c0 | https://github.com/jimthompson5802/ludwig/tree/8a369328a3f839d9cdb3710be315952c7891d7c0 | import torch
class Model(torch.nn.Module):
def forward(self, inputs, mask=None):
return torch.amax(inputs, dim=1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
IOUloss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class IOUloss(nn.Module):
def __init__(self, reduction='none', loss_type='iou'):
super(IOUloss, self).__init__()
self.reduction = reduction
self.loss_type = loss_type
def forward(self, pred, target):
assert pred.shape... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dynamo.guard... | kuazhangxiaoai/YOLOX | IOUloss | false | 3,858 | [
"Apache-2.0"
] | 0 | 7aff49b25a8a80c4c33e941da416500eda72b1a2 | https://github.com/kuazhangxiaoai/YOLOX/tree/7aff49b25a8a80c4c33e941da416500eda72b1a2 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, reduction='none', loss_type='iou'):
super().__init__()
self.reduction = reduction
self.loss_type = loss_type
def forward(self, pred, target):
assert pred.shape[0] == target.s... |
BWCEWLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
from typing import Optional
from torch import nn
class LogitsInputsMixin:
@classmethod
def get_loss_inputs(cls):
"""Maps loss to the desired predicted input type."""
return LOGITS
class BWCEWLoss(nn.Module, LogitsInputsMixin):
"""Binary weighted cro... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | jimthompson5802/ludwig | BWCEWLoss | false | 3,859 | [
"Apache-2.0"
] | 0 | 8a369328a3f839d9cdb3710be315952c7891d7c0 | https://github.com/jimthompson5802/ludwig/tree/8a369328a3f839d9cdb3710be315952c7891d7c0 | import torch
from torch import Tensor
from typing import Optional
from torch import nn
class LogitsInputsMixin:
@classmethod
def get_loss_inputs(cls):
"""Maps loss to the desired predicted input type."""
return LOGITS
class Model(nn.Module, LogitsInputsMixin):
"""Binary weighted cross e... |
Scaler | # 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 abc import ABC
class BaseOperator(ABC):
"""
Abstract class defining the basic structure for operator implementations in Hummingbird.
"""
def __init__(self, regression=False, classification=False, transformer=
False, anomaly_detection=False, **kwargs):
"""
Arg... | 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 abc import ABC
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_stri... | kvenkman/hummingbird | Scaler | false | 3,860 | [
"MIT"
] | 0 | dac08f4ff4a4103df4a8e83329a02f2d804bf34d | https://github.com/kvenkman/hummingbird/tree/dac08f4ff4a4103df4a8e83329a02f2d804bf34d | import torch
from abc import ABC
class BaseOperator(ABC):
"""
Abstract class defining the basic structure for operator implementations in Hummingbird.
"""
def __init__(self, regression=False, classification=False, transformer=
False, anomaly_detection=False, **kwargs):
"""
Arg... |
CausalConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn as nn
class CausalConv1d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, dilation=1,
**kwargs):
super().__init__()
self.pad = (kernel_size - 1) * dilation
self.conv = nn.Conv1d(in_channels, out_channels, 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 import nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_s... | kschamplin/astro-classifier-neo | CausalConv1d | false | 3,861 | [
"MIT"
] | 0 | 44fcb8ba41ef549c16360df7fd470f56c42da9b3 | https://github.com/kschamplin/astro-classifier-neo/tree/44fcb8ba41ef549c16360df7fd470f56c42da9b3 | import torch
from torch import nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, dilation=1,
**kwargs):
super().__init__()
self.pad = (kernel_size - 1) * dilation
self.conv = nn.Conv1d(in_channels, out_channels, kernel_size,
pa... |
Multiply | # 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 abc import ABC
class BaseOperator(ABC):
"""
Abstract class defining the basic structure for operator implementations in Hummingbird.
"""
def __init__(self, regression=False, classification=False, transformer=
False, anomaly_detection=False, **kwargs):
"""
Arg... | 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 abc import ABC
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_stri... | kvenkman/hummingbird | Multiply | false | 3,862 | [
"MIT"
] | 0 | dac08f4ff4a4103df4a8e83329a02f2d804bf34d | https://github.com/kvenkman/hummingbird/tree/dac08f4ff4a4103df4a8e83329a02f2d804bf34d | import torch
from abc import ABC
class BaseOperator(ABC):
"""
Abstract class defining the basic structure for operator implementations in Hummingbird.
"""
def __init__(self, regression=False, classification=False, transformer=
False, anomaly_detection=False, **kwargs):
"""
Arg... |
ReduceLast | # 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 sequence_length_3D(sequence: 'torch.Tensor') ->torch.Tensor:
used = torch.sign(torch.amax(torch.abs(sequence), dim=2))
length = torch.sum(used, 1)
length = length.int()
return length
class ReduceLast(torch.nn.Module):
def forward(self, inputs, mask=None):
batch_size = i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
assert_size_stride = t... | jimthompson5802/ludwig | ReduceLast | false | 3,863 | [
"Apache-2.0"
] | 0 | 8a369328a3f839d9cdb3710be315952c7891d7c0 | https://github.com/jimthompson5802/ludwig/tree/8a369328a3f839d9cdb3710be315952c7891d7c0 | import torch
def sequence_length_3D(sequence: 'torch.Tensor') ->torch.Tensor:
used = torch.sign(torch.amax(torch.abs(sequence), dim=2))
length = torch.sum(used, 1)
length = length.int()
return length
class Model(torch.nn.Module):
def forward(self, inputs, mask=None):
batch_size = inputs... |
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 as nn
import torch.nn.functional as F
class ContrastiveLoss(nn.Module):
def __init__(self, margin=1.5):
super(ContrastiveLoss, self).__init__()
self.margin = margin
def forward(self, output1, output2, weight):
pairdist = F.pairwise_distance(output1, outpu... | 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... | kvswim/kv_jhu_cv | ContrastiveLoss | false | 3,864 | [
"MIT"
] | 0 | 2ddf7a9d497aef116a7c043157b8631cea45000d | https://github.com/kvswim/kv_jhu_cv/tree/2ddf7a9d497aef116a7c043157b8631cea45000d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, margin=1.5):
super().__init__()
self.margin = margin
def forward(self, output1, output2, weight):
pairdist = F.pairwise_distance(output1, output2)
contrastive_loss = ... |
SigmoidCrossEntropyLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
from typing import List
from typing import Optional
from typing import Union
from torch import nn
class LogitsInputsMixin:
@classmethod
def get_loss_inputs(cls):
"""Maps loss to the desired predicted input type."""
return LOGITS
class SigmoidCrossEntrop... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | jimthompson5802/ludwig | SigmoidCrossEntropyLoss | false | 3,865 | [
"Apache-2.0"
] | 0 | 8a369328a3f839d9cdb3710be315952c7891d7c0 | https://github.com/jimthompson5802/ludwig/tree/8a369328a3f839d9cdb3710be315952c7891d7c0 | import torch
from torch import Tensor
from typing import List
from typing import Optional
from typing import Union
from torch import nn
class LogitsInputsMixin:
@classmethod
def get_loss_inputs(cls):
"""Maps loss to the desired predicted input type."""
return LOGITS
class Model(nn.Module, L... |
Layer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class Layer(nn.Module):
def __init__(self, input_dim, output_dim, p, name=None):
super(Layer, self).__init__()
self.name = name
self.register_parameter(name='w', param=nn.Parameter(torch.empty(1,
input_dim, out... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | kw-lee/VIforSDEs | Layer | false | 3,866 | [
"MIT"
] | 0 | dcba3832aaad0aebc921a3b0628c43046d651629 | https://github.com/kw-lee/VIforSDEs/tree/dcba3832aaad0aebc921a3b0628c43046d651629 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim, output_dim, p, name=None):
super().__init__()
self.name = name
self.register_parameter(name='w', param=nn.Parameter(torch.empty(1,
input_dim, output_dim), r... |
Block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
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.... | kris927b/ViLT | Block | false | 3,867 | [
"Apache-2.0"
] | 0 | db96f20ebc656f1995aa573cbcbca0fe31f55c42 | https://github.com/kris927b/ViLT/tree/db96f20ebc656f1995aa573cbcbca0fe31f55c42 | import torch
import torch.nn as nn
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
se... |
encoder3 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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
import torch.nn as nn
class encoder3(nn.Module):
def __init__(self, W, v2):
super(encoder3, self).__init__()
self.conv1 = nn.Conv2d(3, 3, 1, 1, 0)
self.reflecPad1 = nn.ZeroPad2d((1, 1, 1, 1))
self.conv2 = nn.Conv2d(3, 32 if v2 else int(64 ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn
import torch
... | kamieen03/style-transfer-server | encoder3 | false | 3,868 | [
"BSD-2-Clause"
] | 0 | 91727ec62080215a0b870ce043faf0657137b84b | https://github.com/kamieen03/style-transfer-server/tree/91727ec62080215a0b870ce043faf0657137b84b | import torch
import torch.nn
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, W, v2):
super().__init__()
self.conv1 = nn.Conv2d(3, 3, 1, 1, 0)
self.reflecPad1 = nn.ZeroPad2d((1, 1, 1, 1))
self.conv2 = nn.Conv2d(3, 32 if v2 else int(64 * W), 3, 1, 0)
... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from collections import OrderedDict
class Actor(nn.Module):
def __init__(self, state_size, action_size, actor_fc_sizes=[256, 128, 64]):
super(Actor, self).__init__()
sequence_dict_actor = OrderedDict()
sequence_dict_actor['fc0'] = nn.Linear(state_size, a... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | kurohi/deepreinforcement-udacity | Actor | false | 3,869 | [
"MIT"
] | 0 | ea8bfcce9a36ca41aa0d7595326b915a494ed5f2 | https://github.com/kurohi/deepreinforcement-udacity/tree/ea8bfcce9a36ca41aa0d7595326b915a494ed5f2 | import torch
import torch.nn as nn
from collections import OrderedDict
class Model(nn.Module):
def __init__(self, state_size, action_size, actor_fc_sizes=[256, 128, 64]):
super().__init__()
sequence_dict_actor = OrderedDict()
sequence_dict_actor['fc0'] = nn.Linear(state_size, actor_fc_siz... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from collections import OrderedDict
class Critic(nn.Module):
def __init__(self, state_size, action_size, critic_fc_sizes=[256, 128, 64]
):
super(Critic, self).__init__()
sequence_dict_critic = OrderedDict()
self.critic_first_layer = nn.Linear(sta... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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 collections import OrderedDict
assert_size_stride = t... | kurohi/deepreinforcement-udacity | Critic | false | 3,870 | [
"MIT"
] | 0 | ea8bfcce9a36ca41aa0d7595326b915a494ed5f2 | https://github.com/kurohi/deepreinforcement-udacity/tree/ea8bfcce9a36ca41aa0d7595326b915a494ed5f2 | import torch
import torch.nn as nn
from collections import OrderedDict
class Model(nn.Module):
def __init__(self, state_size, action_size, critic_fc_sizes=[256, 128, 64]
):
super().__init__()
sequence_dict_critic = OrderedDict()
self.critic_first_layer = nn.Linear(state_size, crit... |
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, act_dim):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(2704, 520)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | krishanrana/robot_learning_algorithms | Model | false | 3,871 | [
"MIT"
] | 0 | 3e66c9bf44e81ff281195130c71bcc6ebdf5ccda | https://github.com/krishanrana/robot_learning_algorithms/tree/3e66c9bf44e81ff281195130c71bcc6ebdf5ccda | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, act_dim):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(2704, 520)
... |
SPP | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
class SPP(nn.Module):
"""
Spatial Pyramid Pooling
"""
def __init__(self):
super(SPP, self).__init__()
def forward(self, x):
x_1 = torch.nn.functional.max_pool2d(x, 5, stride=1, padding=2)
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
import torch.nn as nn
import torch.optim
import torch.utils.data
assert_size_stride = tor... | ldylab/learning_yolo_family_with_pytorch | SPP | false | 3,872 | [
"MIT"
] | 0 | 63fd8d65e5ccd55c9ec124052bbcb040e0d9c549 | https://github.com/ldylab/learning_yolo_family_with_pytorch/tree/63fd8d65e5ccd55c9ec124052bbcb040e0d9c549 | import torch
import torch.nn as nn
import torch.optim
import torch.utils.data
class Model(nn.Module):
"""
Spatial Pyramid Pooling
"""
def __init__(self):
super().__init__()
def forward(self, x):
x_1 = torch.nn.functional.max_pool2d(x, 5, stride=1, padding=2)
x_2 = tor... |
_DynamicGates | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 _DynamicGates(nn.Module):
"""Internal class to wrap the dynamic gate parameters into a dedicated PyTorch Module"""
def __init__(self, cfg: 'Config', input_size: 'int'):
super(_DynamicGates, 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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | kyleniemeyer/neuralhydrology | _DynamicGates | false | 3,873 | [
"BSD-3-Clause"
] | 0 | 440fda715c4f746a2d56b058b9af2f0e03c36aa0 | https://github.com/kyleniemeyer/neuralhydrology/tree/440fda715c4f746a2d56b058b9af2f0e03c36aa0 | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
"""Internal class to wrap the dynamic gate parameters into a dedicated PyTorch Module"""
def __init__(self, cfg: 'Config', input_size: 'int'):
super().__init__()
self.cfg = cfg
sel... |
LIN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.parameter import Parameter
class LIN(nn.Module):
def __init__(self, num_features, eps=1e-05):
super(LIN, self).__init__()
self.eps = eps
self.rho = Parameter(torch.Tensor(1, num_features, 1, 1))
self.gamma = Parameter(torch.Tensor(1... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
from torch.nn.parameter import Parameter
assert_size_stri... | ldzhangyu/photo2cartoon | LIN | false | 3,874 | [
"MIT"
] | 0 | d5b371e77e61018c28109db67e8306e5e6064800 | https://github.com/ldzhangyu/photo2cartoon/tree/d5b371e77e61018c28109db67e8306e5e6064800 | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, num_features, eps=1e-05):
super().__init__()
self.eps = eps
self.rho = Parameter(torch.Tensor(1, num_features, 1, 1))
self.gamma = Parameter(torch.Tensor(1, num_f... |
GlobalAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.cuda
def aeq(*args):
"""
Assert all arguments have the same value
"""
arguments = (arg for arg in args)
first = next(arguments)
assert all(arg == first for arg in arguments
), 'Not all arguments have the same value: ' + str(args)
def 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.... | kurianbenoy/QG-Net | GlobalAttention | false | 3,875 | [
"MIT"
] | 0 | 074c697530aaaa259a3e16467a020846b1085af1 | https://github.com/kurianbenoy/QG-Net/tree/074c697530aaaa259a3e16467a020846b1085af1 | import torch
import torch.nn as nn
import torch.cuda
def aeq(*args):
"""
Assert all arguments have the same value
"""
arguments = (arg for arg in args)
first = next(arguments)
assert all(arg == first for arg in arguments
), 'Not all arguments have the same value: ' + str(args)
def se... |
mnistmodel_C | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class mnistmodel_C(nn.Module):
def __init__(self):
super(mnistmodel_C, self).__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=128, kernel_size
=3, padding=1)
self.conv2 = nn.Conv2d(in_channels=128, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | layel2/layyer-lib | mnistmodel_C | false | 3,876 | [
"MIT"
] | 0 | db48b5c38098ee93d2d34693d98e5ef4d319d919 | https://github.com/layel2/layyer-lib/tree/db48b5c38098ee93d2d34693d98e5ef4d319d919 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=128, kernel_size
=3, padding=1)
self.conv2 = nn.Conv2d(in_channels=128, out_channels=64,
... |
mnistmodel_B | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class mnistmodel_B(nn.Module):
def __init__(self):
super(mnistmodel_B, self).__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=
8, stride=2, padding=3)
self.conv2 = nn.Conv2d(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
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | layel2/layyer-lib | mnistmodel_B | false | 3,877 | [
"MIT"
] | 0 | db48b5c38098ee93d2d34693d98e5ef4d319d919 | https://github.com/layel2/layyer-lib/tree/db48b5c38098ee93d2d34693d98e5ef4d319d919 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=
8, stride=2, padding=3)
self.conv2 = nn.Conv2d(in_channels=64, out_channels=128,... |
discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class discriminator(nn.Module):
def __init__(self):
super(discriminator, self).__init__()
self.d1 = nn.Conv2d(in_channels=1, out_channels=4, kernel_size=2,
stride=2, padding=0)
self.d2 = nn.Conv2d(in_channels=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
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | layel2/layyer-lib | discriminator | false | 3,878 | [
"MIT"
] | 0 | db48b5c38098ee93d2d34693d98e5ef4d319d919 | https://github.com/layel2/layyer-lib/tree/db48b5c38098ee93d2d34693d98e5ef4d319d919 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.d1 = nn.Conv2d(in_channels=1, out_channels=4, kernel_size=2,
stride=2, padding=0)
self.d2 = nn.Conv2d(in_channels=4, out_channels=8, kernel_siz... |
PartialConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
def weights_init(init_type='gaussian'):
def init_fun(m):
classname = m.__class__.__name__
if (classname.find('Conv') == 0 or classname.find('Linear') == 0
) and hasattr(m, 'weight'):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
import torch.nn.parallel
import torch.utils.da... | labcontext/image-inpainting-oldpaper | PartialConv | false | 3,879 | [
"Apache-2.0"
] | 0 | da4683a2c58d662e443ea24ab93fd9d8fcb96bda | https://github.com/labcontext/image-inpainting-oldpaper/tree/da4683a2c58d662e443ea24ab93fd9d8fcb96bda | import math
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
def weights_init(init_type='gaussian'):
def init_fun(m):
classname = m.__class__.__name__
if (classname.find('Conv') == 0 or classname.find('Linear') == 0
) and hasattr(m, 'weight'):
... |
mnistmodel_A | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class mnistmodel_A(nn.Module):
def __init__(self):
super(mnistmodel_A, self).__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=
5, stride=1, padding=2)
self.conv2 = nn.Conv2d(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
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | layel2/layyer-lib | mnistmodel_A | false | 3,880 | [
"MIT"
] | 0 | db48b5c38098ee93d2d34693d98e5ef4d319d919 | https://github.com/layel2/layyer-lib/tree/db48b5c38098ee93d2d34693d98e5ef4d319d919 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=
5, stride=1, padding=2)
self.conv2 = nn.Conv2d(in_channels=64, out_channels=64, ... |
discriminator2 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class discriminator2(nn.Module):
def __init__(self):
super().__init__()
self.d1 = nn.Conv2d(in_channels=1, out_channels=4, kernel_size=3,
stride=1, padding=1)
self.d2 = nn.Conv2d(in_channels=4, out_channels=8, k... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | layel2/layyer-lib | discriminator2 | false | 3,881 | [
"MIT"
] | 0 | db48b5c38098ee93d2d34693d98e5ef4d319d919 | https://github.com/layel2/layyer-lib/tree/db48b5c38098ee93d2d34693d98e5ef4d319d919 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.d1 = nn.Conv2d(in_channels=1, out_channels=4, kernel_size=3,
stride=1, padding=1)
self.d2 = nn.Conv2d(in_channels=4, out_channels=8, kernel_siz... |
nnNorm | # 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 nnNorm(nn.Module):
def __init__(self, dim=-1):
super().__init__()
self.dim = dim
def forward(self, x):
return F.normalize(x, dim=self.dim)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_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 libdevice
import torch.nn as nn
assert... | learning-group-structure/paper | nnNorm | false | 3,882 | [
"MIT"
] | 0 | 96abf7e25cb7e95f45d6eb025257c0ba9e22fc55 | https://github.com/learning-group-structure/paper/tree/96abf7e25cb7e95f45d6eb025257c0ba9e22fc55 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim=-1):
super().__init__()
self.dim = dim
def forward(self, x):
return F.normalize(x, dim=self.dim)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_... |
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
from torch import nn
import torch.nn.functional as F
class HLoss(nn.Module):
"""
Entropy loss used for entropy maximization.
"""
def __init__(self, ignore_index=-1):
super(HLoss, self).__init__()
self.ignore_index = ignore_index
def forward(self, x, labels):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | lemon234071/oc_parlai | HLoss | false | 3,883 | [
"MIT"
] | 0 | 33a0e57c48e58903cb1666e367a7bb9ef012de0c | https://github.com/lemon234071/oc_parlai/tree/33a0e57c48e58903cb1666e367a7bb9ef012de0c | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Entropy loss used for entropy maximization.
"""
def __init__(self, ignore_index=-1):
super().__init__()
self.ignore_index = ignore_index
def forward(self, x, labels):
mask = (lab... |
gen_ab_cf | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class gen_ab_cf(nn.Module):
def __init__(self):
super().__init__()
self.d1 = nn.Conv2d(in_channels=3, out_channels=8, kernel_size=3,
stride=1, padding=1)
self.d2 = nn.Conv2d(in_channels=8, out_channels=16, kerne... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | layel2/layyer-lib | gen_ab_cf | false | 3,884 | [
"MIT"
] | 0 | db48b5c38098ee93d2d34693d98e5ef4d319d919 | https://github.com/layel2/layyer-lib/tree/db48b5c38098ee93d2d34693d98e5ef4d319d919 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.d1 = nn.Conv2d(in_channels=3, out_channels=8, kernel_size=3,
stride=1, padding=1)
self.d2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_si... |
MultiLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
def tensor(x, dtype=torch.float32):
if torch.is_tensor(x):
return x.type(dtype)
x = torch.tensor(x, device=Config.DEVICE, dtype=dtype)
return x
def batch_linear(input, weight, bias=None):
""" input: (N, D), weight: (N, D, H), bias: (N, H)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import numpy as np
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | lchenat/TSA | MultiLinear | false | 3,885 | [
"Apache-2.0"
] | 0 | 661266ba16e06f63962b306a7c30d25f37920c2d | https://github.com/lchenat/TSA/tree/661266ba16e06f63962b306a7c30d25f37920c2d | import torch
import numpy as np
import torch.nn as nn
def tensor(x, dtype=torch.float32):
if torch.is_tensor(x):
return x.type(dtype)
x = torch.tensor(x, device=Config.DEVICE, dtype=dtype)
return x
def batch_linear(input, weight, bias=None):
""" input: (N, D), weight: (N, D, H), bias: (N, H)... |
TransformerBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class TransformerBlock(nn.Module):
def __init__(self, seq_len: 'int', embed_channels: 'int', mlp_dims:
'int', num_heads: 'int'):
super().__init__()
self.embed_channels = embed_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | ketan0/ddim | TransformerBlock | false | 3,886 | [
"MIT"
] | 0 | 26f2de1107885a3f332dd8435b73a1eaedbe10a8 | https://github.com/ketan0/ddim/tree/26f2de1107885a3f332dd8435b73a1eaedbe10a8 | import torch
import torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, seq_len: 'int', embed_channels: 'int', mlp_dims:
'int', num_heads: 'int'):
super().__init__()
self.embed_channels = embed_channels
... |
EntMinLoss | # 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 EntMinLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, f_x):
soft_f_x = F.softmax(f_x, dim=-1)
log_soft_f_x = F.log_softmax(f_x, dim=-1)
ent = -torch.sum(soft_f_x * log_soft_f_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
import torch.nn as nn
... | leoandeol/ldir | EntMinLoss | false | 3,887 | [
"MIT"
] | 0 | f90408c5fb16a52c6c5a76fff1c46b9062343ad5 | https://github.com/leoandeol/ldir/tree/f90408c5fb16a52c6c5a76fff1c46b9062343ad5 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, f_x):
soft_f_x = F.softmax(f_x, dim=-1)
log_soft_f_x = F.log_softmax(f_x, dim=-1)
ent = -torch.sum(soft_f_x * log_soft_f_x) / f_... |
CeCriterion | # 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.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... | 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.nn.modules.... | johnson7788/mt-dnn | CeCriterion | false | 3,888 | [
"MIT"
] | 0 | 26e5c4a5bfdbf1a1dd1c903e606db1c070568237 | https://github.com/johnson7788/mt-dnn/tree/26e5c4a5bfdbf1a1dd1c903e606db1c070568237 | import torch
import torch.nn.functional as F
from torch.nn.modules.loss import _Loss
from torch.optim.lr_scheduler import *
class Criterion(_Loss):
def __init__(self, alpha=1.0, name='criterion'):
super().__init__()
"""Alpha is used to weight each loss term
"""
self.alpha = alpha
... |
gconv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.model_zoo
class gconv(nn.Module):
def __init__(self, channel):
super(gconv, self).__init__()
self.relu = nn.ReLU()
self.conv = nn.Conv2d(channel, channel, kernel_size=3, padding=1)
def forward(self, x):
y = self.conv(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
import ... | lee-zq/MRDN | gconv | false | 3,889 | [
"Apache-2.0"
] | 0 | 976c1f8cd0d4b1943378149ef836bb86dd5fc0cd | https://github.com/lee-zq/MRDN/tree/976c1f8cd0d4b1943378149ef836bb86dd5fc0cd | import torch
import torch.nn as nn
import torch.utils.model_zoo
class Model(nn.Module):
def __init__(self, channel):
super().__init__()
self.relu = nn.ReLU()
self.conv = nn.Conv2d(channel, channel, kernel_size=3, padding=1)
def forward(self, x):
y = self.conv(x)
y = y... |
adaLIN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.parameter import Parameter
class adaLIN(nn.Module):
def __init__(self, num_features, eps=1e-05):
super(adaLIN, self).__init__()
self.eps = eps
self.rho = Parameter(torch.Tensor(1, num_features, 1, 1))
self.rho.data.fill_(0.9)
d... | 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
from torch.nn.parameter import Parameter
assert_size_stri... | ldzhangyu/photo2cartoon | adaLIN | false | 3,890 | [
"MIT"
] | 0 | d5b371e77e61018c28109db67e8306e5e6064800 | https://github.com/ldzhangyu/photo2cartoon/tree/d5b371e77e61018c28109db67e8306e5e6064800 | import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, num_features, eps=1e-05):
super().__init__()
self.eps = eps
self.rho = Parameter(torch.Tensor(1, num_features, 1, 1))
self.rho.data.fill_(0.9)
def forward(se... |
LinearModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class LinearModel(nn.Module):
"""Model creation.
"""
def __init__(self, input_dim, output_dim):
super(LinearModel, self).__init__()
self.layer1 = nn.Linear(input_dim, 50)
self.layer2 = nn.Linear(50, 50)
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | learniotai/iotai-sensor-classifications | LinearModel | false | 3,891 | [
"Apache-2.0"
] | 0 | ba2527cb317afa30a5c495d1cddc16f7dc2936ed | https://github.com/learniotai/iotai-sensor-classifications/tree/ba2527cb317afa30a5c495d1cddc16f7dc2936ed | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""Model creation.
"""
def __init__(self, input_dim, output_dim):
super().__init__()
self.layer1 = nn.Linear(input_dim, 50)
self.layer2 = nn.Linear(50, 50)
self.layer3 = nn.Linear(50... |
_MCLSTMCell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from typing import Tuple
import torch.nn as nn
class _Gate(nn.Module):
"""Utility class to implement a standard sigmoid gate"""
def __init__(self, in_features: 'int', out_features: 'int'):
super(_Gate, self).__init__()
self.fc = nn.Li... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | kyleniemeyer/neuralhydrology | _MCLSTMCell | false | 3,892 | [
"BSD-3-Clause"
] | 0 | 440fda715c4f746a2d56b058b9af2f0e03c36aa0 | https://github.com/kyleniemeyer/neuralhydrology/tree/440fda715c4f746a2d56b058b9af2f0e03c36aa0 | from _paritybench_helpers import _mock_config
import torch
from typing import Tuple
import torch.nn as nn
class _Gate(nn.Module):
"""Utility class to implement a standard sigmoid gate"""
def __init__(self, in_features: 'int', out_features: 'int'):
super().__init__()
self.fc = nn.Linear(in_fea... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.