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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
InputInjection | # 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._C
import torch.serialization
class InputInjection(nn.Module):
"""Downsampling module for CGNet."""
def __init__(self, num_downsampling):
super(InputInjection, self).__init__()
self.pool = nn.ModuleList()
for i in range(num_downsampling)... | 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._C
import torch.serialization
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strid... | AnonSubmission6150/submission6150 | InputInjection | false | 8,975 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
"""Downsampling module for CGNet."""
def __init__(self, num_downsampling):
super().__init__()
self.pool = nn.ModuleList()
for i in range(num_downsampling):
self.pool.appen... |
Policy | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Policy(nn.Module):
def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.affine2 = nn.Linear(128, 2)
self.saved_log_probs = []
self.rewards = []
def forward(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.... | Chandan-h-509/ignite | Policy | false | 8,976 | [
"BSD-3-Clause"
] | 0 | f8c39828cb1dac49b6ef358cdf77865bf2430106 | https://github.com/Chandan-h-509/ignite/tree/f8c39828cb1dac49b6ef358cdf77865bf2430106 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.affine1 = nn.Linear(4, 128)
self.affine2 = nn.Linear(128, 2)
self.saved_log_probs = []
self.rewards = []
def forward(self, x):
... |
DecoderBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.modules.loss import *
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import *
from torch.optim import *
from torch.optim.lr_scheduler import *
class ConvRelu(nn.Module):
"""3x3 convolution followed by ReLU activation building block.
"""
def __init__(self, n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn.modules.loss im... | DBusAI/catalyst | DecoderBlock | false | 8,977 | [
"Apache-2.0"
] | 0 | 4fbdf477ea93b4d3781bf4eb10ae8da1747e4566 | https://github.com/DBusAI/catalyst/tree/4fbdf477ea93b4d3781bf4eb10ae8da1747e4566 | import torch
from torch.nn.modules.loss import *
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import *
from torch.optim import *
from torch.optim.lr_scheduler import *
class ConvRelu(nn.Module):
"""3x3 convolution followed by ReLU activation building block.
"""
def __init__(self, n... |
NormedLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
from torch import nn
class NormedLinear(nn.Linear):
"""Normalized Linear Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | CVPR2022-911/PPH | NormedLinear | false | 8,978 | [
"Apache-2.0"
] | 0 | f066933525aaeef412b8d166ef167f00170b5428 | https://github.com/CVPR2022-911/PPH/tree/f066933525aaeef412b8d166ef167f00170b5428 | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.Linear):
"""Normalized Linear Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value of divi... |
L2Norm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class L2Norm(nn.Module):
def __init__(self, n_dims, scale=20.0, eps=1e-10):
"""L2 normalization layer.
Args:
n_dims (int): Number of dimensions to be normalized
scale (float, optional): Defaults to 20..
eps (float, optional): ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | CVPR2022-911/PPH | L2Norm | false | 8,979 | [
"Apache-2.0"
] | 0 | f066933525aaeef412b8d166ef167f00170b5428 | https://github.com/CVPR2022-911/PPH/tree/f066933525aaeef412b8d166ef167f00170b5428 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, n_dims, scale=20.0, eps=1e-10):
"""L2 normalization layer.
Args:
n_dims (int): Number of dimensions to be normalized
scale (float, optional): Defaults to 20..
eps (float, optional): U... |
FCUDown | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 functools import partial
from torch import nn
class FCUDown(nn.Module):
""" CNN feature maps -> Transformer patch embeddings
"""
def __init__(self, inplanes, outplanes, dw_stride, act_layer=nn.GELU,
norm_layer=partial(nn.LayerNorm, eps=1e-06)):
super(FCUDown, 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
from torch._inductor.runtime.triton_helpers import libdevice
from functools impo... | CVPR2022-911/PPH | FCUDown | false | 8,980 | [
"Apache-2.0"
] | 0 | f066933525aaeef412b8d166ef167f00170b5428 | https://github.com/CVPR2022-911/PPH/tree/f066933525aaeef412b8d166ef167f00170b5428 | import torch
from functools import partial
from torch import nn
class Model(nn.Module):
""" CNN feature maps -> Transformer patch embeddings
"""
def __init__(self, inplanes, outplanes, dw_stride, act_layer=nn.GELU,
norm_layer=partial(nn.LayerNorm, eps=1e-06)):
super().__init__()
s... |
ChannelMixer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
import torch.multiprocessing
import torch.nn
import torch.optim
import torch.distributed
class FeedForward(nn.Module):
def __init__(self, num_features, expansion_factor, dropout):
super().__init__()
num_hidden = expansion_factor * ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | Cardroid/Muskits | ChannelMixer | false | 8,981 | [
"Apache-2.0"
] | 0 | 91708bb243bc671e48893a734aee710c356e4bd8 | https://github.com/Cardroid/Muskits/tree/91708bb243bc671e48893a734aee710c356e4bd8 | import torch
from torch import nn
import torch.nn.functional as F
import torch.multiprocessing
import torch.nn
import torch.optim
import torch.distributed
class FeedForward(nn.Module):
def __init__(self, num_features, expansion_factor, dropout):
super().__init__()
num_hidden = expansion_factor * ... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class ConvLayer(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super(ConvLayer, self).__init__()
reflection_padding = kernel_size // 2
self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
self.conv2d = torch.nn.Conv... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Chandan-h-509/ignite | ResidualBlock | false | 8,982 | [
"BSD-3-Clause"
] | 0 | f8c39828cb1dac49b6ef358cdf77865bf2430106 | https://github.com/Chandan-h-509/ignite/tree/f8c39828cb1dac49b6ef358cdf77865bf2430106 | import torch
class ConvLayer(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super().__init__()
reflection_padding = kernel_size // 2
self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
self.conv2d = torch.nn.Conv2d(in_channels,... |
ClassHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from itertools import product as product
import torch.nn as nn
class ClassHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=3):
super(ClassHead, self).__init__()
self.num_anchors = num_anchors
self.conv1x1 = nn.Conv2d(inchannels, self.num_anchors * 2,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from itertools import product as product
import torch.nn as nn
assert_size_strid... | BossunWang/Pytorch_Retinaface | ClassHead | false | 8,983 | [
"MIT"
] | 0 | 01ec6cfbcced1e8cc8802084e4e566ccaf2513a8 | https://github.com/BossunWang/Pytorch_Retinaface/tree/01ec6cfbcced1e8cc8802084e4e566ccaf2513a8 | import torch
from itertools import product as product
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=3):
super().__init__()
self.num_anchors = num_anchors
self.conv1x1 = nn.Conv2d(inchannels, self.num_anchors * 2,
kernel_size=(1, 1... |
LandmarkHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from itertools import product as product
import torch.nn as nn
class LandmarkHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=3):
super(LandmarkHead, self).__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=
(1, 1), stride=1, padd... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from itertools import product as product
import torch.nn as nn
assert_size_strid... | BossunWang/Pytorch_Retinaface | LandmarkHead | false | 8,984 | [
"MIT"
] | 0 | 01ec6cfbcced1e8cc8802084e4e566ccaf2513a8 | https://github.com/BossunWang/Pytorch_Retinaface/tree/01ec6cfbcced1e8cc8802084e4e566ccaf2513a8 | import torch
from itertools import product as product
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=3):
super().__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 10, kernel_size=
(1, 1), stride=1, padding=0)
def forward(s... |
ExampleBackbone | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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._C
import torch.serialization
class ExampleBackbone(nn.Module):
def __init__(self):
super(ExampleBackbone, self).__init__()
self.conv = nn.Conv2d(3, 3, 3)
def init_weights(self, pretrained=None):
pass
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
import torch.nn as nn
import torch._C
import torch.serialization
assert_size_str... | AnonSubmission6150/submission6150 | ExampleBackbone | false | 8,985 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(3, 3, 3)
def init_weights(self, pretrained=None):
pass
def forward(self, x):
return [self.conv(x)]
def get... |
NormedConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class NormedConv2d(nn.Conv2d):
"""Normalized Conv2d Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value of divisor to
keep ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | CVPR2022-911/PPH | NormedConv2d | false | 8,986 | [
"Apache-2.0"
] | 0 | f066933525aaeef412b8d166ef167f00170b5428 | https://github.com/CVPR2022-911/PPH/tree/f066933525aaeef412b8d166ef167f00170b5428 | import torch
from torch import nn
class Model(nn.Conv2d):
"""Normalized Conv2d Layer.
Args:
tempeature (float, optional): Tempeature term. Default to 20.
power (int, optional): Power term. Default to 1.0.
eps (float, optional): The minimal value of divisor to
keep numeric... |
BboxHead | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from itertools import product as product
import torch.nn as nn
class BboxHead(nn.Module):
def __init__(self, inchannels=512, num_anchors=3):
super(BboxHead, self).__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 4, kernel_size=(
1, 1), stride=1, padding=0)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from itertools import product as product
import torch.nn as nn
assert_size_strid... | BossunWang/Pytorch_Retinaface | BboxHead | false | 8,987 | [
"MIT"
] | 0 | 01ec6cfbcced1e8cc8802084e4e566ccaf2513a8 | https://github.com/BossunWang/Pytorch_Retinaface/tree/01ec6cfbcced1e8cc8802084e4e566ccaf2513a8 | import torch
from itertools import product as product
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inchannels=512, num_anchors=3):
super().__init__()
self.conv1x1 = nn.Conv2d(inchannels, num_anchors * 4, kernel_size=(
1, 1), stride=1, padding=0)
def forward(se... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class LayerNorm(nn.Module):
def __init__(self, num_features, eps=1e-05, affine=True):
super(LayerNorm, self).__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
if self.affine:
self.gamma = nn.Param... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | AnnanShu/gan | LayerNorm | false | 8,988 | [
"MIT"
] | 0 | 0c6409872ce65fe046e620fca053cff553bba9ef | https://github.com/AnnanShu/gan/tree/0c6409872ce65fe046e620fca053cff553bba9ef | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_features, eps=1e-05, affine=True):
super().__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
if self.affine:
self.gamma = nn.Parameter(torch.Tensor(n... |
RSoftmax | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
class RSoftmax(nn.Module):
"""Radix Softmax module in ``SplitAttentionConv2d``.
Args:
radix (int): Radix of input.
groups (int): Groups of input.
"""
def __init__(self, radix... | 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
... | AnonSubmission6150/submission6150 | RSoftmax | false | 8,989 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
"""Radix Softmax module in ``SplitAttentionConv2d``.
Args:
radix (int): Radix of input.
groups (int): Groups of input.
"""
def __init__(self, radix, g... |
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
from torch import Tensor
from torch import nn
class RMSELoss(nn.Module):
""" Root mean square error. """
def __init__(self, **kwargs):
super().__init__()
self.mse = nn.MSELoss(**kwargs)
def forward(self, preds: 'Tensor', target: 'Tensor') ->Tensor:
return torch.sqrt(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_... | Connormcc3/ludwig | RMSELoss | false | 8,990 | [
"Apache-2.0"
] | 0 | 5d562cbc0c4fed3e607969e18611f34240eef177 | https://github.com/Connormcc3/ludwig/tree/5d562cbc0c4fed3e607969e18611f34240eef177 | import torch
from torch import Tensor
from torch import nn
class Model(nn.Module):
""" Root mean square error. """
def __init__(self, **kwargs):
super().__init__()
self.mse = nn.MSELoss(**kwargs)
def forward(self, preds: 'Tensor', target: 'Tensor') ->Tensor:
return torch.sqrt(sel... |
ContrastiveDistanceLoss | # 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.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class ContrastiveDistanceLoss(nn.Module):
"""The Contrastive distance lo... | 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
from torch.nn.modules.loss import *
from torch.nn.modules import *
f... | Casyfill/catalyst | ContrastiveDistanceLoss | false | 8,991 | [
"Apache-2.0"
] | 0 | 7f63545dbc53902c3dd959463def28a67a16a989 | https://github.com/Casyfill/catalyst/tree/7f63545dbc53902c3dd959463def28a67a16a989 | import torch
from torch import nn
from torch.nn.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class Model(nn.Module):
"""The Contrastive distance loss.
@TODO: Do... |
SpatialGatherModule | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
class SpatialGatherModule(nn.Module):
"""Aggregate the context features according to the initial predicted
probability distribution.
Employ the soft-weighted method to aggregate the context.
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | AnonSubmission6150/submission6150 | SpatialGatherModule | false | 8,992 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
"""Aggregate the context features according to the initial predicted
probability distribution.
Employ the soft-weighted method to aggregate the context.
"""
def _... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import functools
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import functools
impor... | AnonSubmission6150/submission6150 | DiceLoss | false | 8,993 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import functools
import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
def reduce_loss(loss, reduction):
"""Reduce loss as specified.
Args:
loss (Tensor): Elementwise loss tensor.
reduction (str): Options are "none", "... |
CrossEntropyLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
def _expand_onehot_labels(labels, label_weights, target_shape, ignore_index):
"""Expand onehot labels to match the size of prediction."""
bin_labels = labels.new_zeros(target_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
from torch._inductor.runtime.triton_helpers import math as tl_math
import numpy as np
imp... | AnonSubmission6150/submission6150 | CrossEntropyLoss | false | 8,994 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
def _expand_onehot_labels(labels, label_weights, target_shape, ignore_index):
"""Expand onehot labels to match the size of prediction."""
bin_labels = labels.new_zeros(target_shape)... |
PTLogreg | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PTLogreg(nn.Module):
def __init__(self, D, C):
"""Arguments:
- D: dimensions of each datapoint
- C: number of classes
"""
super(PTLogreg, self).__init__()
self.W = torch.nn.Parameter(torch.zeros(D, C))
self.b =... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | EduardEdiJerkovic/deeplearning | PTLogreg | false | 8,995 | [
"MIT"
] | 0 | 0493b26ca153f93f41e8de930e16df658fb01a56 | https://github.com/EduardEdiJerkovic/deeplearning/tree/0493b26ca153f93f41e8de930e16df658fb01a56 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, D, C):
"""Arguments:
- D: dimensions of each datapoint
- C: number of classes
"""
super().__init__()
self.W = torch.nn.Parameter(torch.zeros(D, C))
self.b = torch.nn.Paramet... |
Encoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
import torch._C
import torch.serialization
class Encoding(nn.Module):
"""Encoding Layer: a learnable residual encoder.
Input is of shape (batch_size, channels, height, width).
Output is of shape (batch_size, num_codes, channels).
Ar... | 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
... | AnonSubmission6150/submission6150 | Encoding | false | 8,996 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.Module):
"""Encoding Layer: a learnable residual encoder.
Input is of shape (batch_size, channels, height, width).
Output is of shape (batch_size, num_codes, channels).
Args:... |
SquareActivation | # 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 SquareActivation(nn.Module):
"""
Square activation function, clamps the output between 0 and 20 to avoid overflow
"""
@staticmethod
def forward(x):
return torch.clamp(x ** 2, 0, 20)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def ge... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | Ergodice/PWLU | SquareActivation | false | 8,997 | [
"MIT"
] | 0 | 8e714cff4245b9282fe6b9420ffbab8178ba456c | https://github.com/Ergodice/PWLU/tree/8e714cff4245b9282fe6b9420ffbab8178ba456c | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Square activation function, clamps the output between 0 and 20 to avoid overflow
"""
@staticmethod
def forward(x):
return torch.clamp(x ** 2, 0, 20)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inpu... |
PPMConcat | # 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._C
import torch.serialization
class PPMConcat(nn.ModuleList):
"""Pyramid Pooling Module that only concat the features of each layer.
Args:
pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
Module.
"""
def __init__(sel... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch._C
import torch.serialization
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strid... | AnonSubmission6150/submission6150 | PPMConcat | false | 8,998 | [
"Apache-2.0"
] | 0 | 571633d9a12b4fd7a9546947787fc068966dab04 | https://github.com/AnonSubmission6150/submission6150/tree/571633d9a12b4fd7a9546947787fc068966dab04 | import torch
import torch.nn as nn
import torch._C
import torch.serialization
class Model(nn.ModuleList):
"""Pyramid Pooling Module that only concat the features of each layer.
Args:
pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
Module.
"""
def __init__(self, p... |
EDMLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.autograd import Variable
class EDMLoss(nn.Module):
def __init__(self):
super(EDMLoss, self).__init__()
def forward(self, p_target: 'Variable', p_estimate: 'Variable'):
assert p_target.shape == p_estimate.shape
cdf_target = torch.cumsum(p_... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | DazhiZhong/NIMA | EDMLoss | false | 8,999 | [
"MIT"
] | 0 | 82655ac762414ef2a980feba8b6978c605c66a4d | https://github.com/DazhiZhong/NIMA/tree/82655ac762414ef2a980feba8b6978c605c66a4d | import torch
import torch.nn as nn
from torch.autograd import Variable
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, p_target: 'Variable', p_estimate: 'Variable'):
assert p_target.shape == p_estimate.shape
cdf_target = torch.cumsum(p_target, dim=1)
... |
ContrastiveEmbeddingLoss | # 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.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class ContrastiveEmbeddingLoss(nn.Module):
"""The Contrastive embedding ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
from to... | Casyfill/catalyst | ContrastiveEmbeddingLoss | false | 9,000 | [
"Apache-2.0"
] | 0 | 7f63545dbc53902c3dd959463def28a67a16a989 | https://github.com/Casyfill/catalyst/tree/7f63545dbc53902c3dd959463def28a67a16a989 | import torch
from torch import nn
from torch.nn.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class Model(nn.Module):
"""The Contrastive embedding loss.
It has b... |
ycbcr_to_rgb_jpeg | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
class ycbcr_to_rgb_jpeg(nn.Module):
""" Converts YCbCr image to RGB JPEG
Input:
image(tensor): batch x height x width x 3
Outpput:
result(tensor): batch x 3 x height x width
"""
def __init__(self):
super(ycbcr_to_rgb_jp... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | DazhiZhong/DiffJPEG | ycbcr_to_rgb_jpeg | false | 9,001 | [
"MIT"
] | 0 | e20de92539f31a57906ae4c32a41dc46e774c316 | https://github.com/DazhiZhong/DiffJPEG/tree/e20de92539f31a57906ae4c32a41dc46e774c316 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
""" Converts YCbCr image to RGB JPEG
Input:
image(tensor): batch x height x width x 3
Outpput:
result(tensor): batch x 3 x height x width
"""
def __init__(self):
super().__init__()
matrix... |
ContrastivePairwiseEmbeddingLoss | # 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
from torch.nn.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class ContrastivePairwiseEmbeddingLoss(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Casyfill/catalyst | ContrastivePairwiseEmbeddingLoss | false | 9,002 | [
"Apache-2.0"
] | 0 | 7f63545dbc53902c3dd959463def28a67a16a989 | https://github.com/Casyfill/catalyst/tree/7f63545dbc53902c3dd959463def28a67a16a989 | import torch
from torch import nn
from torch.nn import functional as F
from torch.nn.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class Model(nn.Module):
"""Contrast... |
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 BWCEWLoss(nn.Module):
""" Binary weighted cross entropy loss. """
def __init__(self, positive_class_weight: 'Optional[Tensor]'=None,
robust_lambda: 'int'=0, confidence_penalty: 'int'=0, **kwargs):
sup... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | Connormcc3/ludwig | BWCEWLoss | false | 9,003 | [
"Apache-2.0"
] | 0 | 5d562cbc0c4fed3e607969e18611f34240eef177 | https://github.com/Connormcc3/ludwig/tree/5d562cbc0c4fed3e607969e18611f34240eef177 | import torch
from torch import Tensor
from typing import Optional
from torch import nn
class Model(nn.Module):
""" Binary weighted cross entropy loss. """
def __init__(self, positive_class_weight: 'Optional[Tensor]'=None,
robust_lambda: 'int'=0, confidence_penalty: 'int'=0, **kwargs):
super()... |
DQNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import torch
import torch.nn as nn
class DQNetwork(Module):
def __init__(self, num_states, num_actions):
super(DQNetwork, self).__init__()
self.relu = nn.ReLU()
self.fc_layer1 = nn.Linear(num_states, 256)
self.fc_layer2 = nn.Linear(256, 256)
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.nn import Module
i... | Devanshu-singh-VR/Reinforcement-Learning_Mixed | DQNetwork | false | 9,004 | [
"MIT"
] | 0 | 6b8b23977864f918ab8958b729d0faabcca720e4 | https://github.com/Devanshu-singh-VR/Reinforcement-Learning_Mixed/tree/6b8b23977864f918ab8958b729d0faabcca720e4 | from torch.nn import Module
import torch
import torch.nn as nn
class Model(Module):
def __init__(self, num_states, num_actions):
super().__init__()
self.relu = nn.ReLU()
self.fc_layer1 = nn.Linear(num_states, 256)
self.fc_layer2 = nn.Linear(256, 256)
self.q_val = nn.Linear... |
deepQ | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 deepQ(nn.Module):
def __init__(self, action_size, obs_size, hidden_size=256):
super().__init__()
self.input_layer = nn.Linear(obs_size, hidden_size)
self.output_layer = nn.Linear(hidden_size, action_size)
def fo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | ExilesAI/RLAgents | deepQ | false | 9,005 | [
"MIT"
] | 0 | b8159a933c4674c7a62bfe9555870336616a59f3 | https://github.com/ExilesAI/RLAgents/tree/b8159a933c4674c7a62bfe9555870336616a59f3 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, action_size, obs_size, hidden_size=256):
super().__init__()
self.input_layer = nn.Linear(obs_size, hidden_size)
self.output_layer = nn.Linear(hidden_size, action_size)
def fo... |
ArcMarginProduct | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
from torch.nn.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class ArcMarginProduct(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.... | Casyfill/catalyst | ArcMarginProduct | false | 9,006 | [
"Apache-2.0"
] | 0 | 7f63545dbc53902c3dd959463def28a67a16a989 | https://github.com/Casyfill/catalyst/tree/7f63545dbc53902c3dd959463def28a67a16a989 | import torch
from torch import nn
from torch.nn import functional as F
from torch.nn.modules.loss import *
from torch.nn.modules import *
from torch.optim import *
from torch.optim.lr_scheduler import *
import torch.distributed
import torch.multiprocessing
import torch.backends
class Model(nn.Module):
"""Implemen... |
chroma_subsampling | # 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 chroma_subsampling(nn.Module):
""" Chroma subsampling on CbCv channels
Input:
image(tensor): batch x height x width x 3
Output:
y(tensor): batch x height x width
cb(tensor): batch x height/2 x width/2
cr(tensor): batch x height/2 x w... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | DazhiZhong/DiffJPEG | chroma_subsampling | false | 9,007 | [
"MIT"
] | 0 | e20de92539f31a57906ae4c32a41dc46e774c316 | https://github.com/DazhiZhong/DiffJPEG/tree/e20de92539f31a57906ae4c32a41dc46e774c316 | import torch
import torch.nn as nn
class Model(nn.Module):
""" Chroma subsampling on CbCv channels
Input:
image(tensor): batch x height x width x 3
Output:
y(tensor): batch x height x width
cb(tensor): batch x height/2 x width/2
cr(tensor): batch x height/2 x width/2
""... |
BPR | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BPR(nn.Module):
def __init__(self, user_size, item_size, dim, weight_decay):
super().__init__()
self.W = nn.Parameter(torch.empty(user_size, dim))
self.H = nn.Parameter(torch.empty(item_size, dim))
nn.init.xa... | 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... | EternalImmortal/bpr | BPR | false | 9,008 | [
"MIT"
] | 0 | ba95806530e51b580359d22ed533ad461124fa22 | https://github.com/EternalImmortal/bpr/tree/ba95806530e51b580359d22ed533ad461124fa22 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, user_size, item_size, dim, weight_decay):
super().__init__()
self.W = nn.Parameter(torch.empty(user_size, dim))
self.H = nn.Parameter(torch.empty(item_size, dim))
nn.init.... |
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 SigmoidCrossEntropyLoss(nn.Module):
def __init__(self, class_weights: 'Optional[Union[Tensor, List]]'=None,
**kwargs):
"""
Params:
clas... | 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 ... | Connormcc3/ludwig | SigmoidCrossEntropyLoss | false | 9,009 | [
"Apache-2.0"
] | 0 | 5d562cbc0c4fed3e607969e18611f34240eef177 | https://github.com/Connormcc3/ludwig/tree/5d562cbc0c4fed3e607969e18611f34240eef177 | import torch
from torch import Tensor
from typing import List
from typing import Optional
from typing import Union
from torch import nn
class Model(nn.Module):
def __init__(self, class_weights: 'Optional[Union[Tensor, List]]'=None,
**kwargs):
"""
Params:
class_weights: List or... |
MNISTBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MNISTBlock(nn.Module):
def __init__(self, width, scaling=1.0, use_bias=True):
super(MNISTBlock, self).__init__()
self.scaling = scaling
self.linear = nn.Linear(width, width, bias=use_bias)
nn.init.xavier_norm... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | EulerInstitute/mgopt_icml21 | MNISTBlock | false | 9,010 | [
"Apache-2.0"
] | 0 | 3790ac863e22c49e067d2872f7e3ea6e306c65af | https://github.com/EulerInstitute/mgopt_icml21/tree/3790ac863e22c49e067d2872f7e3ea6e306c65af | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, width, scaling=1.0, use_bias=True):
super().__init__()
self.scaling = scaling
self.linear = nn.Linear(width, width, bias=use_bias)
nn.init.xavier_normal_(self.linear.weigh... |
StatsPool | # 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 warnings
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class StatsPool(nn.Module):
"""Statistics pooling
Compute temporal mean and (unbiased) standard deviation
and returns their concatenation.
Reference
---------
htt... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._dynamo.... | FrenchKrab/pyannote-audio | StatsPool | false | 9,011 | [
"MIT"
] | 0 | 14e3b999e3b3fa6063d6401c375a9f7a2534cb74 | https://github.com/FrenchKrab/pyannote-audio/tree/14e3b999e3b3fa6063d6401c375a9f7a2534cb74 | import torch
import warnings
from typing import Optional
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
"""Statistics pooling
Compute temporal mean and (unbiased) standard deviation
and returns their concatenation.
Reference
---------
https:/... |
idct_8x8 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import itertools
import torch
import numpy as np
import torch.nn as nn
class idct_8x8(nn.Module):
""" Inverse discrete Cosine Transformation
Input:
dcp(tensor): batch x height x width
Output:
image(tensor): batch x height x width
"""
def __init__(self):
super(idct_8x8, 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
import itertools
import numpy as np
import torch.nn as nn
assert_size_stride = t... | DazhiZhong/DiffJPEG | idct_8x8 | false | 9,012 | [
"MIT"
] | 0 | e20de92539f31a57906ae4c32a41dc46e774c316 | https://github.com/DazhiZhong/DiffJPEG/tree/e20de92539f31a57906ae4c32a41dc46e774c316 | import itertools
import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
""" Inverse discrete Cosine Transformation
Input:
dcp(tensor): batch x height x width
Output:
image(tensor): batch x height x width
"""
def __init__(self):
super().__init__()
... |
Normal_Model | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class Normal_Model(nn.Module):
"""
Example of a module for modeling a probability distribution. This is set up with all pieces
required for use with the rest of this package. (initial parameters; as well as implimented
constrain, forward, and log_prob methods)
""... | 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
assert_size_stride = torch._C._dynamo.guards.assert... | ExamDay/InfoTorch | Normal_Model | false | 9,013 | [
"MIT"
] | 0 | ef13acce5bd8e76f9c3c8aadd1ab804dda9202e7 | https://github.com/ExamDay/InfoTorch/tree/ef13acce5bd8e76f9c3c8aadd1ab804dda9202e7 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Example of a module for modeling a probability distribution. This is set up with all pieces
required for use with the rest of this package. (initial parameters; as well as implimented
constrain, forward, and log_prob methods)
"""
... |
Network | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Network(nn.Module):
def __init__(self, input_size, nb_action):
super(Network, self).__init__()
self.input_size = input_size
self.nb_action = nb_action
self.fc1 = nn.Linear(input_size, 30)
self.fc2 = n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | ExileExodus/Deep-Reinforcement-Learning | Network | false | 9,014 | [
"MIT"
] | 0 | 0007e5c4b74e920c250a15c18762966e1b55c17d | https://github.com/ExileExodus/Deep-Reinforcement-Learning/tree/0007e5c4b74e920c250a15c18762966e1b55c17d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size, nb_action):
super().__init__()
self.input_size = input_size
self.nb_action = nb_action
self.fc1 = nn.Linear(input_size, 30)
self.fc2 = nn.Linear(30, nb... |
BiasAdd | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
class BiasAdd(nn.Module):
def __init__(self, num_features):
super(BiasAdd, self).__init__()
self.bias = torch.nn.Parameter(torch.Tensor(num_features))
def... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
assert_size_str... | Desmond-97/RepVGG | BiasAdd | false | 9,015 | [
"MIT"
] | 0 | 147490c54ee7b83d4a432a5913b17c8800e55d06 | https://github.com/Desmond-97/RepVGG/tree/147490c54ee7b83d4a432a5913b17c8800e55d06 | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
class Model(nn.Module):
def __init__(self, num_features):
super().__init__()
self.bias = torch.nn.Parameter(torch.Tensor(num_features))
def forward(self, ... |
tofp16 | # 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
import torch.nn.parallel
import torch.utils.data
import torch.optim
import torch.utils.data.distributed
class tofp16(nn.Module):
"""
Utility module that implements::
def forward(self, input):
return input.half()
"""
de... | 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.functional
import torch.nn.parallel
import torch.utils.data
import torch.optim
import torch.utils.data... | DeanChan/apex | tofp16 | false | 9,016 | [
"BSD-3-Clause"
] | 0 | a03267e5e1209f559a6671da56c479a216f418d1 | https://github.com/DeanChan/apex/tree/a03267e5e1209f559a6671da56c479a216f418d1 | import torch
import torch.nn as nn
import torch.nn.functional
import torch.nn.parallel
import torch.utils.data
import torch.optim
import torch.utils.data.distributed
class Model(nn.Module):
"""
Utility module that implements::
def forward(self, input):
return input.half()
"""
def... |
MSBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MSBlock(nn.Module):
def __init__(self, c_in, rate=4):
super(MSBlock, self).__init__()
self.rate = rate
self.conv = nn.Conv2d(c_in, 32, 3, stride=1, padding=1)
self.relu = nn.ReLU(inplace=True)
dilation = self.rate * 1 if self.rate >... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | Ding1119/BDCN-Fiber_Detect | MSBlock | false | 9,017 | [
"MIT"
] | 0 | 7f3db5210a1a87d02c7ef8e79038ba00a8e5ef62 | https://github.com/Ding1119/BDCN-Fiber_Detect/tree/7f3db5210a1a87d02c7ef8e79038ba00a8e5ef62 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, c_in, rate=4):
super().__init__()
self.rate = rate
self.conv = nn.Conv2d(c_in, 32, 3, stride=1, padding=1)
self.relu = nn.ReLU(inplace=True)
dilation = self.rate * 1 if self.rate >= 1 else 1
... |
Classifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.distributed
import torch
import torch.nn as nn
class Classifier(nn.Module):
def __init__(self, hidden_size):
super(Classifier, self).__init__()
self.linear1 = nn.Linear(hidden_size, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x, mask_cls):
h = s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.distributed
import torch
import torch.nn as nn
assert_size_stride =... | EisakuHiguchi/BertSum | Classifier | false | 9,018 | [
"Apache-2.0"
] | 0 | 67177fe025a26c40707d541bcfa0e723f88110da | https://github.com/EisakuHiguchi/BertSum/tree/67177fe025a26c40707d541bcfa0e723f88110da | import torch
import torch.distributed
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.linear1 = nn.Linear(hidden_size, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x, mask_cls):
h = self.linear1(x).squeez... |
LinearMask | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as F
class LinearMask(nn.Linear):
def __init__(self, in_features, out_features, bias=True):
super(LinearMask, self).__init__(in_features, out_features, bias)
def forward(self, x, mask):
params = self.weight * ma... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.optim
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | DMIU-ShELL/deeprl-shell | LinearMask | false | 9,019 | [
"Apache-2.0"
] | 0 | a7845ab1c4967ba2af9486625086c3d0b176d293 | https://github.com/DMIU-ShELL/deeprl-shell/tree/a7845ab1c4967ba2af9486625086c3d0b176d293 | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Linear):
def __init__(self, in_features, out_features, bias=True):
super().__init__(in_features, out_features, bias)
def forward(self, x, mask):
params = self.weight * mask
return F.l... |
Conv_Q | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Conv_Q(nn.Module):
def __init__(self, frames, num_actions):
super(Conv_Q, self).__init__()
self.c1 = nn.Conv2d(frames, 32, kernel_size=8, stride=4)
self.c2 = nn.Conv2d(32, 64, kernel_size=4, 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.... | Altriaex/d4rl_evaluations | Conv_Q | false | 9,020 | [
"Apache-2.0"
] | 0 | ceb34c04e98af9332c6338a1414c0c2aa5fea68b | https://github.com/Altriaex/d4rl_evaluations/tree/ceb34c04e98af9332c6338a1414c0c2aa5fea68b | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, frames, num_actions):
super().__init__()
self.c1 = nn.Conv2d(frames, 32, kernel_size=8, stride=4)
self.c2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)
... |
DCCWeightedELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
import torch.nn as nn
class DCCWeightedELoss(nn.Module):
def __init__(self, size_average=True):
super(DCCWeightedELoss, self).__init__()
self.size_average = size_average
def forward(self, inputs, outputs, weights):
out = (inputs - outputs).view(len(inp... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | Detzy/DCC_childpoet | DCCWeightedELoss | false | 9,021 | [
"MIT"
] | 0 | fc0a90516d7cfe57071801de8e9451381883af78 | https://github.com/Detzy/DCC_childpoet/tree/fc0a90516d7cfe57071801de8e9451381883af78 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, size_average=True):
super().__init__()
self.size_average = size_average
def forward(self, inputs, outputs, weights):
out = (inputs - outputs).view(len(inputs), -1)
out = torch.sum... |
ValueNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ValueNetwork(nn.Module):
def __init__(self):
super(ValueNetwork, self).__init__()
self.relu = nn.ReLU()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 256)
self.fc3 = nn.Linear(256, 1)
def forward(self, x):
x = se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | DeepHaeJoong/reinforcement-learning | ValueNetwork | false | 9,022 | [
"MIT"
] | 0 | 63e3053e3209809e67e97d51adaf5f85ce3799ba | https://github.com/DeepHaeJoong/reinforcement-learning/tree/63e3053e3209809e67e97d51adaf5f85ce3799ba | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.relu = nn.ReLU()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 256)
self.fc3 = nn.Linear(256, 1)
def forward(self, x):
x = self.relu(self.fc1(x))
... |
CNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class CNN(nn.Module):
"""
Convolutional Neural Network.
"""
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 20, kernel_size=5, stride=1)
self.fc1 = nn.Linear(8 * 8 * 20, 64)
self.fc2 = ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | EricZLou/Ax | CNN | false | 9,023 | [
"MIT"
] | 0 | 3f8fc6f4a055e93cb69fda3799be41ee9572ef02 | https://github.com/EricZLou/Ax/tree/3f8fc6f4a055e93cb69fda3799be41ee9572ef02 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Convolutional Neural Network.
"""
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 20, kernel_size=5, stride=1)
self.fc1 = nn.Linear(8 * 8 * 20, 64)
self.fc2 ... |
SEBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
import torch.nn.functional as F
class SEBlock(nn.Module):
def __init__(self, input_channels, internal_neurons):
super(SEBlock, self).__init__()
self.down = 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.parallel
impo... | Desmond-97/RepVGG | SEBlock | false | 9,024 | [
"MIT"
] | 0 | 147490c54ee7b83d4a432a5913b17c8800e55d06 | https://github.com/Desmond-97/RepVGG/tree/147490c54ee7b83d4a432a5913b17c8800e55d06 | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_channels, internal_neurons):
super().__init__()
self.down = nn.Conv2d(in_chann... |
Gaussian | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
import torch.utils.data
class Gaussian(nn.Module):
def __init__(self, in_dim, z_dim):
super(Gaussian, self).__init__()
self.mu = nn.Linear(in_dim, z_dim)
self.var = nn.Linear(in_dim, z_dim)
def reparameterize(self... | import torch
from torch import device
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libd... | Fischer19/GMVAE | Gaussian | false | 9,025 | [
"MIT"
] | 0 | b960e24df8a10e9e07b2111ccb8939dd2556a6c2 | https://github.com/Fischer19/GMVAE/tree/b960e24df8a10e9e07b2111ccb8939dd2556a6c2 | import torch
from torch import nn
from torch.nn import functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_dim, z_dim):
super().__init__()
self.mu = nn.Linear(in_dim, z_dim)
self.var = nn.Linear(in_dim, z_dim)
def reparameterize(self, mu, var):
... |
PolicyNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.distributions import Bernoulli
class PolicyNetwork(nn.Module):
def __init__(self):
super(PolicyNetwork, self).__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 128)
self.fc3 = nn.Linear(128, 1)
self.relu = nn.ReLU... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | DeepHaeJoong/reinforcement-learning | PolicyNetwork | false | 9,026 | [
"MIT"
] | 0 | 63e3053e3209809e67e97d51adaf5f85ce3799ba | https://github.com/DeepHaeJoong/reinforcement-learning/tree/63e3053e3209809e67e97d51adaf5f85ce3799ba | import torch
import torch.nn as nn
from torch.distributions import Bernoulli
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 128)
self.fc3 = nn.Linear(128, 1)
self.relu = nn.ReLU()
self.sigmoid = n... |
NotearsSobolev | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 NotearsSobolev(nn.Module):
def __init__(self, d, k):
"""d: num variables k: num expansion of each variable"""
super(NotearsSobolev, self).__init__()
self.d, self.k = d, k
self.fc1_pos = nn.Linear(d * k, d, bia... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | FrankTianTT/notears | NotearsSobolev | false | 9,027 | [
"Apache-2.0"
] | 0 | ead1e4fa966e29343a393d637320f98ee0cada7c | https://github.com/FrankTianTT/notears/tree/ead1e4fa966e29343a393d637320f98ee0cada7c | import math
import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d, k):
"""d: num variables k: num expansion of each variable"""
super().__init__()
self.d, self.k = d, k
self.fc1_pos = nn.Linear(d * k, d, bias=False)
self.fc1_neg... |
LocallyConnected | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
class LocallyConnected(nn.Module):
"""Local linear layer, i.e. Conv1dLocal() with filter size 1.
Args:
num_linear: num of local linear layers, i.e.
in_features: m1
out_features: m2
bias: whether to include bias or not
Shape:
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.a... | FrankTianTT/notears | LocallyConnected | false | 9,028 | [
"Apache-2.0"
] | 0 | ead1e4fa966e29343a393d637320f98ee0cada7c | https://github.com/FrankTianTT/notears/tree/ead1e4fa966e29343a393d637320f98ee0cada7c | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""Local linear layer, i.e. Conv1dLocal() with filter size 1.
Args:
num_linear: num of local linear layers, i.e.
in_features: m1
out_features: m2
bias: whether to include bias or not
Shape:
- I... |
OneLayerFCBodyWithAction | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as F
def layer_init(layer, w_scale=1.0):
nn.init.orthogonal_(layer.weight.data)
layer.weight.data.mul_(w_scale)
nn.init.constant_(layer.bias.data, 0)
return layer
class OneLayerFCBodyWithAction(nn.Module):
def __in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.optim
import tor... | DMIU-ShELL/deeprl-shell | OneLayerFCBodyWithAction | false | 9,029 | [
"Apache-2.0"
] | 0 | a7845ab1c4967ba2af9486625086c3d0b176d293 | https://github.com/DMIU-ShELL/deeprl-shell/tree/a7845ab1c4967ba2af9486625086c3d0b176d293 | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as F
def layer_init(layer, w_scale=1.0):
nn.init.orthogonal_(layer.weight.data)
layer.weight.data.mul_(w_scale)
nn.init.constant_(layer.bias.data, 0)
return layer
class Model(nn.Module):
def __init__(self, state_di... |
SigmoidFocalClassificationLoss | # 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 SigmoidFocalClassificationLoss(nn.Module):
"""
Sigmoid focal cross entropy loss.
"""
def __init__(self, gamma: 'float'=2.0, alpha: 'float'=0.25):
"""
Args:
gamma: Weighting parameter to balance loss for hard and easy examples.
... | 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... | ElodieShan/OpenPCDet | SigmoidFocalClassificationLoss | false | 9,030 | [
"Apache-2.0"
] | 0 | d23959d70c73b29f3f14462628fa8520a64f2eae | https://github.com/ElodieShan/OpenPCDet/tree/d23959d70c73b29f3f14462628fa8520a64f2eae | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Sigmoid focal cross entropy loss.
"""
def __init__(self, gamma: 'float'=2.0, alpha: 'float'=0.25):
"""
Args:
gamma: Weighting parameter to balance loss for hard and easy examples.
alpha: Weighting p... |
Qnet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import random
import torch
import torch.nn as nn
class Qnet(nn.Module):
def __init__(self, actions=2):
super(Qnet, self).__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 64)
self.fc3 = nn.Linear(64, actions)
self.relu = nn.ReLU()
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 random
import torch.nn... | DeepHaeJoong/reinforcement-learning | Qnet | false | 9,031 | [
"MIT"
] | 0 | 63e3053e3209809e67e97d51adaf5f85ce3799ba | https://github.com/DeepHaeJoong/reinforcement-learning/tree/63e3053e3209809e67e97d51adaf5f85ce3799ba | import random
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, actions=2):
super().__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 64)
self.fc3 = nn.Linear(64, actions)
self.relu = nn.ReLU()
def forward(self, x):
x ... |
FourierFeatures | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
class FourierFeatures(nn.Module):
def __init__(self, in_features, out_features, std=1.0):
super().__init__()
assert out_features % 2 == 0
self.weight = nn.Parameter(torch.randn([out_features // 2,
in_features]) * std)
def forw... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch im... | DeepTitan/v-diffusion-pytorch | FourierFeatures | false | 9,032 | [
"MIT"
] | 0 | 857b6f2a4519973f9a8dc0b6c93f0134cebc3a8d | https://github.com/DeepTitan/v-diffusion-pytorch/tree/857b6f2a4519973f9a8dc0b6c93f0134cebc3a8d | import math
import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_features, out_features, std=1.0):
super().__init__()
assert out_features % 2 == 0
self.weight = nn.Parameter(torch.randn([out_features // 2,
in_features]) * std)
def forward(self, ... |
DuelingQnet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import random
import torch
import torch.nn as nn
import torch.nn.functional as F
class DuelingQnet(nn.Module):
def __init__(self, actions=2):
super(DuelingQnet, self).__init__()
self.fc1 = nn.Linear(4, 128)
self.fc_value = nn.Linear(128, 128)
self.fc_adv = nn.Linear(128, 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
import random
import torch.nn... | DeepHaeJoong/reinforcement-learning | DuelingQnet | false | 9,033 | [
"MIT"
] | 0 | 63e3053e3209809e67e97d51adaf5f85ce3799ba | https://github.com/DeepHaeJoong/reinforcement-learning/tree/63e3053e3209809e67e97d51adaf5f85ce3799ba | import random
import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, actions=2):
super().__init__()
self.fc1 = nn.Linear(4, 128)
self.fc_value = nn.Linear(128, 128)
self.fc_adv = nn.Linear(128, 128)
self.value = nn.Lin... |
Classifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Classifier(nn.Module):
def __init__(self, n_hid, n_out):
super(Classifier, self).__init__()
self.n_hid = n_hid
self.n_out = n_out
self.linear = nn.Linear(n_hid, n_out)
def forward(self, x):
tx = self.linear(x)
return to... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | FengMingquan-sjtu/pyHGT | Classifier | false | 9,034 | [
"MIT"
] | 0 | 3ad1b10ee11358c02fa199667a80c291323e5e2d | https://github.com/FengMingquan-sjtu/pyHGT/tree/3ad1b10ee11358c02fa199667a80c291323e5e2d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, n_hid, n_out):
super().__init__()
self.n_hid = n_hid
self.n_out = n_out
self.linear = nn.Linear(n_hid, n_out)
def forward(self, x):
tx = self.linear(x)
return torch.log_softmax(tx.sq... |
TransformerEncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional
from torch.nn import TransformerEncoderLayer
from torch.nn.modules.activation import MultiheadAttention
from torch.nn.init import xavier_uniform_
from torch.nn.modules.dropout import Dropout
from torc... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Chertushkin/efficient-dl-systems | TransformerEncoderLayer | false | 9,035 | [
"MIT"
] | 0 | 9541dbbbc92f8cf58d0f14c646562e068089aad0 | https://github.com/Chertushkin/efficient-dl-systems/tree/9541dbbbc92f8cf58d0f14c646562e068089aad0 | import torch
from torch import Tensor
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional
from torch.nn import TransformerEncoderLayer
from torch.nn.modules.activation import MultiheadAttention
from torch.nn.init import xavier_uniform_
from torch.nn.modules.dropout import Dropout
from torc... |
DDPGConvBody | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as F
def layer_init(layer, w_scale=1.0):
nn.init.orthogonal_(layer.weight.data)
layer.weight.data.mul_(w_scale)
nn.init.constant_(layer.bias.data, 0)
return layer
class DDPGConvBody(nn.Module):
def __init__(self, i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.optim
... | DMIU-ShELL/deeprl-shell | DDPGConvBody | false | 9,036 | [
"Apache-2.0"
] | 0 | a7845ab1c4967ba2af9486625086c3d0b176d293 | https://github.com/DMIU-ShELL/deeprl-shell/tree/a7845ab1c4967ba2af9486625086c3d0b176d293 | import torch
import torch.optim
import torch.nn as nn
import torch.nn.functional as F
def layer_init(layer, w_scale=1.0):
nn.init.orthogonal_(layer.weight.data)
layer.weight.data.mul_(w_scale)
nn.init.constant_(layer.bias.data, 0)
return layer
class Model(nn.Module):
def __init__(self, in_chann... |
WeightedCrossEntropyLoss | # 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 WeightedCrossEntropyLoss(nn.Module):
"""
Transform input to fit the fomation of PyTorch offical cross entropy loss
with anchor-wise weighting.
"""
def __init__(self):
super(WeightedCrossEntropyLoss, self).__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | ElodieShan/OpenPCDet | WeightedCrossEntropyLoss | false | 9,037 | [
"Apache-2.0"
] | 0 | d23959d70c73b29f3f14462628fa8520a64f2eae | https://github.com/ElodieShan/OpenPCDet/tree/d23959d70c73b29f3f14462628fa8520a64f2eae | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Transform input to fit the fomation of PyTorch offical cross entropy loss
with anchor-wise weighting.
"""
def __init__(self):
super().__init__()
def forward(self, input: 'torch.Tensor', tar... |
FC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn
import torch.utils.checkpoint
import torch.utils.data
import torch.optim
import torch.distributed
import torch.multiprocessing
class FC(torch.nn.Module):
def __init__(self, in_features, out_features, act=torch.nn.ReLU(inplace
=True)):
super().__init__()
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 import triton_helpers
import torch.nn
import torch.... | AndrejOrsula/O-CNN | FC | false | 9,038 | [
"MIT"
] | 0 | e17290a206c3fe23d80873fb21d7243f71e2e9df | https://github.com/AndrejOrsula/O-CNN/tree/e17290a206c3fe23d80873fb21d7243f71e2e9df | import torch
import torch.nn
import torch.utils.checkpoint
import torch.utils.data
import torch.optim
import torch.distributed
import torch.multiprocessing
class Model(torch.nn.Module):
def __init__(self, in_features, out_features, act=torch.nn.ReLU(inplace
=True)):
super().__init__()
sel... |
ShuffleBlock | # 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 ShuffleBlock(nn.Module):
def __init__(self, groups=2):
super(ShuffleBlock, self).__init__()
self.groups = groups
def forward(self, x):
"""Channel shuffle: [N,C,H,W] -> [N,g,C/g,H,W] -> [N,C/g,g,H,w] -> [N,C,H,W]"""
N, C, H, W = x.size(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | BoyuGuan/pytorch-cifar | ShuffleBlock | false | 9,039 | [
"MIT"
] | 0 | b96d0e325c614e8351449d63742fea5d085fdd8e | https://github.com/BoyuGuan/pytorch-cifar/tree/b96d0e325c614e8351449d63742fea5d085fdd8e | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, groups=2):
super().__init__()
self.groups = groups
def forward(self, x):
"""Channel shuffle: [N,C,H,W] -> [N,g,C/g,H,W] -> [N,C/g,g,H,w] -> [N,C,H,W]"""
N, C, H, W = x.size()
g = self.groups... |
ACNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ACNetwork(nn.Module):
def __init__(self, num_actions, num_states):
super(ACNetwork, self).__init__()
self.fc1 = nn.Linear(num_states, 1024)
self.fc2 = nn.Linear(1024, 512)
self.action = nn.Linear(512, num_actions)
self.softmax = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Devanshu-singh-VR/Reinforcement-Learning_Mixed | ACNetwork | false | 9,040 | [
"MIT"
] | 0 | 6b8b23977864f918ab8958b729d0faabcca720e4 | https://github.com/Devanshu-singh-VR/Reinforcement-Learning_Mixed/tree/6b8b23977864f918ab8958b729d0faabcca720e4 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, num_actions, num_states):
super().__init__()
self.fc1 = nn.Linear(num_states, 1024)
self.fc2 = nn.Linear(1024, 512)
self.action = nn.Linear(512, num_actions)
self.softmax = nn.Softmax(1)
... |
SoftQNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SoftQNetwork(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_size, init_w=0.003):
super(SoftQNetwork, self).__init__()
self.linear1 = nn.Linear(num_inputs + num_actions, hidden_size)
self.linear2 = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | FTC-8856/SAC | SoftQNetwork | false | 9,041 | [
"MIT"
] | 0 | 98898d2c4b2ae99b74a8b5a6934d5d3cb91fe5f4 | https://github.com/FTC-8856/SAC/tree/98898d2c4b2ae99b74a8b5a6934d5d3cb91fe5f4 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_size, init_w=0.003):
super().__init__()
self.linear1 = nn.Linear(num_inputs + num_actions, hidden_size)
self.linear2 = nn.Linear(hidden_size, hidde... |
ValueNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ValueNetwork(nn.Module):
def __init__(self, state_dim, hidden_dim, init_w=0.003):
super(ValueNetwork, self).__init__()
self.linear1 = nn.Linear(state_dim, hidden_dim)
self.linear2 = nn.Linear(hidden_dim, hidden_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
assert_... | FTC-8856/SAC | ValueNetwork | false | 9,042 | [
"MIT"
] | 0 | 98898d2c4b2ae99b74a8b5a6934d5d3cb91fe5f4 | https://github.com/FTC-8856/SAC/tree/98898d2c4b2ae99b74a8b5a6934d5d3cb91fe5f4 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, hidden_dim, init_w=0.003):
super().__init__()
self.linear1 = nn.Linear(state_dim, hidden_dim)
self.linear2 = nn.Linear(hidden_dim, hidden_dim)
self.linear3 = nn... |
DistillationLoss | # 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 DistillationLoss(torch.nn.Module):
def __init__(self, temperature: 'float'=1.0):
super().__init__()
self.temperature = 1.0
def forward(self, student_logits, teacher_logits):
teacher_prediction = torch.exp(torch.log_softmax(teacher_logits /
self.temperat... | 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... | Gugutse/Poly-Encoder | DistillationLoss | false | 9,043 | [
"MIT"
] | 0 | aa3151d5accb240c32ac3d54bc785d904f78fcc7 | https://github.com/Gugutse/Poly-Encoder/tree/aa3151d5accb240c32ac3d54bc785d904f78fcc7 | import torch
class Model(torch.nn.Module):
def __init__(self, temperature: 'float'=1.0):
super().__init__()
self.temperature = 1.0
def forward(self, student_logits, teacher_logits):
teacher_prediction = torch.exp(torch.log_softmax(teacher_logits /
self.temperature, dim=-1... |
DenseModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class DenseModel(nn.Module):
def __init__(self, input_shape, output_shape, hidden_size=150,
activation=None):
super(DenseModel, self).__init__()
self.l1 = nn.Linear(input_shape, hidden_size)
self.l2 = nn.Linear(hidden_size, output_shape)
s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | HSE-LAMBDA/pytorch_ard | DenseModel | false | 9,044 | [
"MIT"
] | 0 | b6b40d4c495d3374180698549d8fef0b768ffd3a | https://github.com/HSE-LAMBDA/pytorch_ard/tree/b6b40d4c495d3374180698549d8fef0b768ffd3a | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, input_shape, output_shape, hidden_size=150,
activation=None):
super().__init__()
self.l1 = nn.Linear(input_shape, hidden_size)
self.l2 = nn.Linear(hidden_size, output_shape)
self.activation = acti... |
SelfAttention2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class SelfAttention2d(nn.Module):
def __init__(self, c_in, n_head=1, dropout_rate=0.1):
super().__init__()
assert c_in % n_head == 0
self.norm = nn.GroupNorm(1, c_in)
self.n_head = n_head
self.qkv_proj = nn.Conv2d(c_in, c_in * 3, 1)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | DeepTitan/v-diffusion-pytorch | SelfAttention2d | false | 9,045 | [
"MIT"
] | 0 | 857b6f2a4519973f9a8dc0b6c93f0134cebc3a8d | https://github.com/DeepTitan/v-diffusion-pytorch/tree/857b6f2a4519973f9a8dc0b6c93f0134cebc3a8d | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, c_in, n_head=1, dropout_rate=0.1):
super().__init__()
assert c_in % n_head == 0
self.norm = nn.GroupNorm(1, c_in)
self.n_head = n_head
self.qkv_proj = nn.Conv2d(c_in, c_in * 3, 1)
self.out... |
SE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class SE(nn.Module):
"""Squeeze-and-Excitation block."""
def __init__(self, in_planes, se_planes):
super(SE, self).__init__()
self.se1 = nn.Conv2d(in_planes, se_planes, kernel_size=1, bias=True)
self.se2 = nn.Conv2d(se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | BoyuGuan/pytorch-cifar | SE | false | 9,046 | [
"MIT"
] | 0 | b96d0e325c614e8351449d63742fea5d085fdd8e | https://github.com/BoyuGuan/pytorch-cifar/tree/b96d0e325c614e8351449d63742fea5d085fdd8e | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Squeeze-and-Excitation block."""
def __init__(self, in_planes, se_planes):
super().__init__()
self.se1 = nn.Conv2d(in_planes, se_planes, kernel_size=1, bias=True)
self.se2 = nn.Conv2d(se_plan... |
PolicyNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class PolicyNetwork(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_size, init_w=0.003,
log_std_min=-20, log_std_max=2):
super(PolicyNetwork, self).__init__()
self.log_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | FTC-8856/SAC | PolicyNetwork | false | 9,047 | [
"MIT"
] | 0 | 98898d2c4b2ae99b74a8b5a6934d5d3cb91fe5f4 | https://github.com/FTC-8856/SAC/tree/98898d2c4b2ae99b74a8b5a6934d5d3cb91fe5f4 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Normal
class Model(nn.Module):
def __init__(self, num_inputs, num_actions, hidden_size, init_w=0.003,
log_std_min=-20, log_std_max=2):
super().__init__()
self.log_std_min = log_std_min
... |
Matcher | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
class Matcher(nn.Module):
"""
Matching between a pair of nodes to conduct link prediction.
Use multi-head attention as matching model.
"""
def __init__(self, n_hid):
super(Matcher, self).__init__()
self.left_linear = nn.Linear... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.a... | FengMingquan-sjtu/pyHGT | Matcher | false | 9,048 | [
"MIT"
] | 0 | 3ad1b10ee11358c02fa199667a80c291323e5e2d | https://github.com/FengMingquan-sjtu/pyHGT/tree/3ad1b10ee11358c02fa199667a80c291323e5e2d | import math
import torch
import torch.nn as nn
class Model(nn.Module):
"""
Matching between a pair of nodes to conduct link prediction.
Use multi-head attention as matching model.
"""
def __init__(self, n_hid):
super().__init__()
self.left_linear = nn.Linear(n_hid, n_hid)
... |
GINPreTransition | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 typing
import torch.nn as nn
class MLP(nn.Module):
def __init__(self, input_dim, hidden_sizes: 'typing.Iterable[int]',
out_dim, activation_function=nn.Sigmoid(), activation_out=None):
super(MLP, self).__init__()
i_h_sizes = [input_dim] + hidden_sizes
self.mlp =... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 typing
impor... | FaezehAmou2020/torch_gnn | GINPreTransition | false | 9,049 | [
"BSD-3-Clause"
] | 0 | 996a7f94259e718c625c6b4594729f025c4e4f14 | https://github.com/FaezehAmou2020/torch_gnn/tree/996a7f94259e718c625c6b4594729f025c4e4f14 | import torch
import typing
import torch.nn as nn
class MLP(nn.Module):
def __init__(self, input_dim, hidden_sizes: 'typing.Iterable[int]',
out_dim, activation_function=nn.Sigmoid(), activation_out=None):
super().__init__()
i_h_sizes = [input_dim] + hidden_sizes
self.mlp = nn.Seque... |
Conv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Conv1d(nn.Conv1d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride: Scalar
:param paddin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | CookiePPP/mellotron | Conv1d | false | 9,050 | [
"BSD-3-Clause"
] | 0 | 488425981c19cd0eddddea13d1348da4bfef8d26 | https://github.com/CookiePPP/mellotron/tree/488425981c19cd0eddddea13d1348da4bfef8d26 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Conv1d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride: Scalar
:param padding... |
InstanceSimilarity | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
import torch.nn as nn
class InstanceSimilarity(nn.Module):
"""
Instance Similarity based loss
"""
def __init__(self, mse=True):
super(InstanceSimilarity, self).__init__()
self.mse = mse
def _loss(self, fm_s, fm_t):
fm_s = fm_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.... | DemoAuguste/ZAQ-code | InstanceSimilarity | false | 9,051 | [
"MIT"
] | 0 | 9986a2d217ab5cb284e08c062f8726cabacb311e | https://github.com/DemoAuguste/ZAQ-code/tree/9986a2d217ab5cb284e08c062f8726cabacb311e | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""
Instance Similarity based loss
"""
def __init__(self, mse=True):
super().__init__()
self.mse = mse
def _loss(self, fm_s, fm_t):
fm_s = fm_s.view(fm_s.size(0), -1)
G_s = ... |
GlobalAvgPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
class GlobalAvgPool2d(nn.Module):
def __init__(self):
"""Global average pooling over the input's spatial dimensions"""
super(GlobalAvgPool2d, self).__init__()
def forward(self, inputs):
in_size = inputs.size()
return 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
import torch.utils.data
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._... | GOPIKA-0204/Clothing-Detection-and-Recolouring | GlobalAvgPool2d | false | 9,052 | [
"MIT"
] | 0 | b5d436a981b854228314729b41874f31948a33ba | https://github.com/GOPIKA-0204/Clothing-Detection-and-Recolouring/tree/b5d436a981b854228314729b41874f31948a33ba | import torch
import torch.utils.data
from torch import nn
class Model(nn.Module):
def __init__(self):
"""Global average pooling over the input's spatial dimensions"""
super().__init__()
def forward(self, inputs):
in_size = inputs.size()
return inputs.view((in_size[0], in_size... |
Conv2dSamePadding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
def conv2d_same_padding(input, weight, bias=None, stride=1, dilation=1,
groups=1):
input_rows = input.size(2)
filter_rows = weight.size(2)
effective_filter_size_rows = (filter_rows - 1) * dilation[0] + 1
out_rows = (input_rows + str... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.nn.functional as F
assert_size_stride = torch.... | Florian-P-Huber/pycrop-yield-prediction | Conv2dSamePadding | false | 9,053 | [
"MIT"
] | 0 | 9c1a000db55589b3480ae3ac2baab8f461947855 | https://github.com/Florian-P-Huber/pycrop-yield-prediction/tree/9c1a000db55589b3480ae3ac2baab8f461947855 | import torch
from torch import nn
import torch.nn.functional as F
def conv2d_same_padding(input, weight, bias=None, stride=1, dilation=1,
groups=1):
input_rows = input.size(2)
filter_rows = weight.size(2)
effective_filter_size_rows = (filter_rows - 1) * dilation[0] + 1
out_rows = (input_rows + str... |
Highway | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class Highway(nn.Linear):
"""
:param input_dim: Scalar.
:param drop_rate: Scalar. dropout rate
"""
def __init__(self, input_dim, drop_rate=0.0):
self.drop_rate = drop_rate
super(Highway, self).__init__(input_dim, inpu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | CookiePPP/mellotron | Highway | false | 9,054 | [
"BSD-3-Clause"
] | 0 | 488425981c19cd0eddddea13d1348da4bfef8d26 | https://github.com/CookiePPP/mellotron/tree/488425981c19cd0eddddea13d1348da4bfef8d26 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Linear):
"""
:param input_dim: Scalar.
:param drop_rate: Scalar. dropout rate
"""
def __init__(self, input_dim, drop_rate=0.0):
self.drop_rate = drop_rate
super().__init__(input_dim, input_dim * 2)
... |
HighwayConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Conv1d(nn.Conv1d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride: Scalar
:param paddin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | CookiePPP/mellotron | HighwayConv1d | false | 9,055 | [
"BSD-3-Clause"
] | 0 | 488425981c19cd0eddddea13d1348da4bfef8d26 | https://github.com/CookiePPP/mellotron/tree/488425981c19cd0eddddea13d1348da4bfef8d26 | import torch
import torch.nn as nn
import torch.utils.data
class Conv1d(nn.Conv1d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride: Scalar
:param paddin... |
IIDIsotropicGaussianUVLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch import nn
class IIDIsotropicGaussianUVLoss(nn.Module):
"""
Loss for the case of iid residuals with isotropic covariance:
$Sigma_i = sigma_i^2 I$
The loss (negative log likelihood) is then:
$1/2 sum_{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 libdevice, math as tl_math
import math... | GOPIKA-0204/Clothing-Detection-and-Recolouring | IIDIsotropicGaussianUVLoss | false | 9,056 | [
"MIT"
] | 0 | b5d436a981b854228314729b41874f31948a33ba | https://github.com/GOPIKA-0204/Clothing-Detection-and-Recolouring/tree/b5d436a981b854228314729b41874f31948a33ba | import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch import nn
class Model(nn.Module):
"""
Loss for the case of iid residuals with isotropic covariance:
$Sigma_i = sigma_i^2 I$
The loss (negative log likelihood) is then:
$1/2 sum_{i=1}^n (log(2 pi) + 2 l... |
TransformerNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ConvLayer(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super(ConvLayer, self).__init__()
reflection_padding = kernel_size // 2
self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
self.conv2d = torch.nn.Conv... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Chandan-h-509/ignite | TransformerNet | false | 9,057 | [
"BSD-3-Clause"
] | 0 | f8c39828cb1dac49b6ef358cdf77865bf2430106 | https://github.com/Chandan-h-509/ignite/tree/f8c39828cb1dac49b6ef358cdf77865bf2430106 | import torch
class ConvLayer(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride):
super().__init__()
reflection_padding = kernel_size // 2
self.reflection_pad = torch.nn.ReflectionPad2d(reflection_padding)
self.conv2d = torch.nn.Conv2d(in_channels,... |
Conv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class Conv2d(nn.Conv2d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride: Scalar
:param paddin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | CookiePPP/mellotron | Conv2d | false | 9,058 | [
"BSD-3-Clause"
] | 0 | 488425981c19cd0eddddea13d1348da4bfef8d26 | https://github.com/CookiePPP/mellotron/tree/488425981c19cd0eddddea13d1348da4bfef8d26 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Conv2d):
"""
:param in_channels: Scalar
:param out_channels: Scalar
:param kernel_size: Scalar
:param activation_fn: activation function
:param drop_rate: Scalar. dropout rate
:param stride: Scalar
:param padding... |
ALL_CNN_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 ALL_CNN_C(nn.Module):
def __init__(self, num_classes=10):
super(ALL_CNN_C, self).__init__()
self.model_name = 'ALL_CNN_C'
self.dp0 = nn.Dropout2d(p=0.2)
self.conv1 = nn.Conv2d(3, 96, 3, padding=1)
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 import nn
assert_s... | EIDOSlab/Delving-in-the-loss-landscape-to-embed-robust-watermarks-into-neural-networks | ALL_CNN_C | false | 9,059 | [
"MIT"
] | 0 | 020ea57d48c192cec03c69e66938480cf898b8f2 | https://github.com/EIDOSlab/Delving-in-the-loss-landscape-to-embed-robust-watermarks-into-neural-networks/tree/020ea57d48c192cec03c69e66938480cf898b8f2 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.model_name = 'ALL_CNN_C'
self.dp0 = nn.Dropout2d(p=0.2)
self.conv1 = nn.Conv2d(3, 96, 3, padding=1)
self.conv2 = nn.Conv2d(... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
def set_init(layers):
for layer in layers:
nn.init.normal(layer.weight, mean=0.0, std=0.3)
nn.init.constant(layer.bias, 0.3)
class Net(nn.Module):
def __init__(self, s_dim, a_dim):
super(Net, self).__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional as F
assert_size_stride = torch... | HaiyinPiao/pytorch-a3c | Net | false | 9,060 | [
"MIT"
] | 0 | d151fb4197449610f090c1d687c50a74422f594c | https://github.com/HaiyinPiao/pytorch-a3c/tree/d151fb4197449610f090c1d687c50a74422f594c | import torch
import torch.nn as nn
import torch.nn.functional as F
def set_init(layers):
for layer in layers:
nn.init.normal(layer.weight, mean=0.0, std=0.3)
nn.init.constant(layer.bias, 0.3)
class Model(nn.Module):
def __init__(self, s_dim, a_dim):
super().__init__()
self.s... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Attention(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
.. math::
\\begin{array}{ll}
x = context*output \\\\
attn = exp(x_i) / sum_j exp(x_j) \\\\
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | HanSeokhyeon/speech_recognition_for_multi_language | Attention | false | 9,061 | [
"Apache-2.0"
] | 0 | 6219186146ec4e47dcb7ac46cdb74ca49dad7770 | https://github.com/HanSeokhyeon/speech_recognition_for_multi_language/tree/6219186146ec4e47dcb7ac46cdb74ca49dad7770 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
.. math::
\\begin{array}{ll}
x = context*output \\\\
attn = exp(x_i) / sum_j exp(x_j) \\\\
... |
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 torch
import torch.nn as nn
import torch.utils.data
import torch.nn.functional as F
class MultiHeadAttention(nn.Module):
"""
input:
query --- [N, T_q, query_dim]
key --- [N, T_k, key_dim]
output:
out --- [N, T_q, num_units]
"""
def __init__(self, query_dim, key_dim,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | CookiePPP/mellotron | MultiHeadAttention | false | 9,062 | [
"BSD-3-Clause"
] | 0 | 488425981c19cd0eddddea13d1348da4bfef8d26 | https://github.com/CookiePPP/mellotron/tree/488425981c19cd0eddddea13d1348da4bfef8d26 | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.functional as F
class Model(nn.Module):
"""
input:
query --- [N, T_q, query_dim]
key --- [N, T_k, key_dim]
output:
out --- [N, T_q, num_units]
"""
def __init__(self, query_dim, key_dim, num_units, n... |
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)
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.... | FrameNetBrasil/OpenNMT-py | GlobalAttention | false | 9,063 | [
"MIT"
] | 0 | f14a8f325ec2e482ea9aa6e12fbf3544bc68631b | https://github.com/FrameNetBrasil/OpenNMT-py/tree/f14a8f325ec2e482ea9aa6e12fbf3544bc68631b | 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)
class ... |
BilinearAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BilinearAttention(nn.Module):
"""
:param enc_dim: Scalar.
:param dec_dim: Scalar
"""
def __init__(self, enc_dim, dec_dim):
super(BilinearAttention, self).__init__()
self.W = nn.Linear(enc_dim, dec_dim)
def forw... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | CookiePPP/mellotron | BilinearAttention | false | 9,064 | [
"BSD-3-Clause"
] | 0 | 488425981c19cd0eddddea13d1348da4bfef8d26 | https://github.com/CookiePPP/mellotron/tree/488425981c19cd0eddddea13d1348da4bfef8d26 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
"""
:param enc_dim: Scalar.
:param dec_dim: Scalar
"""
def __init__(self, enc_dim, dec_dim):
super().__init__()
self.W = nn.Linear(enc_dim, dec_dim)
def forward(self, h, s):
"""
... |
SmallAdversarialNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
import torch.nn as nn
class SmallAdversarialNetwork(nn.Module):
def __init__(self, in_feature):
super(SmallAdversarialNetwork, self).__init__()
self.ad_layer1 = nn.Linear(in_feature, 64)
self.ad_layer2 = nn.Linear(64, 1)
self.relu1... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch
import torch.nn as nn
assert_size_stride = ... | FigaroK/pytorch-CycleGAN-and-pix2pix | SmallAdversarialNetwork | false | 9,065 | [
"BSD-3-Clause"
] | 0 | 74407363baf4626782398040e34a342e20915d41 | https://github.com/FigaroK/pytorch-CycleGAN-and-pix2pix/tree/74407363baf4626782398040e34a342e20915d41 | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_feature):
super().__init__()
self.ad_layer1 = nn.Linear(in_feature, 64)
self.ad_layer2 = nn.Linear(64, 1)
self.relu1 = nn.LeakyReLU()
self.dropout1 = nn.Dr... |
Encoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.hub
import torch.nn.functional as F
class Encoder(nn.Module):
"""Estimation of the nonnegative mixture weight by a 1-D conv layer.
"""
def __init__(self, L, N, audio_channels):
super(Encoder, self).__init__()
self.L, self.N = L, N
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 import nn
import t... | FindingBen/demucs-copy | Encoder | false | 9,066 | [
"MIT"
] | 0 | b607e9c91b776eb03bf95a2aa9c4900c92fc7c3f | https://github.com/FindingBen/demucs-copy/tree/b607e9c91b776eb03bf95a2aa9c4900c92fc7c3f | import torch
from torch import nn
import torch.hub
import torch.nn.functional as F
class Model(nn.Module):
"""Estimation of the nonnegative mixture weight by a 1-D conv layer.
"""
def __init__(self, L, N, audio_channels):
super().__init__()
self.L, self.N = L, N
self.conv1d_U = nn... |
UpConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from collections import OrderedDict
import torch.nn as nn
class UpConv(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.up_conv = nn.Sequential(OrderedDict([('up', nn.Upsample(
scale_factor=2)), ('conv', nn.Conv2d(in_channels, in_channels //
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from collections import OrderedDict
import torch.nn as nn
assert_size_stride = t... | HCMUS-ROBOTICS/ssdf-perception | UpConv | false | 9,067 | [
"MIT"
] | 0 | c3eb426397a542da49509bb381972c8ff877597b | https://github.com/HCMUS-ROBOTICS/ssdf-perception/tree/c3eb426397a542da49509bb381972c8ff877597b | import torch
from collections import OrderedDict
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.up_conv = nn.Sequential(OrderedDict([('up', nn.Upsample(
scale_factor=2)), ('conv', nn.Conv2d(in_channels, in_channels //
... |
GramLoss | # 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
from torch.nn import functional as F
class GramLoss(nn.Module):
def __init__(self):
super(GramLoss, self).__init__()
def forward(self, input, target):
input = input.reshape(input.shape[0], input.shape[1], -1)
tar... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | Dimlife/pytorch-CycleGAN-and-pix2pix | GramLoss | false | 9,068 | [
"BSD-3-Clause"
] | 0 | 7f43282e8f816d103e3c0e9e5df008a463cdfdc4 | https://github.com/Dimlife/pytorch-CycleGAN-and-pix2pix/tree/7f43282e8f816d103e3c0e9e5df008a463cdfdc4 | import torch
import torch.utils.data
import torch
import torch.nn as nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, target):
input = input.reshape(input.shape[0], input.shape[1], -1)
target = target.resh... |
StableBCELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
class StableBCELoss(torch.nn.modules.Module):
def __init__(self):
super(StableBCELoss, self).__init__()
def forward(self, input, target):
neg_abs = -input.abs()
loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log()
return ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.utils.dat... | GOPIKA-0204/Clothing-Detection-and-Recolouring | StableBCELoss | false | 9,069 | [
"MIT"
] | 0 | b5d436a981b854228314729b41874f31948a33ba | https://github.com/GOPIKA-0204/Clothing-Detection-and-Recolouring/tree/b5d436a981b854228314729b41874f31948a33ba | import torch
import torch.utils.data
class Model(torch.nn.modules.Module):
def __init__(self):
super().__init__()
def forward(self, input, target):
neg_abs = -input.abs()
loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log()
return loss.mean()
def get_input... |
LittleAdversarialNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
import torch.nn as nn
class LittleAdversarialNetwork(nn.Module):
def __init__(self, in_feature):
super(LittleAdversarialNetwork, self).__init__()
self.ad_layer1 = nn.Linear(in_feature, 1)
self.ad_layer1.weight.data.normal_(0, 0.01)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch
import torch.nn as nn
assert_size_stride = ... | FigaroK/pytorch-CycleGAN-and-pix2pix | LittleAdversarialNetwork | false | 9,070 | [
"BSD-3-Clause"
] | 0 | 74407363baf4626782398040e34a342e20915d41 | https://github.com/FigaroK/pytorch-CycleGAN-and-pix2pix/tree/74407363baf4626782398040e34a342e20915d41 | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_feature):
super().__init__()
self.ad_layer1 = nn.Linear(in_feature, 1)
self.ad_layer1.weight.data.normal_(0, 0.01)
self.ad_layer1.bias.data.fill_(0.0)
self... |
DownConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.nn.functional as F
def conv3x3(in_channels, out_channels, stride=1, padding=1, bias=True, groups=1
):
return nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=
stride, padding=padding, bias=bias, groups=groups)
class D... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | Amadeus9029/Haru | DownConv | false | 9,071 | [
"MIT"
] | 0 | 60396b6cc7ad008e4ae78cb182b6f421197cd7bf | https://github.com/Amadeus9029/Haru/tree/60396b6cc7ad008e4ae78cb182b6f421197cd7bf | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.nn.functional as F
def conv3x3(in_channels, out_channels, stride=1, padding=1, bias=True, groups=1
):
return nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=
stride, padding=padding, bias=bias, groups=groups)
class M... |
AdversarialNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
import torch.nn as nn
class AdversarialNetwork(nn.Module):
def __init__(self, in_feature):
super(AdversarialNetwork, self).__init__()
self.ad_layer1 = nn.Linear(in_feature, 1024)
self.ad_layer2 = nn.Linear(1024, 1024)
self.ad_layer... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch
import torch.nn as nn
assert_size_stride = ... | FigaroK/pytorch-CycleGAN-and-pix2pix | AdversarialNetwork | false | 9,072 | [
"BSD-3-Clause"
] | 0 | 74407363baf4626782398040e34a342e20915d41 | https://github.com/FigaroK/pytorch-CycleGAN-and-pix2pix/tree/74407363baf4626782398040e34a342e20915d41 | import torch
import torch.utils.data
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_feature):
super().__init__()
self.ad_layer1 = nn.Linear(in_feature, 1024)
self.ad_layer2 = nn.Linear(1024, 1024)
self.ad_layer3 = nn.Linear(1024, 1)
self.a... |
ConvNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ConvNet(nn.Module):
def __init__(self, img_size):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.relu = nn.ReLU()
self.padding = nn.ZeroPad2d(1)
self.fc1 = nn.Linear(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
import torch.nn as nn
assert_... | Guojiacheng2017/wasteNet_SH | ConvNet | false | 9,073 | [
"MIT"
] | 0 | cc02e535e52513133fe87094f76a30835dbb0010 | https://github.com/Guojiacheng2017/wasteNet_SH/tree/cc02e535e52513133fe87094f76a30835dbb0010 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, img_size):
super().__init__()
self.conv1 = nn.Conv2d(3, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.relu = nn.ReLU()
self.padding = nn.ZeroPad2d(1)
self.fc1 = nn.Linear(4 * img_size * i... |
IndepAnisotropicGaussianUVLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch import nn
class IndepAnisotropicGaussianUVLoss(nn.Module):
"""
Loss for the case of independent residuals with anisotropic covariances:
$Sigma_i = sigma_i^2 I + r_i r_i^T$
The loss (negative log likelihood... | 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 math... | GOPIKA-0204/Clothing-Detection-and-Recolouring | IndepAnisotropicGaussianUVLoss | false | 9,074 | [
"MIT"
] | 0 | b5d436a981b854228314729b41874f31948a33ba | https://github.com/GOPIKA-0204/Clothing-Detection-and-Recolouring/tree/b5d436a981b854228314729b41874f31948a33ba | import math
import torch
from torch.nn import functional as F
import torch.utils.data
from torch import nn
class Model(nn.Module):
"""
Loss for the case of independent residuals with anisotropic covariances:
$Sigma_i = sigma_i^2 I + r_i r_i^T$
The loss (negative log likelihood) is then:
$1/2 sum_{... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.