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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
GC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
class GC(nn.Module):
def __init__(self, inplanes, planes, kh=7, kw=7):
super(GC, self).__init__()
self.conv_l1 = nn.Conv2d(inplanes, 256, kernel_size=(kh, 1),
padding=(int(kh / 2), 0))
self.conv_l2 = nn.Conv2d(256, pl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.parallel
assert_size_stride = torch._C._dy... | HuaijiaLin/AGSS-VOS | GC | false | 8,250 | [
"MIT"
] | 11 | e9272365aa45bf098316d7111238fe0ab8df8a17 | https://github.com/HuaijiaLin/AGSS-VOS/tree/e9272365aa45bf098316d7111238fe0ab8df8a17 | import torch
import torch.nn as nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, inplanes, planes, kh=7, kw=7):
super().__init__()
self.conv_l1 = nn.Conv2d(inplanes, 256, kernel_size=(kh, 1),
padding=(int(kh / 2), 0))
self.conv_l2 = nn.Conv2d(256, planes,... |
ChannelPool | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.model_zoo
class ChannelPool(nn.Module):
def forward(self, x):
return torch.cat((torch.max(x, 1)[0].unsqueeze(1), torch.mean(x, 1)
.unsqueeze(1)), dim=1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.utils.model_zoo
assert_size_stride = torch._C._dynamo.... | HolmesShuan/AIM2020-Real-Super-Resolution | ChannelPool | false | 8,251 | [
"BSD-2-Clause"
] | 19 | 0ea4d7db0f4f7ed488cc162b90bb08fc02082106 | https://github.com/HolmesShuan/AIM2020-Real-Super-Resolution/tree/0ea4d7db0f4f7ed488cc162b90bb08fc02082106 | import torch
import torch.nn as nn
import torch.utils.model_zoo
class Model(nn.Module):
def forward(self, x):
return torch.cat((torch.max(x, 1)[0].unsqueeze(1), torch.mean(x, 1)
.unsqueeze(1)), dim=1)
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
retur... |
FirstBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BatchNormLayer(nn.Module):
"""Implements batch normalization layer."""
def __init__(self, channels, gamma=False, beta=True, decay=0.9, epsilon
=1e-05):
"""Initializes with basic settings.
Args:
channels: Number of 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
import numpy as np
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | Hsintien-Ng/idinvert_pytorch-reproduced | FirstBlock | false | 8,252 | [
"MIT"
] | 20 | cf3302510573138cf16202add06feae7c93624ea | https://github.com/Hsintien-Ng/idinvert_pytorch-reproduced/tree/cf3302510573138cf16202add06feae7c93624ea | import torch
import numpy as np
import torch.nn as nn
class BatchNormLayer(nn.Module):
"""Implements batch normalization layer."""
def __init__(self, channels, gamma=False, beta=True, decay=0.9, epsilon
=1e-05):
"""Initializes with basic settings.
Args:
channels: Number of channels... |
InstanceNormLayer | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class InstanceNormLayer(nn.Module):
"""Implements instance normalization layer."""
def __init__(self, epsilon=1e-08):
super().__init__()
self.eps = epsilon
def forward(self, x):
if x.ndim != 4:
raise ValueError(
f'The... | 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_... | Hsintien-Ng/idinvert_pytorch-reproduced | InstanceNormLayer | false | 8,253 | [
"MIT"
] | 20 | cf3302510573138cf16202add06feae7c93624ea | https://github.com/Hsintien-Ng/idinvert_pytorch-reproduced/tree/cf3302510573138cf16202add06feae7c93624ea | import torch
import torch.nn as nn
class Model(nn.Module):
"""Implements instance normalization layer."""
def __init__(self, epsilon=1e-08):
super().__init__()
self.eps = epsilon
def forward(self, x):
if x.ndim != 4:
raise ValueError(
f'The input tenso... |
ClipL1 | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.model_zoo
class ClipL1(nn.Module):
def __init__(self, clip_min=0.0, clip_max=10.0):
super(ClipL1, self).__init__()
self.clip_max = clip_max
self.clip_min = clip_min
def forward(self, sr, hr):
loss = torch.mean(torch.clamp(... | 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
... | HolmesShuan/AIM2020-Real-Super-Resolution | ClipL1 | false | 8,254 | [
"BSD-2-Clause"
] | 19 | 0ea4d7db0f4f7ed488cc162b90bb08fc02082106 | https://github.com/HolmesShuan/AIM2020-Real-Super-Resolution/tree/0ea4d7db0f4f7ed488cc162b90bb08fc02082106 | import torch
import torch.nn as nn
import torch.utils.model_zoo
class Model(nn.Module):
def __init__(self, clip_min=0.0, clip_max=10.0):
super().__init__()
self.clip_max = clip_max
self.clip_min = clip_min
def forward(self, sr, hr):
loss = torch.mean(torch.clamp(torch.abs(sr ... |
CosineSimilarity | # 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 CosineSimilarity(nn.Module):
def __init__(self, dim=-1):
super(CosineSimilarity, self).__init__()
self.m = nn.CosineSimilarity(dim=dim)
def forward(self, i, j):
i = F.normalize(i, p=2, dim=-1)
j = F.norm... | 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... | IBM/aihn-ucsd | CosineSimilarity | false | 8,255 | [
"Apache-2.0"
] | 20 | 6c6a56d11c704b529a31868418e350e9760ff9d9 | https://github.com/IBM/aihn-ucsd/tree/6c6a56d11c704b529a31868418e350e9760ff9d9 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim=-1):
super().__init__()
self.m = nn.CosineSimilarity(dim=dim)
def forward(self, i, j):
i = F.normalize(i, p=2, dim=-1)
j = F.normalize(j, p=2, dim=-1)
ret... |
TemporalPooling | # 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.distributions
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class TemporalPooling(nn.Module):
def __init__(self, frames, kernel_size=3, stride=2, mode='avg'):
"""
Parameters
--------... | 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.distributions
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data... | IBM/AdaMML | TemporalPooling | false | 8,256 | [
"Apache-2.0"
] | 32 | be50c02188e6b31ca3a25f285b1b538c137d3d5c | https://github.com/IBM/AdaMML/tree/be50c02188e6b31ca3a25f285b1b538c137d3d5c | import torch
import torch.nn as nn
import torch.distributions
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, frames, kernel_size=3, stride=2, mode='avg'):
"""
Parameters
----------
... |
LastBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BatchNormLayer(nn.Module):
"""Implements batch normalization layer."""
def __init__(self, channels, gamma=False, beta=True, decay=0.9, epsilon
=1e-05):
"""Initializes with basic settings.
Args:
channels: Number of 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
import numpy as np
import torch.nn as nn
assert_size_stride = torch._C._dynamo.g... | Hsintien-Ng/idinvert_pytorch-reproduced | LastBlock | false | 8,257 | [
"MIT"
] | 20 | cf3302510573138cf16202add06feae7c93624ea | https://github.com/Hsintien-Ng/idinvert_pytorch-reproduced/tree/cf3302510573138cf16202add06feae7c93624ea | import torch
import numpy as np
import torch.nn as nn
class BatchNormLayer(nn.Module):
"""Implements batch normalization layer."""
def __init__(self, channels, gamma=False, beta=True, decay=0.9, epsilon
=1e-05):
"""Initializes with basic settings.
Args:
channels: Number of channels... |
Refine | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
class Refine(nn.Module):
def __init__(self, inplanes, planes, scale_factor=2):
super(Refine, self).__init__()
self.convFS1 = nn.Conv2d(inplanes, planes, kernel_size=3, padding=1)
self.convFS2 = 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
import ... | HuaijiaLin/AGSS-VOS | Refine | false | 8,258 | [
"MIT"
] | 11 | e9272365aa45bf098316d7111238fe0ab8df8a17 | https://github.com/HuaijiaLin/AGSS-VOS/tree/e9272365aa45bf098316d7111238fe0ab8df8a17 | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, inplanes, planes, scale_factor=2):
super().__init__()
self.convFS1 = nn.Conv2d(inplanes, planes, kernel_size=3, padding=1)
self.convFS2 = nn.Conv2d(planes... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Critic(nn.Module):
def __init__(self, state_dim, action_dim):
super(Critic, self).__init__()
self.l1 = nn.Linear(state_dim + action_dim, 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, 1)
def... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | HzcIrving/DLRL_PlayGround | Critic | false | 8,259 | [
"MIT"
] | 27 | 0db9a4bdb87130d1d26aea1591ef74cbe6aaa43b | https://github.com/HzcIrving/DLRL_PlayGround/tree/0db9a4bdb87130d1d26aea1591ef74cbe6aaa43b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, action_dim):
super().__init__()
self.l1 = nn.Linear(state_dim + action_dim, 400)
self.l2 = nn.Linear(400, 300)
self.l3 = nn.Linear(300, 1)
def forward(self... |
partCE | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class partCE(nn.Module):
def __init__(self, if_average=False):
super(partCE, self).__init__()
self.crit = nn.CrossEntropyLoss(size_average=if_average)
self.maximum_score = 100000
def forward(self, scores, target):
par... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | INK-USC/shifted-label-distribution | partCE | false | 8,260 | [
"Apache-2.0"
] | 37 | 3cf2b7ced3b2e18234db405f6014f049c4830d71 | https://github.com/INK-USC/shifted-label-distribution/tree/3cf2b7ced3b2e18234db405f6014f049c4830d71 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, if_average=False):
super().__init__()
self.crit = nn.CrossEntropyLoss(size_average=if_average)
self.maximum_score = 100000
def forward(self, scores, target):
par_scores = sco... |
one_conv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class one_conv(nn.Module):
def __init__(self, G0, G):
super(one_conv, self).__init__()
self.conv = nn.Conv2d(G0, G, kernel_size=3, stride=1, padding=1,
bias=True)
self.relu = nn.LeakyReLU(0.1, inplace=True)
def forward(self, x):
o... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | Holmes-Alan/RefVAE | one_conv | false | 8,261 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, G0, G):
super().__init__()
self.conv = nn.Conv2d(G0, G, kernel_size=3, stride=1, padding=1,
bias=True)
self.relu = nn.LeakyReLU(0.1, inplace=True)
def forward(self, x):
output = self.relu... |
ConvBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ConvBlock(torch.nn.Module):
def __init__(self, input_size, output_size, kernel_size, stride,
padding, bias=True):
super(ConvBlock, self).__init__()
self.conv = torch.nn.Conv2d(input_size, output_size, kernel_size,
stride, padding, bias=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.triton_helpers import libdevice
from torch import n... | Holmes-Alan/RefVAE | ConvBlock | false | 8,262 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class Model(torch.nn.Module):
def __init__(self, input_size, output_size, kernel_size, stride,
padding, bias=True):
super().__init__()
self.conv = torch.nn.Conv2d(input_size, output_size, kernel_size,
stride, padding, bias=bias)
self.a... |
BilinearMap | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch as th
import torch.nn as nn
from torch.nn.parameter import Parameter
class BilinearMap(nn.Module):
def __init__(self, nunits):
super(BilinearMap, self).__init__()
self.map = Parameter(th.Tensor(nunits, nunits))
self.nunits = nunits
self.reset_parameters()... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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 as th
import torch.nn as nn
from torch.nn.parameter import Paramete... | IBM/aihn-ucsd | BilinearMap | false | 8,263 | [
"Apache-2.0"
] | 20 | 6c6a56d11c704b529a31868418e350e9760ff9d9 | https://github.com/IBM/aihn-ucsd/tree/6c6a56d11c704b529a31868418e350e9760ff9d9 | import torch
import torch as th
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, nunits):
super().__init__()
self.map = Parameter(th.Tensor(nunits, nunits))
self.nunits = nunits
self.reset_parameters()
def reset_paramet... |
ResnetBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class ResnetBlock(torch.nn.Module):
def __init__(self, num_filter, kernel_size=3, stride=1, padding=1, bias
=True):
super(ResnetBlock, self).__init__()
self.conv1 = torch.nn.Conv2d(num_filter, num_filter, kernel_size,
stride, padding, bias=bias)
self.conv2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cu... | Holmes-Alan/RefVAE | ResnetBlock | false | 8,264 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
class Model(torch.nn.Module):
def __init__(self, num_filter, kernel_size=3, stride=1, padding=1, bias
=True):
super().__init__()
self.conv1 = torch.nn.Conv2d(num_filter, num_filter, kernel_size,
stride, padding, bias=bias)
self.conv2 = torch.nn.Conv2d(num_... |
dnn | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 dnn(nn.Module):
def weight_init(self):
nn.init.xavier_uniform_(self.fc1.weight)
nn.init.xavier_uniform_(self.fc2.weight)
nn.init.xavier_uniform_(self.fc3.weight)
nn.init.xavier_uniform_(self.out.weight)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Harshitmalaviya/whisper-to-normal-speech-conversion | dnn | false | 8,265 | [
"MIT"
] | 23 | a6d411b27a3c5cc4ad12e3968350b22d88b9b4d9 | https://github.com/Harshitmalaviya/whisper-to-normal-speech-conversion/tree/a6d411b27a3c5cc4ad12e3968350b22d88b9b4d9 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def weight_init(self):
nn.init.xavier_uniform_(self.fc1.weight)
nn.init.xavier_uniform_(self.fc2.weight)
nn.init.xavier_uniform_(self.fc3.weight)
nn.init.xavier_uniform_(self.out.weight)
... |
TVLoss | # 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 TVLoss(torch.nn.Module):
def __init__(self):
super(TVLoss, self).__init__()
def forward(self, x):
x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
self._tensor_size(x[:, :, 1:, :])
self._tensor_size(x[:, :, :, 1:])
h_tv = torch.pow(x[... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | Holmes-Alan/RefVAE | TVLoss | false | 8,266 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
self._tensor_size(x[:, :, 1:, :])
self._tensor_size(x[:, :, :, 1:])
h_tv = torch.pow(x[:, :, 1:, :] ... |
EncoderLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn.functional as F
import torch.nn as nn
def attention(q, k, v, d_k, mask=None, dropout=None):
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
mask = mask.unsqueeze(1)
scores = scores.masked_fill(mask == 0, -1000000000.0... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Hyunseung-Kim/molGCT | EncoderLayer | false | 8,267 | [
"Apache-2.0"
] | 10 | 5a2604337cf0a9d3c725295ccb7c8ea4b0144636 | https://github.com/Hyunseung-Kim/molGCT/tree/5a2604337cf0a9d3c725295ccb7c8ea4b0144636 | import math
import torch
import torch.nn.functional as F
import torch.nn as nn
def attention(q, k, v, d_k, mask=None, dropout=None):
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
mask = mask.unsqueeze(1)
scores = scores.masked_fill(mask == 0, -1000000000.0... |
ConvRelu | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
import torch.backends.cudnn
class ConvRelu(nn.Module):
"""3x3 convolution followed by ReLU activation building block.
"""
def __init__(self, num_in, num_out):
"""Creates a `ConvReLU` building block.
Args:
num_in: number... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | Iceofsky/Roofpedia | ConvRelu | false | 8,268 | [
"MIT"
] | 16 | 933dd3ff6e77ace78be6d2a23ac6692281475073 | https://github.com/Iceofsky/Roofpedia/tree/933dd3ff6e77ace78be6d2a23ac6692281475073 | import torch
import torch.utils.data
import torch.nn as nn
import torch.backends.cudnn
class Model(nn.Module):
"""3x3 convolution followed by ReLU activation building block.
"""
def __init__(self, num_in, num_out):
"""Creates a `ConvReLU` building block.
Args:
num_in: number of... |
OutPutBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 OutPutBlock(nn.Module):
def __init__(self, in_channels, out_channels):
super(OutPutBlock, self).__init__()
self.in_chns = in_channels
self.out_chns = out_channels
self.conv1 = nn.Conv2d(self.in_chns, self.in_chns // 2, kernel_size
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | HiLab-git/WSL4MIS | OutPutBlock | false | 8,269 | [
"MIT"
] | 29 | 9683e7c7409b95c0ac2169fe7964f6ca04c80d9a | https://github.com/HiLab-git/WSL4MIS/tree/9683e7c7409b95c0ac2169fe7964f6ca04c80d9a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.in_chns = in_channels
self.out_chns = out_channels
self.conv1 = nn.Conv2d(self.in_chns, self.in_chns // 2, kernel_size
=1, padding=0)
... |
VAE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class VAE(nn.Module):
def __init__(self, state_dim, action_dim, latent_dim, max_action, device):
super(VAE, self).__init__()
self.e1 = nn.Linear(state_dim + action_dim, 750)
self.e2 = nn.Linear(750, 750)
self.mean ... | import torch
from torch import device
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from... | HzcIrving/DLRL_PlayGround | VAE | false | 8,270 | [
"MIT"
] | 27 | 0db9a4bdb87130d1d26aea1591ef74cbe6aaa43b | https://github.com/HzcIrving/DLRL_PlayGround/tree/0db9a4bdb87130d1d26aea1591ef74cbe6aaa43b | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, action_dim, latent_dim, max_action, device):
super().__init__()
self.e1 = nn.Linear(state_dim + action_dim, 750)
self.e2 = nn.Linear(750, 750)
self.mean = nn.Li... |
CRF | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.init
import torch.nn.functional as F
class CRF(nn.Module):
"""
Conditional Random Field Module
Parameters
----------
hidden_dim : ``int``, required.
the dimension of the input features.
tagset_size : ``int``, required.
the siz... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.init
assert_size_stride = torch._C._dynamo... | INK-USC/ConNet | CRF | false | 8,271 | [
"MIT"
] | 11 | adb299f160556004561df302c19578200bd3835b | https://github.com/INK-USC/ConNet/tree/adb299f160556004561df302c19578200bd3835b | import torch
import torch.nn as nn
import torch.nn.init
import torch.nn.functional as F
class Model(nn.Module):
"""
Conditional Random Field Module
Parameters
----------
hidden_dim : ``int``, required.
the dimension of the input features.
tagset_size : ``int``, required.
the s... |
CGD | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.model_zoo
class CGD(nn.Module):
def __init__(self, in_channels, bias=True, nonlinear=True):
super(CGD, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.max_pool = nn.AdaptiveMaxPool2d(1)
self.softmax = nn.Softmax(d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | HolmesShuan/AIM2020-Real-Super-Resolution | CGD | false | 8,272 | [
"BSD-2-Clause"
] | 19 | 0ea4d7db0f4f7ed488cc162b90bb08fc02082106 | https://github.com/HolmesShuan/AIM2020-Real-Super-Resolution/tree/0ea4d7db0f4f7ed488cc162b90bb08fc02082106 | import torch
import torch.nn as nn
import torch.utils.model_zoo
class Model(nn.Module):
def __init__(self, in_channels, bias=True, nonlinear=True):
super().__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.max_pool = nn.AdaptiveMaxPool2d(1)
self.softmax = nn.Softmax(dim=1)
... |
_ImpalaResBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 _ImpalaResBlock(nn.Module):
def __init__(self, n_channels: 'int'):
super().__init__()
self.n_channels = n_channels
kernel_size = 3
padding = 1
self.relu = nn.ReLU()
self.relu_inplace = nn.ReLU()
self.conv1 = nn.Conv2d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | IBM/vsrl-framework | _ImpalaResBlock | false | 8,273 | [
"MIT"
] | 44 | 42e0853bffb5efbb66cd97178aff9e10ad18c5a9 | https://github.com/IBM/vsrl-framework/tree/42e0853bffb5efbb66cd97178aff9e10ad18c5a9 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, n_channels: 'int'):
super().__init__()
self.n_channels = n_channels
kernel_size = 3
padding = 1
self.relu = nn.ReLU()
self.relu_inplace = nn.ReLU()
self.conv1 = nn.Conv2d(n_channel... |
MlpNetM | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class MlpNetM(nn.Module):
"""Implements a simple fully connected mlp network."""
def __init__(self, sa_dim, n_agents, hidden_size, agent_id=0,
agent_shuffle='none'):
super(MlpNetM, self).__init__()
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
import torch.nn as nn
assert_... | HAXRD/PIC | MlpNetM | false | 8,274 | [
"MIT"
] | 28 | 658b4dd6b01e64413d5f8f0107d9167f1bd78546 | https://github.com/HAXRD/PIC/tree/658b4dd6b01e64413d5f8f0107d9167f1bd78546 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Implements a simple fully connected mlp network."""
def __init__(self, sa_dim, n_agents, hidden_size, agent_id=0,
agent_shuffle='none'):
super().__init__()
self.linear1 = n... |
predicates | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 func
class predicates(nn.Module):
def __init__(self, num_predicates, body_len):
"""
Use these to express a choice amongst predicates. For use when
learning rules.
Parameters:
----------
num_predicat... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | IBM/LOA | predicates | false | 8,275 | [
"MIT"
] | 12 | 9cd402c814f1d9c8b4de52ee18a3cb7ec2c6d07a | https://github.com/IBM/LOA/tree/9cd402c814f1d9c8b4de52ee18a3cb7ec2c6d07a | import torch
import torch.nn as nn
import torch.nn.functional as func
class Model(nn.Module):
def __init__(self, num_predicates, body_len):
"""
Use these to express a choice amongst predicates. For use when
learning rules.
Parameters:
----------
num_predicates: T... |
ConcatBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ConcatBlock(nn.Module):
def __init__(self, in_channels, out_channels):
super(ConcatBlock, self).__init__()
self.in_chns = in_channels
self.out_chns = out_channels
self.conv1 = nn.Conv2d(self.in_chns, self.in_chns, kernel_size=1,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | HiLab-git/WSL4MIS | ConcatBlock | false | 8,276 | [
"MIT"
] | 29 | 9683e7c7409b95c0ac2169fe7964f6ca04c80d9a | https://github.com/HiLab-git/WSL4MIS/tree/9683e7c7409b95c0ac2169fe7964f6ca04c80d9a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.in_chns = in_channels
self.out_chns = out_channels
self.conv1 = nn.Conv2d(self.in_chns, self.in_chns, kernel_size=1,
padding=0)
sel... |
predicates1 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 func
class predicates1(nn.Module):
def __init__(self, num_predicates, body_len):
super().__init__()
self.weights = nn.Parameter(torch.zeros(body_len, num_predicates).
uniform_(0.0, 0.1))
self.beta = nn.Parameter(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | IBM/LOA | predicates1 | false | 8,277 | [
"MIT"
] | 12 | 9cd402c814f1d9c8b4de52ee18a3cb7ec2c6d07a | https://github.com/IBM/LOA/tree/9cd402c814f1d9c8b4de52ee18a3cb7ec2c6d07a | import torch
import torch.nn as nn
import torch.nn.functional as func
class Model(nn.Module):
def __init__(self, num_predicates, body_len):
super().__init__()
self.weights = nn.Parameter(torch.zeros(body_len, num_predicates).
uniform_(0.0, 0.1))
self.beta = nn.Parameter(torch.... |
qd | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 qd(nn.Module):
def __init__(self, d_dim, zd_dim):
super(qd, self).__init__()
self.fc1 = nn.Linear(zd_dim, d_dim)
self.activation = nn.LeakyReLU(inplace=True)
torch.nn.init.xavier_uniform_(self.fc1.weight)
self.fc1.bias.data.zero_()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | IamWangYunKai/DG-TrajGen | qd | false | 8,278 | [
"MIT"
] | 31 | 0a8aab7e1c05111a5afe43d53801c55942e9ff56 | https://github.com/IamWangYunKai/DG-TrajGen/tree/0a8aab7e1c05111a5afe43d53801c55942e9ff56 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d_dim, zd_dim):
super().__init__()
self.fc1 = nn.Linear(zd_dim, d_dim)
self.activation = nn.LeakyReLU(inplace=True)
torch.nn.init.xavier_uniform_(self.fc1.weight)
self.fc1.bias.data.zero_()
... |
GramMatrix | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn
class GramMatrix(nn.Module):
def forward(self, input):
b, c, h, w = input.size()
F = input.view(b, c, h * w)
G = torch.bmm(F, F.transpose(1, 2))
G.div_(h * w)
return G
def get_inputs():
return... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.utils.data
import torch.nn as nn
import torch.nn
assert_size_stride... | IceClear/MW-GAN | GramMatrix | false | 8,279 | [
"MIT"
] | 36 | acb962468c984681c4a21f7b5c14588ca8f58c00 | https://github.com/IceClear/MW-GAN/tree/acb962468c984681c4a21f7b5c14588ca8f58c00 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn
class Model(nn.Module):
def forward(self, input):
b, c, h, w = input.size()
F = input.view(b, c, h * w)
G = torch.bmm(F, F.transpose(1, 2))
G.div_(h * w)
return G
def get_inputs():
return [tor... |
MLSTM_cell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.autograd import Variable
class MLSTM_cell(nn.Module):
def __init__(self, input_size, hidden_size, K, output_size):
super(MLSTM_cell, self).__init__()
self.hidden_size = hidden_size
self.K = K
self.output_size = output_size
self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | Gladys-Zhao/mRNN-mLSTM | MLSTM_cell | false | 8,280 | [
"BSD-3-Clause"
] | 15 | 23499f237ea8b0f68c96f756fbf0f4028836e64c | https://github.com/Gladys-Zhao/mRNN-mLSTM/tree/23499f237ea8b0f68c96f756fbf0f4028836e64c | import torch
import torch.nn as nn
from torch.autograd import Variable
class Model(nn.Module):
def __init__(self, input_size, hidden_size, K, output_size):
super().__init__()
self.hidden_size = hidden_size
self.K = K
self.output_size = output_size
self.cgate = nn.Linear(in... |
EuclideanDistance | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as th
import torch.nn as nn
class EuclideanDistance(nn.Module):
def __init__(self):
super(EuclideanDistance, self).__init__()
self.m = nn.Sigmoid()
def forward(self, i, j):
i_norm = self.m(i)
j_norm = self.m(j)
return th.sqrt(th.sum((i_norm -... | 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_... | IBM/aihn-ucsd | EuclideanDistance | false | 8,281 | [
"Apache-2.0"
] | 20 | 6c6a56d11c704b529a31868418e350e9760ff9d9 | https://github.com/IBM/aihn-ucsd/tree/6c6a56d11c704b529a31868418e350e9760ff9d9 | import torch
import torch as th
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.m = nn.Sigmoid()
def forward(self, i, j):
i_norm = self.m(i)
j_norm = self.m(j)
return th.sqrt(th.sum((i_norm - j_norm) ** 2, dim=-1))
def get_i... |
DownBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ConvBlock(torch.nn.Module):
def __init__(self, input_size, output_size, kernel_size, stride,
padding, bias=True):
super(ConvBlock, self).__init__()
self.conv = torch.nn.Conv2d(input_size, output_size, kernel_size,
stride, padding, bias=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.triton_helpers import libdevice
from torch import n... | Holmes-Alan/RefVAE | DownBlock | false | 8,282 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class ConvBlock(torch.nn.Module):
def __init__(self, input_size, output_size, kernel_size, stride,
padding, bias=True):
super().__init__()
self.conv = torch.nn.Conv2d(input_size, output_size, kernel_size,
stride, padding, bias=bias)
se... |
MumfordShah_Loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class MumfordShah_Loss(nn.Module):
def levelsetLoss(self, output, target, penalty='l1'):
outshape = output.shape
tarshape = target.shape
self.penalty = penalty
loss = 0.0
for ich in range(tarshape[1]):
target_ = torch.unsqueez... | 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
... | HiLab-git/WSL4MIS | MumfordShah_Loss | false | 8,283 | [
"MIT"
] | 29 | 9683e7c7409b95c0ac2169fe7964f6ca04c80d9a | https://github.com/HiLab-git/WSL4MIS/tree/9683e7c7409b95c0ac2169fe7964f6ca04c80d9a | import torch
import torch.nn as nn
class Model(nn.Module):
def levelsetLoss(self, output, target, penalty='l1'):
outshape = output.shape
tarshape = target.shape
self.penalty = penalty
loss = 0.0
for ich in range(tarshape[1]):
target_ = torch.unsqueeze(target[:,... |
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
import torch.utils.data
import torch.nn as nn
import torch.backends.cudnn
class ConvRelu(nn.Module):
"""3x3 convolution followed by ReLU activation building block.
"""
def __init__(self, num_in, num_out):
"""Creates a `ConvReLU` building block.
Args:
num_in: number... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | Iceofsky/Roofpedia | DecoderBlock | false | 8,284 | [
"MIT"
] | 16 | 933dd3ff6e77ace78be6d2a23ac6692281475073 | https://github.com/Iceofsky/Roofpedia/tree/933dd3ff6e77ace78be6d2a23ac6692281475073 | import torch
import torch.utils.data
import torch.nn as nn
import torch.backends.cudnn
class ConvRelu(nn.Module):
"""3x3 convolution followed by ReLU activation building block.
"""
def __init__(self, num_in, num_out):
"""Creates a `ConvReLU` building block.
Args:
num_in: number... |
_ImpalaBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 _ImpalaResBlock(nn.Module):
def __init__(self, n_channels: 'int'):
super().__init__()
self.n_channels = n_channels
kernel_size = 3
padding = 1
self.relu = nn.ReLU()
self.relu_inplace = nn.ReLU()
self.conv1 = nn.Conv2d... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | IBM/vsrl-framework | _ImpalaBlock | false | 8,285 | [
"MIT"
] | 44 | 42e0853bffb5efbb66cd97178aff9e10ad18c5a9 | https://github.com/IBM/vsrl-framework/tree/42e0853bffb5efbb66cd97178aff9e10ad18c5a9 | import torch
from torch import nn
class _ImpalaResBlock(nn.Module):
def __init__(self, n_channels: 'int'):
super().__init__()
self.n_channels = n_channels
kernel_size = 3
padding = 1
self.relu = nn.ReLU()
self.relu_inplace = nn.ReLU()
self.conv1 = nn.Conv2d... |
C51ValueNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 C51ValueNetwork(nn.Module):
"""Critic - return Q value from given states and actions. """
def __init__(self, num_states, num_actions, hidden_size, v_min, v_max,
num_atoms, device='cuda'):
"""
Args:
num_states (int... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import numpy as np
import tor... | HzcIrving/DLRL_PlayGround | C51ValueNetwork | false | 8,286 | [
"MIT"
] | 27 | 0db9a4bdb87130d1d26aea1591ef74cbe6aaa43b | https://github.com/HzcIrving/DLRL_PlayGround/tree/0db9a4bdb87130d1d26aea1591ef74cbe6aaa43b | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
"""Critic - return Q value from given states and actions. """
def __init__(self, num_states, num_actions, hidden_size, v_min, v_max,
num_atoms, device='cuda'):
"""
Args:
num_states (int): state d... |
NormalizeColorSpace | # 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 typing import *
class NormalizeColorSpace(nn.Module):
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
x = x.clamp(0.0, 255.0)
return x / 255.0
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
from typing import *
assert_size_stride = torch._C._dynamo.guards.as... | IntelLabs/OSCAR | NormalizeColorSpace | false | 8,287 | [
"BSD-3-Clause"
] | 13 | 25d1dea35727379117e11b7238b5a0d1ed19acad | https://github.com/IntelLabs/OSCAR/tree/25d1dea35727379117e11b7238b5a0d1ed19acad | import torch
from torch import nn
from typing import *
class Model(nn.Module):
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
x = x.clamp(0.0, 255.0)
return x / 255.0
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
CharbonnierLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn
class CharbonnierLoss(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=0.001):
super(CharbonnierLoss, self).__init__()
self.eps = eps
def forward(self, x, y):
diff = x - y
loss = torc... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.data
impo... | IceClear/MW-GAN | CharbonnierLoss | false | 8,288 | [
"MIT"
] | 36 | acb962468c984681c4a21f7b5c14588ca8f58c00 | https://github.com/IceClear/MW-GAN/tree/acb962468c984681c4a21f7b5c14588ca8f58c00 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn
class Model(nn.Module):
"""Charbonnier Loss (L1)"""
def __init__(self, eps=0.001):
super().__init__()
self.eps = eps
def forward(self, x, y):
diff = x - y
loss = torch.sum(torch.sqrt(diff * diff + ... |
Transform | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def calc_mean_std(feat, eps=1e-05):
size = feat.size()
assert len(size) == 4
N, C = size[:2]
feat_var = feat.view(N, C, -1).var(dim=2) + eps
feat_std = feat_var.sqrt().view(N, C, 1, 1)
feat_mean = feat.view(N, C, -1).mean(dim=2).view(N, C, 1, 1)
return fe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | HalbertCH/IEContraAST | Transform | false | 8,289 | [
"MIT"
] | 39 | 50ee949f5302a7e4a3cae3226610c03462093c21 | https://github.com/HalbertCH/IEContraAST/tree/50ee949f5302a7e4a3cae3226610c03462093c21 | import torch
import torch.nn as nn
def calc_mean_std(feat, eps=1e-05):
size = feat.size()
assert len(size) == 4
N, C = size[:2]
feat_var = feat.view(N, C, -1).var(dim=2) + eps
feat_std = feat_var.sqrt().view(N, C, 1, 1)
feat_mean = feat.view(N, C, -1).mean(dim=2).view(N, C, 1, 1)
return fe... |
EuclideanLoss | # 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 EuclideanLoss(nn.Module):
def __init__(self):
super(EuclideanLoss, self).__init__()
def forward(self, pre, gt):
N = pre.shape[0]
diff = torch.sum((pre - gt).pow(2)) / (N * 2)
return diff
def get_inputs():
return [torch.rand([4, 4... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | IndigoPurple/EFENet | EuclideanLoss | false | 8,290 | [
"MIT"
] | 11 | e88234486f19534274a0a20badc251788ac67e31 | https://github.com/IndigoPurple/EFENet/tree/e88234486f19534274a0a20badc251788ac67e31 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pre, gt):
N = pre.shape[0]
diff = torch.sum((pre - gt).pow(2)) / (N * 2)
return diff
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4,... |
loss_Textures | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn
class loss_Textures(nn.Module):
def __init__(self, nc=1, alpha=1.2, margin=0):
super(loss_Textures, self).__init__()
self.nc = nc
self.alpha = alpha
self.margin = margin
def forward(self, x, y):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
import torch.nn as nn
import torch.nn
assert_size_stride = torch.... | IceClear/MW-GAN | loss_Textures | false | 8,291 | [
"MIT"
] | 36 | acb962468c984681c4a21f7b5c14588ca8f58c00 | https://github.com/IceClear/MW-GAN/tree/acb962468c984681c4a21f7b5c14588ca8f58c00 | import torch
import torch.utils.data
import torch.nn as nn
import torch.nn
class Model(nn.Module):
def __init__(self, nc=1, alpha=1.2, margin=0):
super().__init__()
self.nc = nc
self.alpha = alpha
self.margin = margin
def forward(self, x, y):
xi = x.contiguous().view(... |
BilinearMatrixAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BilinearMatrixAttention(nn.Module):
"""
Adopted from AllenNLP. For now there is no activation function
"""
def __init__(self, matrix_1_dim: 'int', matrix_2_dim: 'int',
use_input_biases: 'bool'=False, label_dim: 'int'=1) ->None:
super().__init__()
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | Impavidity/relogic | BilinearMatrixAttention | false | 8,292 | [
"MIT"
] | 24 | f647106e143cd603b95b63e06ea530cdd516aefe | https://github.com/Impavidity/relogic/tree/f647106e143cd603b95b63e06ea530cdd516aefe | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Adopted from AllenNLP. For now there is no activation function
"""
def __init__(self, matrix_1_dim: 'int', matrix_2_dim: 'int',
use_input_biases: 'bool'=False, label_dim: 'int'=1) ->None:
super().__init__()
if use_inpu... |
CharbonnierLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class CharbonnierLoss(nn.Module):
def __init__(self):
super(CharbonnierLoss, self).__init__()
def forward(self, pre, gt):
N = pre.shape[0]
diff = torch.sum(torch.sqrt((pre - gt).pow(2) + 0.001 ** 2)) / N
return diff
def get_inputs():
r... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert... | IndigoPurple/EFENet | CharbonnierLoss | false | 8,293 | [
"MIT"
] | 11 | e88234486f19534274a0a20badc251788ac67e31 | https://github.com/IndigoPurple/EFENet/tree/e88234486f19534274a0a20badc251788ac67e31 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, pre, gt):
N = pre.shape[0]
diff = torch.sum(torch.sqrt((pre - gt).pow(2) + 0.001 ** 2)) / N
return diff
def get_inputs():
return [torch.rand([4, 4, 4, 4])... |
ConvLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ConvLayer(nn.Module):
def __init__(self, in_channels: 'int', out_channels: 'int', kernel_size:
'int', stride: 'int'):
super().__init__()
self._conv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channels, kernel_size=kernel_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.... | Inkln/StyleTransferWithCatalyst | ConvLayer | false | 8,294 | [
"Apache-2.0"
] | 11 | c3181ecdfd32160907efc2d9d917a55925c25c11 | https://github.com/Inkln/StyleTransferWithCatalyst/tree/c3181ecdfd32160907efc2d9d917a55925c25c11 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels: 'int', out_channels: 'int', kernel_size:
'int', stride: 'int'):
super().__init__()
self._conv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channels, kernel_size=kernel_size, st... |
HardMish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn as nn
def hard_mish(x, inplace: 'bool'=False):
""" Hard Mish
Experimental, based on notes by Mish author Diganta Misra at
https://github.com/digantamisra98/H-Mish/blob/0da20d4bc58e696b6803f2523c58d3c8a82782d0/README.md
"""
if inplace:
return x.mul_(0.5 *... | 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 as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_strid... | JDAI-CV/CoTNet-ObjectDetection-InstanceSegmentation | HardMish | false | 8,295 | [
"Apache-2.0"
] | 34 | 2a546ef946989fc5bac8d819b3c93a9fdc83f241 | https://github.com/JDAI-CV/CoTNet-ObjectDetection-InstanceSegmentation/tree/2a546ef946989fc5bac8d819b3c93a9fdc83f241 | import torch
from torch import nn as nn
def hard_mish(x, inplace: 'bool'=False):
""" Hard Mish
Experimental, based on notes by Mish author Diganta Misra at
https://github.com/digantamisra98/H-Mish/blob/0da20d4bc58e696b6803f2523c58d3c8a82782d0/README.md
"""
if inplace:
return x.mul_(0.5 *... |
SpatialPyramidPooling | # 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 SpatialPyramidPooling(nn.Module):
def __init__(self, pool_sizes=[5, 9, 13]):
super(SpatialPyramidPooling, self).__init__()
self.maxpools = nn.ModuleList([nn.MaxPool2d(pool_size, 1, pool_size //
2) for pool_size in pool_sizes])
def forward(... | 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... | IDayday/YOLOv4_CAM | SpatialPyramidPooling | false | 8,296 | [
"Apache-2.0"
] | 34 | 8df61f1c59c197126f0385c1ec1cf65a29a80cec | https://github.com/IDayday/YOLOv4_CAM/tree/8df61f1c59c197126f0385c1ec1cf65a29a80cec | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, pool_sizes=[5, 9, 13]):
super().__init__()
self.maxpools = nn.ModuleList([nn.MaxPool2d(pool_size, 1, pool_size //
2) for pool_size in pool_sizes])
def forward(self, x):
features = [maxpool(x) fo... |
decoder4 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 decoder4(nn.Module):
def __init__(self):
super(decoder4, self).__init__()
self.reflecPad11 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv11 = nn.Conv2d(512, 256, 3, 1, 0)
self.relu11 = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingN... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Holmes-Alan/RefVAE | decoder4 | false | 8,297 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.reflecPad11 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv11 = nn.Conv2d(512, 256, 3, 1, 0)
self.relu11 = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingNearest2d(scale_fa... |
Normalization | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Normalization(nn.Module):
def __init__(self):
super(Normalization, self).__init__()
self.mean = nn.Parameter(torch.tensor([0.485, 0.456, 0.406]).view(-
1, 1, 1))
self.std = nn.Parameter(torch.tensor([0.329, 0.224, 0.225]).view(-1,
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | Inkln/StyleTransferWithCatalyst | Normalization | false | 8,298 | [
"Apache-2.0"
] | 11 | c3181ecdfd32160907efc2d9d917a55925c25c11 | https://github.com/Inkln/StyleTransferWithCatalyst/tree/c3181ecdfd32160907efc2d9d917a55925c25c11 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.mean = nn.Parameter(torch.tensor([0.485, 0.456, 0.406]).view(-
1, 1, 1))
self.std = nn.Parameter(torch.tensor([0.329, 0.224, 0.225]).view(-1,
1, 1))
def forw... |
GroupNorm32 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 GroupNorm32(nn.GroupNorm):
def __init__(self, num_groups, num_channels, swish, eps=1e-05):
super().__init__(num_groups=num_groups, num_channels=num_channels,
eps=eps)
self.swish = swish
def forward(self, x):
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | Jack000/glid-3 | GroupNorm32 | false | 8,299 | [
"MIT"
] | 31 | 4a18efc2785339ebc743e149a7955e34fff436fb | https://github.com/Jack000/glid-3/tree/4a18efc2785339ebc743e149a7955e34fff436fb | import torch
import torch.nn.functional as F
from torch import nn
class Model(nn.GroupNorm):
def __init__(self, num_groups, num_channels, swish, eps=1e-05):
super().__init__(num_groups=num_groups, num_channels=num_channels,
eps=eps)
self.swish = swish
def forward(self, x):
... |
ImageGradients | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as th
import torch.utils.data
class ImageGradients(th.nn.Module):
"""
Args:
c_in(int): number of channels expected in the images.
use_sobel(bool): if True, uses a (smoother) Sobel filter instead of simple
finite differences.
"""
def __init__(self, c_in, use_sobel=T... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch as th
import torch.utils.data
assert_size_stride = torch._C._dynamo... | IlyaBizyaev/ttools | ImageGradients | false | 8,300 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch as th
import torch.utils.data
class Model(th.nn.Module):
"""
Args:
c_in(int): number of channels expected in the images.
use_sobel(bool): if True, uses a (smoother) Sobel filter instead of simple
finite differences.
"""
def __init__(self, c_in, use_sobel=True):
... |
decoder3 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
class decoder3(nn.Module):
def __init__(self):
super(decoder3, self).__init__()
self.reflecPad7 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv7 = nn.Conv2d(256, 128, 3, 1, 0)
self.relu7 = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingNear... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Holmes-Alan/RefVAE | decoder3 | false | 8,301 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.reflecPad7 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv7 = nn.Conv2d(256, 128, 3, 1, 0)
self.relu7 = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingNearest2d(scale_facto... |
CMMD | # 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 CMMD(nn.Module):
def __init__(self, num_pos):
super(CMMD, self).__init__()
self.num_pos = num_pos
def forward(self, feat_v, feat_t):
feat_v = feat_v.view(feat_v.size(0), -1)
feat_v = F.normalize(feat_v, ... | 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... | JDAI-CV/CM-NAS | CMMD | false | 8,302 | [
"Apache-2.0"
] | 31 | bbc77f427b2c8afb9f3865f5a04e86079d33dd28 | https://github.com/JDAI-CV/CM-NAS/tree/bbc77f427b2c8afb9f3865f5a04e86079d33dd28 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, num_pos):
super().__init__()
self.num_pos = num_pos
def forward(self, feat_v, feat_t):
feat_v = feat_v.view(feat_v.size(0), -1)
feat_v = F.normalize(feat_v, dim=-1)
... |
qy | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 weights_init(m):
if isinstance(m, nn.Conv2d):
nn.init.kaiming_uniform_(m.weight, a=0, mode='fan_in', nonlinearity
='leaky_relu')
try:
nn.init.constant_(m.bias, 0.01)
except:
pass
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | IamWangYunKai/DG-TrajGen | qy | false | 8,303 | [
"MIT"
] | 31 | 0a8aab7e1c05111a5afe43d53801c55942e9ff56 | https://github.com/IamWangYunKai/DG-TrajGen/tree/0a8aab7e1c05111a5afe43d53801c55942e9ff56 | import torch
import torch.nn as nn
import torch.nn.functional as F
def weights_init(m):
if isinstance(m, nn.Conv2d):
nn.init.kaiming_uniform_(m.weight, a=0, mode='fan_in', nonlinearity
='leaky_relu')
try:
nn.init.constant_(m.bias, 0.01)
except:
pass
... |
decoder6 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 decoder6(nn.Module):
def __init__(self):
super(decoder6, self).__init__()
self.reflecPad11 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv11 = nn.Conv2d(512, 256, 3, 1, 0)
self.relu11 = nn.ReLU(inplace=True)
self.unpool1 = nn.ConvTransp... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Holmes-Alan/RefVAE | decoder6 | false | 8,304 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.reflecPad11 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv11 = nn.Conv2d(512, 256, 3, 1, 0)
self.relu11 = nn.ReLU(inplace=True)
self.unpool1 = nn.ConvTranspose2d(256, 256, 4... |
SP | # 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 SP(nn.Module):
def __init__(self):
super(SP, self).__init__()
def forward(self, feat_v, feat_t):
feat_v = feat_v.view(feat_v.size(0), -1)
G_v = torch.mm(feat_v, feat_v.t())
norm_G_v = F.normalize(G_v, p=... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JDAI-CV/CM-NAS | SP | false | 8,305 | [
"Apache-2.0"
] | 31 | bbc77f427b2c8afb9f3865f5a04e86079d33dd28 | https://github.com/JDAI-CV/CM-NAS/tree/bbc77f427b2c8afb9f3865f5a04e86079d33dd28 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, feat_v, feat_t):
feat_v = feat_v.view(feat_v.size(0), -1)
G_v = torch.mm(feat_v, feat_v.t())
norm_G_v = F.normalize(G_v, p=2, di... |
PSNR | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as th
import torch.utils.data
class PSNR(th.nn.Module):
def __init__(self):
super(PSNR, self).__init__()
self.mse = th.nn.MSELoss()
def forward(self, out, ref):
mse = self.mse(out, ref)
return -10 * th.log10(mse + 1e-12)
def get_inputs():
retur... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch as th
import to... | IlyaBizyaev/ttools | PSNR | false | 8,306 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch as th
import torch.utils.data
class Model(th.nn.Module):
def __init__(self):
super().__init__()
self.mse = th.nn.MSELoss()
def forward(self, out, ref):
mse = self.mse(out, ref)
return -10 * th.log10(mse + 1e-12)
def get_inputs():
return [torch.... |
BicubicUpsampler | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as th
import torch.utils.data
class BicubicUpsampler(th.nn.Module):
def __init__(self, scale=2, channels=1):
super(BicubicUpsampler, self).__init__()
ksize = 2 * scale * 2
total_pad = ksize - scale // 2
if scale % 2 == 1:
ksize += 1
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
import torch as th
import torch.utils.data
assert_size_stride = torch._C._dynamo... | IlyaBizyaev/ttools | BicubicUpsampler | false | 8,307 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch as th
import torch.utils.data
class Model(th.nn.Module):
def __init__(self, scale=2, channels=1):
super().__init__()
ksize = 2 * scale * 2
total_pad = ksize - scale // 2
if scale % 2 == 1:
ksize += 1
self.pad = th.nn.ReplicationPad2d((... |
FCChain | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)
if activation ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | IlyaBizyaev/ttools | FCChain | false | 8,308 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)
if activation ... |
TransformerEncoderPostNormLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
from typing import Optional
from torch.nn import LayerNorm
def _get_activation_fn(activation):
if activation == 'relu':
return F.relu
elif activation == 'gelu':
return F.gelu
raise RuntimeError('activation should be relu/gel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JDBumgardner/stone_ground_hearth_battles | TransformerEncoderPostNormLayer | false | 8,309 | [
"Apache-2.0"
] | 20 | 9fe095651fab60e8ddbf563f0b9b7f3e723d5f4f | https://github.com/JDBumgardner/stone_ground_hearth_battles/tree/9fe095651fab60e8ddbf563f0b9b7f3e723d5f4f | import torch
import torch.nn.functional as F
from torch import nn
from typing import Optional
from torch.nn import LayerNorm
def _get_activation_fn(activation):
if activation == 'relu':
return F.relu
elif activation == 'gelu':
return F.gelu
raise RuntimeError('activation should be relu/gel... |
ResidualAttentionBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from collections import OrderedDict
from torch import nn
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: 'torch.Tensor'):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
cla... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Jack000/glid-3 | ResidualAttentionBlock | false | 8,310 | [
"MIT"
] | 31 | 4a18efc2785339ebc743e149a7955e34fff436fb | https://github.com/Jack000/glid-3/tree/4a18efc2785339ebc743e149a7955e34fff436fb | import torch
from collections import OrderedDict
from torch import nn
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: 'torch.Tensor'):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
cla... |
StyleLossBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 StyleLossBlock(nn.Module):
def __init__(self, target: 'torch.Tensor'):
super().__init__()
self.stored_value = None
self._loss = F.mse_loss
self.shape = target.shape
self._target_gram_matrix = nn.Param... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Inkln/StyleTransferWithCatalyst | StyleLossBlock | false | 8,311 | [
"Apache-2.0"
] | 11 | c3181ecdfd32160907efc2d9d917a55925c25c11 | https://github.com/Inkln/StyleTransferWithCatalyst/tree/c3181ecdfd32160907efc2d9d917a55925c25c11 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, target: 'torch.Tensor'):
super().__init__()
self.stored_value = None
self._loss = F.mse_loss
self.shape = target.shape
self._target_gram_matrix = nn.Parameter(self... |
BilinearUpsampler | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as th
import torch.utils.data
class BilinearUpsampler(th.nn.Module):
def __init__(self, scale=2, channels=1):
super(BilinearUpsampler, self).__init__()
ksize = 2 * scale
total_pad = ksize - scale // 2
if scale % 2 == 1:
ksize += 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
import torch as th
import torch.utils.data
assert_size_stride = torch._C._dynamo... | IlyaBizyaev/ttools | BilinearUpsampler | false | 8,312 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch as th
import torch.utils.data
class Model(th.nn.Module):
def __init__(self, scale=2, channels=1):
super().__init__()
ksize = 2 * scale
total_pad = ksize - scale // 2
if scale % 2 == 1:
ksize += 1
self.pad = th.nn.ReplicationPad2d((1, 1... |
Conv1dResBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Conv1d(nn.Conv1d):
"""
Convolution 1d
Args:
x: (N, T, C_in)
Returns:
y: (N, T, C_out)
"""
def __init__(self, in_channels, out_channels, kernel_size,
activation_fn=None, drop_rate=0.0, stride=1, padding='same',
dilation=1, groups=1, bias=Tr... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | Jackson-Kang/VQVC-Pytorch | Conv1dResBlock | false | 8,313 | [
"MIT"
] | 13 | d2267b5c52253b6ae11a5767963a65320ae335c2 | https://github.com/Jackson-Kang/VQVC-Pytorch/tree/d2267b5c52253b6ae11a5767963a65320ae335c2 | import torch
import torch.nn as nn
class Conv1d(nn.Conv1d):
"""
Convolution 1d
Args:
x: (N, T, C_in)
Returns:
y: (N, T, C_out)
"""
def __init__(self, in_channels, out_channels, kernel_size,
activation_fn=None, drop_rate=0.0, stride=1, padding='same',
dilation=1, groups=1, bias=Tr... |
DepthwiseSeparableConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class DepthwiseSeparableConv(nn.Module):
"""
Depth-wise separable convolution uses less parameters to generate output by convolution.
:Examples:
>>> m = DepthwiseSeparableConv(300, 200, 5, dim=1)
>>> input_tensor = torch.ra... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | IsaacChanghau/ReLoCLNet | DepthwiseSeparableConv | false | 8,314 | [
"MIT"
] | 31 | 56cb666ce516cce9acbcfce78fb4e95d81e11e54 | https://github.com/IsaacChanghau/ReLoCLNet/tree/56cb666ce516cce9acbcfce78fb4e95d81e11e54 | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""
Depth-wise separable convolution uses less parameters to generate output by convolution.
:Examples:
>>> m = DepthwiseSeparableConv(300, 200, 5, dim=1)
>>> input_tensor = torch.randn(32, 300, 20)
... |
NormalDivLoss | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def fuzzyDist(x, a=0.1, b=2):
return 1 / (1 + (x / a).abs().pow(2 * b))
class SoftHist(nn.Module):
def __init__(self, bins, dist):
super(SoftHist, self).__init__()
bins[1] - bins[0]
self.bins = nn.Parameter(bins.unsqueeze(1))
self.dist = di... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.gu... | JWHan717/CS492I-Project | NormalDivLoss | false | 8,315 | [
"MIT"
] | 23 | 5da80bc41425ee90711a3de89c5501b5f7acd4b7 | https://github.com/JWHan717/CS492I-Project/tree/5da80bc41425ee90711a3de89c5501b5f7acd4b7 | import torch
import torch.nn as nn
def fuzzyDist(x, a=0.1, b=2):
return 1 / (1 + (x / a).abs().pow(2 * b))
class SoftHist(nn.Module):
def __init__(self, bins, dist):
super().__init__()
bins[1] - bins[0]
self.bins = nn.Parameter(bins.unsqueeze(1))
self.dist = dist
sel... |
ConvEncoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class DepthwiseSeparableConv(nn.Module):
"""
Depth-wise separable convolution uses less parameters to generate output by convolution.
:Examples:
>>> m = DepthwiseSeparableConv(300, 200, 5, dim=1)
>>> input_tensor = torch.ra... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | IsaacChanghau/ReLoCLNet | ConvEncoder | false | 8,316 | [
"MIT"
] | 31 | 56cb666ce516cce9acbcfce78fb4e95d81e11e54 | https://github.com/IsaacChanghau/ReLoCLNet/tree/56cb666ce516cce9acbcfce78fb4e95d81e11e54 | import torch
import torch.nn.functional as F
import torch.nn as nn
class DepthwiseSeparableConv(nn.Module):
"""
Depth-wise separable convolution uses less parameters to generate output by convolution.
:Examples:
>>> m = DepthwiseSeparableConv(300, 200, 5, dim=1)
>>> input_tensor = torch.ra... |
ConvChain | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)
if activation ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | IlyaBizyaev/ttools | ConvChain | false | 8,317 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import torch.utils.data
import torch.nn as nn
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if activation == 'relu':
return nn.ReLU(inplace=True)
if activation ... |
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
class Conv1d(nn.Conv1d):
"""
Convolution 1d
Args:
x: (N, T, C_in)
Returns:
y: (N, T, C_out)
"""
def __init__(self, in_channels, out_channels, kernel_size,
activation_fn=None, drop_rate=0.0, stride=1, padding='same',
dilation=1, groups=1, bias=Tr... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | Jackson-Kang/VQVC-Pytorch | Conv1d | false | 8,318 | [
"MIT"
] | 13 | d2267b5c52253b6ae11a5767963a65320ae335c2 | https://github.com/Jackson-Kang/VQVC-Pytorch/tree/d2267b5c52253b6ae11a5767963a65320ae335c2 | import torch
import torch.nn as nn
class Model(nn.Conv1d):
"""
Convolution 1d
Args:
x: (N, T, C_in)
Returns:
y: (N, T, C_out)
"""
def __init__(self, in_channels, out_channels, kernel_size,
activation_fn=None, drop_rate=0.0, stride=1, padding='same',
dilation=1, groups=1, bias=Tru... |
KLLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
from math import sqrt as sqrt
from itertools import product as product
class KLLoss(nn.Module):
"""
Kl-loss function for bounding box regression from CVPR 2019 paper:
Bounding Box Regression with Uncertainty for Accurate Object Detection
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
f... | JappaB/Active_Learning_Object_Detection | KLLoss | false | 8,319 | [
"MIT"
] | 21 | 3d9ad367aa872cbf3e9d71c566042c78fe2d0e76 | https://github.com/JappaB/Active_Learning_Object_Detection/tree/3d9ad367aa872cbf3e9d71c566042c78fe2d0e76 | import torch
from torch import nn
import torch.nn.functional as F
from math import sqrt as sqrt
from itertools import product as product
class Model(nn.Module):
"""
Kl-loss function for bounding box regression from CVPR 2019 paper:
Bounding Box Regression with Uncertainty for Accurate Object Detection
... |
ResidualBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ConvLayer(nn.Module):
def __init__(self, in_channels: 'int', out_channels: 'int', kernel_size:
'int', stride: 'int'):
super().__init__()
self._conv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channels, kernel_size=kernel_size... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Inkln/StyleTransferWithCatalyst | ResidualBlock | false | 8,320 | [
"Apache-2.0"
] | 11 | c3181ecdfd32160907efc2d9d917a55925c25c11 | https://github.com/Inkln/StyleTransferWithCatalyst/tree/c3181ecdfd32160907efc2d9d917a55925c25c11 | import torch
import torch.nn as nn
class ConvLayer(nn.Module):
def __init__(self, in_channels: 'int', out_channels: 'int', kernel_size:
'int', stride: 'int'):
super().__init__()
self._conv = nn.Conv2d(in_channels=in_channels, out_channels=
out_channels, kernel_size=kernel_size... |
FixupBasicBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
class FixupBasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, plane... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | IlanPrice/DCTpS | FixupBasicBlock | false | 8,321 | [
"MIT"
] | 12 | e3219ac132959f484724e0d0bd48a0cb8af3d0fa | https://github.com/IlanPrice/DCTpS/tree/e3219ac132959f484724e0d0bd48a0cb8af3d0fa | import torch
import torch.nn as nn
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
class Model(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=... |
TrainablePositionalEncoding | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 TrainablePositionalEncoding(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings."""
def __init__(self, max_position_embeddings, hidden_size, dropout=0.1):
super(TrainablePositionalEncoding, self).__init__()
self.positi... | 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_... | IsaacChanghau/ReLoCLNet | TrainablePositionalEncoding | false | 8,322 | [
"MIT"
] | 31 | 56cb666ce516cce9acbcfce78fb4e95d81e11e54 | https://github.com/IsaacChanghau/ReLoCLNet/tree/56cb666ce516cce9acbcfce78fb4e95d81e11e54 | import torch
import torch.nn as nn
class Model(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings."""
def __init__(self, max_position_embeddings, hidden_size, dropout=0.1):
super().__init__()
self.position_embeddings = nn.Embedding(max_position_embeddings,
... |
FixupResidualChain | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 as th
import torch.utils.data
import torch.nn as nn
from collections import OrderedDict
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if act... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import numpy as np
import tor... | IlyaBizyaev/ttools | FixupResidualChain | false | 8,323 | [
"MIT"
] | 11 | b1435b19f397ce1baff9daed3cb287e52a029fdb | https://github.com/IlyaBizyaev/ttools/tree/b1435b19f397ce1baff9daed3cb287e52a029fdb | import torch
import numpy as np
import torch as th
import torch.utils.data
import torch.nn as nn
from collections import OrderedDict
def _get_activation(activation):
valid = ['relu', 'leaky_relu', 'lrelu', 'tanh', 'sigmoid']
assert activation in valid, 'activation should be one of {}'.format(valid)
if act... |
WeightedSmoothL1Loss | # 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 WeightedSmoothL1Loss(nn.Module):
"""
Code-wise Weighted Smooth L1 Loss modified based on fvcore.nn.smooth_l1_loss
https://github.com/facebookresearch/fvcore/blob/master/fvcore/nn/smooth_l1_loss.py
| 0.5 * x ** 2 / beta if abs(... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import numpy as np
import torch.nn as nn
assert_size_stride = ... | Jasonkks/mlcnet | WeightedSmoothL1Loss | false | 8,324 | [
"Apache-2.0"
] | 18 | 8f89c860c709733c8baa663607004fc48d76291d | https://github.com/Jasonkks/mlcnet/tree/8f89c860c709733c8baa663607004fc48d76291d | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
"""
Code-wise Weighted Smooth L1 Loss modified based on fvcore.nn.smooth_l1_loss
https://github.com/facebookresearch/fvcore/blob/master/fvcore/nn/smooth_l1_loss.py
| 0.5 * x ** 2 / beta if abs(x) < beta
s... |
h_swish | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class h_sigmoid(nn.Module):
def __init__(self, inplace=True):
super(h_sigmoid, self).__init__()
self.relu = nn.ReLU6(inplace=inplace)
def forward(self, x):
return self.relu(x + 3) / 6
class h_swish(nn.Module):
def __init__(self, inplace=True)... | 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... | JaminFong/dali-pytorch | h_swish | false | 8,325 | [
"Apache-2.0"
] | 41 | 7bd5d2380d210a32d24c7309da69c8d2c5db8759 | https://github.com/JaminFong/dali-pytorch/tree/7bd5d2380d210a32d24c7309da69c8d2c5db8759 | import torch
import torch.nn as nn
class h_sigmoid(nn.Module):
def __init__(self, inplace=True):
super().__init__()
self.relu = nn.ReLU6(inplace=inplace)
def forward(self, x):
return self.relu(x + 3) / 6
class Model(nn.Module):
def __init__(self, inplace=True):
super()... |
injective_pad | # 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 injective_pad(nn.Module):
def __init__(self, pad_size):
super(injective_pad, self).__init__()
self.pad_size = pad_size
self.pad = nn.ZeroPad2d((0, 0, 0, pad_size))
def forward(self, x):
x = x.permute(0, 2, 1, 3)
x = self.pad(x)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | JessieYuW/CrevNet-Traffic4cast | injective_pad | false | 8,326 | [
"Apache-2.0"
] | 13 | 810b2a951de1f99a07bf8cfcbd93e1fc016cce48 | https://github.com/JessieYuW/CrevNet-Traffic4cast/tree/810b2a951de1f99a07bf8cfcbd93e1fc016cce48 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, pad_size):
super().__init__()
self.pad_size = pad_size
self.pad = nn.ZeroPad2d((0, 0, 0, pad_size))
def forward(self, x):
x = x.permute(0, 2, 1, 3)
x = self.pad(x)
return x.permute(0... |
GridMixupLoss | # 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 random
import torch
import numpy as np
import typing as t
from torch import nn
class GridMixupLoss(nn.Module):
""" Implementation of GridMixup loss
:param alpha: Percent of the first image on the crop. Can be float or Tuple[float, float]
- if float: lambda parameter get... | 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 math
import ran... | IlyaDobrynin/GridMixup | GridMixupLoss | false | 8,327 | [
"MIT"
] | 42 | 11b741f234832c9a15b4e650e1e4fad0e79dc63b | https://github.com/IlyaDobrynin/GridMixup/tree/11b741f234832c9a15b4e650e1e4fad0e79dc63b | import math
import random
import torch
import numpy as np
import typing as t
from torch import nn
class Model(nn.Module):
""" Implementation of GridMixup loss
:param alpha: Percent of the first image on the crop. Can be float or Tuple[float, float]
- if float: lambda parameter gets from t... |
DiagonalQuantizer | # 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.cuda
import torch.fft
def diagonal_quantize_function(x, bit, phase_noise_std=0, random_state=None,
gradient_clip=False):
class DiagonalQuantizeFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
S_scale = x.abs().max... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import nump... | JeremieMelo/pytorch-onn | DiagonalQuantizer | false | 8,328 | [
"MIT"
] | 16 | 670996112277a6c19c7da400afbe0a4ce45ad5de | https://github.com/JeremieMelo/pytorch-onn/tree/670996112277a6c19c7da400afbe0a4ce45ad5de | import torch
import numpy as np
import torch.cuda
import torch.fft
def diagonal_quantize_function(x, bit, phase_noise_std=0, random_state=None,
gradient_clip=False):
class DiagonalQuantizeFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
S_scale = x.abs().max... |
AffineConstantFlow | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 AffineConstantFlow(nn.Module):
"""
Scales + Shifts the flow by (learned) constants per dimension.
In NICE paper there is a Scaling layer which is a special case of this where t is None
"""
def __init__(self, dim, scale=True, shift=True):
super().__... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_... | JannerM/gamma-models | AffineConstantFlow | false | 8,329 | [
"MIT"
] | 32 | 4b40d828bf228385c3081d359cdc3494d70de4a1 | https://github.com/JannerM/gamma-models/tree/4b40d828bf228385c3081d359cdc3494d70de4a1 | import torch
from torch import nn
class Model(nn.Module):
"""
Scales + Shifts the flow by (learned) constants per dimension.
In NICE paper there is a Scaling layer which is a special case of this where t is None
"""
def __init__(self, dim, scale=True, shift=True):
super().__init__()
... |
SqueezeExcite | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torchvision.transforms import functional as F
import torch.nn as nn
import torch.nn.functional as F
def _make_divisible(v, divisor, min_value=None):
"""
This function is taken from the original tf repo.
It ensures that all layers have a channel number that is divisible by 8
It can be... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torchvision.transforms i... | JaminFong/dali-pytorch | SqueezeExcite | false | 8,330 | [
"Apache-2.0"
] | 41 | 7bd5d2380d210a32d24c7309da69c8d2c5db8759 | https://github.com/JaminFong/dali-pytorch/tree/7bd5d2380d210a32d24c7309da69c8d2c5db8759 | import torch
from torchvision.transforms import functional as F
import torch.nn as nn
import torch.nn.functional as F
def _make_divisible(v, divisor, min_value=None):
"""
This function is taken from the original tf repo.
It ensures that all layers have a channel number that is divisible by 8
It can be... |
Upsample | # 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 Upsample(nn.Upsample):
"""
Upsampling via interporlation
Args:
x: (N, T, C)
Returns:
y: (N, S * T, C)
(S: scale_factor)
"""
def __init__(self, scale_factor=2, mode='nearest'):
super(Upsample, self).__init__(scale_factor=scale_factor, mode=mo... | 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... | Jackson-Kang/VQVC-Pytorch | Upsample | false | 8,331 | [
"MIT"
] | 13 | d2267b5c52253b6ae11a5767963a65320ae335c2 | https://github.com/Jackson-Kang/VQVC-Pytorch/tree/d2267b5c52253b6ae11a5767963a65320ae335c2 | import torch
import torch.nn as nn
class Model(nn.Upsample):
"""
Upsampling via interporlation
Args:
x: (N, T, C)
Returns:
y: (N, S * T, C)
(S: scale_factor)
"""
def __init__(self, scale_factor=2, mode='nearest'):
super().__init__(scale_factor=scale_factor, mode=mode)
def forw... |
GraphConvolution | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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.functional as F
from torch.nn import Parameter
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn.modules.loss
from scipy.sparse import *
def dropout(x, drop_prob, shared_axes=[], training=False):
"""
App... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | IBM/graph4nlp | GraphConvolution | false | 8,332 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | from torch.nn import Module
import torch
import torch.nn.functional as F
from torch.nn import Parameter
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
import torch.nn.modules.loss
from scipy.sparse import *
def dropout(x, drop_prob, shared_axes=[], training=False):
"""
App... |
Context2AnswerAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.modules.loss
from scipy.sparse import *
class Context2AnswerAttention(nn.Module):
def __init__(self, dim, hidden_size):
super(Context2AnswerAttention, self).__init__()
self.linear_sim = nn.Linear(dim, hidden_size, bias=False)
def forward(self... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | IBM/graph4nlp | Context2AnswerAttention | false | 8,333 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class Model(nn.Module):
def __init__(self, dim, hidden_size):
super().__init__()
self.linear_sim = nn.Linear(dim, hidden_size, bias=False)
def forward(self, context, answers, out_answers, ans_mask=None)... |
decoder5 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 decoder5(nn.Module):
def __init__(self):
super(decoder5, self).__init__()
self.reflecPad15 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv15 = nn.Conv2d(512, 512, 3, 1, 0)
self.relu15 = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingN... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Holmes-Alan/RefVAE | decoder5 | false | 8,334 | [
"MIT"
] | 13 | 836b8f1168f1b0f923b609a48e202ace7806f79c | https://github.com/Holmes-Alan/RefVAE/tree/836b8f1168f1b0f923b609a48e202ace7806f79c | import torch
from torch import nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.reflecPad15 = nn.ReflectionPad2d((1, 1, 1, 1))
self.conv15 = nn.Conv2d(512, 512, 3, 1, 0)
self.relu15 = nn.ReLU(inplace=True)
self.unpool = nn.UpsamplingNearest2d(scale_fa... |
LxmertAttentionOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class LxmertAttentionOutput(nn.Module):
def __init__(self, hidden_size, hidden_dropout_prob):
super().__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.LayerNorm = nn.LayerNorm(... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.utils.... | IsmaelElsharkawi/new_pororo_repo | LxmertAttentionOutput | false | 8,335 | [
"MIT"
] | 19 | 4617083b420615b8a3eb0f44d02e4e91a8f407f7 | https://github.com/IsmaelElsharkawi/new_pororo_repo/tree/4617083b420615b8a3eb0f44d02e4e91a8f407f7 | import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, hidden_size, hidden_dropout_prob):
super().__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.LayerNorm = nn.LayerNorm(hidden_size, eps... |
MixActiv | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch as th
from torch import nn
def gauss(x, mean=0, std=1):
return th.exp(-(x - mean) ** 2 / (2 * std ** 2))
class MixActiv(nn.Module):
def __init__(self):
super().__init__()
self.activations = th.sin, th.tanh, gauss, th.relu
self.n_activs = len(self.activation... | 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... | JiangZehua/control-pcgrl | MixActiv | false | 8,336 | [
"MIT"
] | 15 | e4fd1bf9670e5855f04941ebca34170517c451b4 | https://github.com/JiangZehua/control-pcgrl/tree/e4fd1bf9670e5855f04941ebca34170517c451b4 | import torch
import torch as th
from torch import nn
def gauss(x, mean=0, std=1):
return th.exp(-(x - mean) ** 2 / (2 * std ** 2))
class Model(nn.Module):
def __init__(self):
super().__init__()
self.activations = th.sin, th.tanh, gauss, th.relu
self.n_activs = len(self.activations)
... |
ClassPredictor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ClassPredictor(nn.Module):
def __init__(self, nz_feat, max_object_classes):
super(ClassPredictor, self).__init__()
self.predictor = nn.Linear(nz_feat, max_object_classes)
def forward(self, feats):
class_logits = self.predictor(feats)
re... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | JasonQSY/Associative3D | ClassPredictor | false | 8,337 | [
"MIT"
] | 25 | c50818b593ec48c38ed7ee3e109c23531089da32 | https://github.com/JasonQSY/Associative3D/tree/c50818b593ec48c38ed7ee3e109c23531089da32 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, nz_feat, max_object_classes):
super().__init__()
self.predictor = nn.Linear(nz_feat, max_object_classes)
def forward(self, feats):
class_logits = self.predictor(feats)
return torch.nn.functional.log_... |
InnerProductDecoder | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
import torch.nn.modules.loss
from scipy.sparse import *
def dropout(x, drop_prob, shared_axes=[], training=False):
"""
Apply dropout to input tensor.
Parameters
----------
input_tensor: ``torch.FloatTensor``
A tensor of shap... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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.modules.loss
from scipy.sparse import *
ass... | IBM/graph4nlp | InnerProductDecoder | false | 8,338 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | import torch
from torch import nn
import torch.nn.functional as F
import torch.nn.modules.loss
from scipy.sparse import *
def dropout(x, drop_prob, shared_axes=[], training=False):
"""
Apply dropout to input tensor.
Parameters
----------
input_tensor: ``torch.FloatTensor``
A tensor of shap... |
GRUStep | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.modules.loss
from scipy.sparse import *
class GRUStep(nn.Module):
def __init__(self, hidden_size, input_size):
super(GRUStep, self).__init__()
"""GRU module"""
self.linear_z = nn.Linear(hidden_size + input_size, hidden_size,
bi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
from torch import n... | IBM/graph4nlp | GRUStep | false | 8,339 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class Model(nn.Module):
def __init__(self, hidden_size, input_size):
super().__init__()
"""GRU module"""
self.linear_z = nn.Linear(hidden_size + input_size, hidden_size,
bias=False)
... |
ScalePredictor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ScalePredictor(nn.Module):
def __init__(self, nz):
super(ScalePredictor, self).__init__()
self.pred_layer = nn.Linear(nz, 3)
def forward(self, feat):
scale = self.pred_layer.forward(feat) + 1
scale = torch.nn.functional.relu(scale) + 1e... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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... | JasonQSY/Associative3D | ScalePredictor | false | 8,340 | [
"MIT"
] | 25 | c50818b593ec48c38ed7ee3e109c23531089da32 | https://github.com/JasonQSY/Associative3D/tree/c50818b593ec48c38ed7ee3e109c23531089da32 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, nz):
super().__init__()
self.pred_layer = nn.Linear(nz, 3)
def forward(self, feat):
scale = self.pred_layer.forward(feat) + 1
scale = torch.nn.functional.relu(scale) + 1e-12
return scale
de... |
CombinedTargetMSELoss | # 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 CombinedTargetMSELoss(nn.Module):
"""MSE loss for combined target.
CombinedTarget: The combination of classification target
(response map) and regression target (offset map).
Paper ref: Huang et al. The Devil is in the Details: Delving into
... | 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... | Jackqu/mmpose | CombinedTargetMSELoss | false | 8,341 | [
"Apache-2.0"
] | 38 | ad8acc5ff5da7993c6befdc4b1ced2c2ecb64533 | https://github.com/Jackqu/mmpose/tree/ad8acc5ff5da7993c6befdc4b1ced2c2ecb64533 | import torch
import torch.nn as nn
class Model(nn.Module):
"""MSE loss for combined target.
CombinedTarget: The combination of classification target
(response map) and regression target (offset map).
Paper ref: Huang et al. The Devil is in the Details: Delving into
Unbiased Data Pr... |
RelativeScalePredictor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 RelativeScalePredictor(nn.Module):
def __init__(self, in_size, out_size):
super(RelativeScalePredictor, self).__init__()
self.predictor = nn.Linear(in_size, out_size)
def forward(self, feat):
predictions = self.predictor.forward(feat) + 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.... | JasonQSY/Associative3D | RelativeScalePredictor | false | 8,342 | [
"MIT"
] | 25 | c50818b593ec48c38ed7ee3e109c23531089da32 | https://github.com/JasonQSY/Associative3D/tree/c50818b593ec48c38ed7ee3e109c23531089da32 | import torch
from torch import nn
class Model(nn.Module):
def __init__(self, in_size, out_size):
super().__init__()
self.predictor = nn.Linear(in_size, out_size)
def forward(self, feat):
predictions = self.predictor.forward(feat) + 1
predictions = torch.nn.functional.relu(pre... |
UpSample | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class UpSample(nn.Sequential):
def __init__(self, skip_input, output_features):
super(UpSample, self).__init__()
self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3,
stride=1, padding=1)
self.leak... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | JanRocketMan/regression-prior-networks | UpSample | false | 8,343 | [
"MIT"
] | 24 | 3c8ffa758ee6eaa15b8afe31ac1c03f87bbf6a14 | https://github.com/JanRocketMan/regression-prior-networks/tree/3c8ffa758ee6eaa15b8afe31ac1c03f87bbf6a14 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Sequential):
def __init__(self, skip_input, output_features):
super().__init__()
self.convA = nn.Conv2d(skip_input, output_features, kernel_size=3,
stride=1, padding=1)
self.leakyreluA = nn.Leaky... |
BasicConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BasicConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, **kwargs):
super(BasicConv2d, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, bias=
False, **kwarg... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | JinkaiZheng/TraND | BasicConv2d | false | 8,344 | [
"MIT"
] | 33 | a8babc34073ee126789969bd97e149bae4015953 | https://github.com/JinkaiZheng/TraND/tree/a8babc34073ee126789969bd97e149bae4015953 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, **kwargs):
super().__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, bias=
False, **kwargs)
def forward(sel... |
TransNonlinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
class TransNonlinear(nn.Module):
def __init__(self, d_model, dim_feedforward, dropout=0.1):
super().__init__()
self.linear1 = nn.Linear(d_model, dim_feedforward)
self.dropout = nn.Dropout(dropout)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Jasonkks/PTTR | TransNonlinear | false | 8,345 | [
"Apache-2.0"
] | 14 | 11f664a7f1b2281293d82a5450fdd3d4bfa5883e | https://github.com/Jasonkks/PTTR/tree/11f664a7f1b2281293d82a5450fdd3d4bfa5883e | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.utils.data
class Model(nn.Module):
def __init__(self, d_model, dim_feedforward, dropout=0.1):
super().__init__()
self.linear1 = nn.Linear(d_model, dim_feedforward)
self.dropout = nn.Dropout(dropout)
self.line... |
LxmertAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class LxmertAttention(nn.Module):
def __init__(self, hidden_size, num_attention_heads,
attention_probs_dropout_prob, ctx_dim=None):
super().__init__()
if hidden_size % num_attentio... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | IsmaelElsharkawi/new_pororo_repo | LxmertAttention | false | 8,346 | [
"MIT"
] | 19 | 4617083b420615b8a3eb0f44d02e4e91a8f407f7 | https://github.com/IsmaelElsharkawi/new_pororo_repo/tree/4617083b420615b8a3eb0f44d02e4e91a8f407f7 | import math
import torch
import torch.utils.data
import torch.nn as nn
import torch
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, hidden_size, num_attention_heads,
attention_probs_dropout_prob, ctx_dim=None):
super().__init__()
if hidden_size % num_attention_heads !=... |
Downsample | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Downsample(torch.nn.Module):
def __init__(self, s, use_max=False, batch_mode=False):
super(Downsample, self).__init__()
self.batch_mode = batch_mode
if use_max:
layer = torch.nn.MaxPool3d(s, stride=s)
else:
layer = torch.nn.Conv3d(1, 1, 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
reinterpret_tens... | JasonQSY/Associative3D | Downsample | false | 8,347 | [
"MIT"
] | 25 | c50818b593ec48c38ed7ee3e109c23531089da32 | https://github.com/JasonQSY/Associative3D/tree/c50818b593ec48c38ed7ee3e109c23531089da32 | import torch
class Model(torch.nn.Module):
def __init__(self, s, use_max=False, batch_mode=False):
super().__init__()
self.batch_mode = batch_mode
if use_max:
layer = torch.nn.MaxPool3d(s, stride=s)
else:
layer = torch.nn.Conv3d(1, 1, s, stride=s)
... |
MeanEmbedding | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class MeanEmbedding(nn.Module):
"""Mean embedding class.
"""
def __init__(self):
super(MeanEmbedding, self).__init__()
def forward(self, emb, len_):
"""Compute average embeddings.
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 import nn
import torch.nn.modules.loss
from scipy.sparse import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride... | IBM/graph4nlp | MeanEmbedding | false | 8,348 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class Model(nn.Module):
"""Mean embedding class.
"""
def __init__(self):
super().__init__()
def forward(self, emb, len_):
"""Compute average embeddings.
Parameters
----------
... |
GatedFusion | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.modules.loss
from scipy.sparse import *
class GatedFusion(nn.Module):
def __init__(self, hidden_size):
super(GatedFusion, self).__init__()
"""GatedFusion module"""
self.fc_z = nn.Linear(4 * hidden_size, hidden_size, bias=True)
def for... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import 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.modules.loss
from scipy.sparse import *
ass... | IBM/graph4nlp | GatedFusion | false | 8,349 | [
"Apache-2.0"
] | 18 | a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | https://github.com/IBM/graph4nlp/tree/a9bf20b23fa1ec368d9bd40cc8c557f86a9f8297 | import torch
from torch import nn
import torch.nn.modules.loss
from scipy.sparse import *
class Model(nn.Module):
def __init__(self, hidden_size):
super().__init__()
"""GatedFusion module"""
self.fc_z = nn.Linear(4 * hidden_size, hidden_size, bias=True)
def forward(self, h_state, inp... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.