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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
Accuracy | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
from torch import Tensor
class Accuracy(Module):
"""
Class for calculating the accuracy for a given prediction and the labels
for comparison.
Expects the inputs to be from a range of 0 to 1 and sets a crossing threshold at 0.5
the labels are similarly round... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn import Module
from torch import Tensor
assert_size_stride = torch._C._dynam... | bharadwaj1098/sparseml | Accuracy | false | 6,327 | [
"Apache-2.0"
] | 1 | b43dc3edc9f7e6cd32368937b7ed3352180abe52 | https://github.com/bharadwaj1098/sparseml/tree/b43dc3edc9f7e6cd32368937b7ed3352180abe52 | from torch.nn import Module
import torch
from torch import Tensor
class Model(Module):
"""
Class for calculating the accuracy for a given prediction and the labels
for comparison.
Expects the inputs to be from a range of 0 to 1 and sets a crossing threshold at 0.5
the labels are similarly rounded.... |
Attention | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import math
import torch
import torch.nn.functional as F
import torch.utils.data
def restricted_softmax(src, dim: 'int'=-1, margin: 'float'=0.0):
src_max = torch.clamp(src.max(dim=dim, keepdim=True)[0], min=0.0)
out = (src - src_max).exp()
out = out / (out.sum(dim=dim, keepdim=True) + (margin - src_max).e... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | beneisner/pytorch_geometric | Attention | false | 6,328 | [
"MIT"
] | 1 | 53d44a96bd2de2753b1ab1d7153c026c92606a81 | https://github.com/beneisner/pytorch_geometric/tree/53d44a96bd2de2753b1ab1d7153c026c92606a81 | import math
import torch
import torch.nn.functional as F
import torch.utils.data
def restricted_softmax(src, dim: 'int'=-1, margin: 'float'=0.0):
src_max = torch.clamp(src.max(dim=dim, keepdim=True)[0], min=0.0)
out = (src - src_max).exp()
out = out / (out.sum(dim=dim, keepdim=True) + (margin - src_max).e... |
DentReLU | # 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 DentReLUFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, input, p):
ctx.save_for_backward(input)
ctx.p = p
output = input.clone()
mask1 = p <= input
mask2 = input <= 0
output[mask1 & mask2] = 0
r... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | bfeng/pytorch-cifar | DentReLU | false | 6,329 | [
"MIT"
] | 1 | 6de257bb4b489429785502d487044c55bec62aae | https://github.com/bfeng/pytorch-cifar/tree/6de257bb4b489429785502d487044c55bec62aae | import torch
import torch.nn as nn
class DentReLUFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, input, p):
ctx.save_for_backward(input)
ctx.p = p
output = input.clone()
mask1 = p <= input
mask2 = input <= 0
output[mask1 & mask2] = 0
r... |
LuongAttentionConcat | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 LuongAttentionConcat(nn.Module):
def __init__(self, units, hidden_size):
super().__init__()
self.W = nn.Linear(2 * hidden_size, units)
self.V = nn.Linear(units, 1)
def forward(self, query, values):
query... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | beroguedou/nmt-pytorch | LuongAttentionConcat | false | 6,330 | [
"MIT"
] | 1 | 8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | https://github.com/beroguedou/nmt-pytorch/tree/8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, units, hidden_size):
super().__init__()
self.W = nn.Linear(2 * hidden_size, units)
self.V = nn.Linear(units, 1)
def forward(self, query, values):
query = torch.squeez... |
BahdanauAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 BahdanauAttention(nn.Module):
def __init__(self, units, hidden_size):
super().__init__()
self.W1 = nn.Linear(hidden_size, units)
self.W2 = nn.Linear(hidden_size, units)
self.V = nn.Linear(units, 1)
def f... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | beroguedou/nmt-pytorch | BahdanauAttention | false | 6,331 | [
"MIT"
] | 1 | 8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | https://github.com/beroguedou/nmt-pytorch/tree/8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, units, hidden_size):
super().__init__()
self.W1 = nn.Linear(hidden_size, units)
self.W2 = nn.Linear(hidden_size, units)
self.V = nn.Linear(units, 1)
def forward(self,... |
RC | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 RC(nn.Module):
"""
A wrapper class for ReflectionPad2d, Conv2d and an optional relu
"""
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1,
activation_function=True):
super().__init__()
self.pad... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | benningtonlee7/AdaIn_Style_Transfer_From_Scratch_In_Pytorch | RC | false | 6,332 | [
"MIT"
] | 1 | 50dfe4bdcbcdd0f4e647f9ee45de2a3f81eb6722 | https://github.com/benningtonlee7/AdaIn_Style_Transfer_From_Scratch_In_Pytorch/tree/50dfe4bdcbcdd0f4e647f9ee45de2a3f81eb6722 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
A wrapper class for ReflectionPad2d, Conv2d and an optional relu
"""
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1,
activation_function=True):
super().__init__()
self.... |
Decoder | # 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 Decoder(nn.Module):
""" Encoder
"""
def __init__(self, n_levels, n_color, n_eccentricity, n_azimuth,
n_theta, n_phase):
super(Decoder, self).__init__()
self.n_levels = n_levels
self.n_color = n_color
... | 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... | bicv/POLO | Decoder | false | 6,333 | [
"MIT"
] | 1 | b8d4f9014796a4eb24c178d8be611a0b3b4c44df | https://github.com/bicv/POLO/tree/b8d4f9014796a4eb24c178d8be611a0b3b4c44df | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
""" Encoder
"""
def __init__(self, n_levels, n_color, n_eccentricity, n_azimuth,
n_theta, n_phase):
super().__init__()
self.n_levels = n_levels
self.n_color = n_color
self.n_... |
ImageProcessingModuleAlt | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ImageProcessingModuleAlt(nn.Module):
def __init__(self, n_filters):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=n_filters * 2,
kernel_size=7)
self.conv2 = nn.Conv2d(in_channels=n... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | bentrevett/task-oriented-language-grounding | ImageProcessingModuleAlt | false | 6,334 | [
"MIT"
] | 1 | 812a7bc21ee622030eb0594c576c7d60dc630148 | https://github.com/bentrevett/task-oriented-language-grounding/tree/812a7bc21ee622030eb0594c576c7d60dc630148 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, n_filters):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=n_filters * 2,
kernel_size=7)
self.conv2 = nn.Conv2d(in_channels=n_filters * 2, out_c... |
MultimodalFusionModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MultimodalFusionModule(nn.Module):
def __init__(self, emb_dim, n_filters):
super().__init__()
self.fc_h = nn.Linear(emb_dim, n_filters)
def forward(self, image, instruction):
_batch_size, _n_filters, _height, _width = image.shape
a = 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.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | bentrevett/task-oriented-language-grounding | MultimodalFusionModule | false | 6,335 | [
"MIT"
] | 1 | 812a7bc21ee622030eb0594c576c7d60dc630148 | https://github.com/bentrevett/task-oriented-language-grounding/tree/812a7bc21ee622030eb0594c576c7d60dc630148 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, emb_dim, n_filters):
super().__init__()
self.fc_h = nn.Linear(emb_dim, n_filters)
def forward(self, image, instruction):
_batch_size, _n_filters, _height, _width = image.shape
a = torch.sigmoid(self... |
LuongAttentionDot | # 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 LuongAttentionDot(nn.Module):
def __init__(self):
super().__init__()
def forward(self, query, values):
query = torch.squeeze(query, 0)
query = torch.unsqueeze(query, 1)
query_transposed = query.transpose... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | beroguedou/nmt-pytorch | LuongAttentionDot | false | 6,336 | [
"MIT"
] | 1 | 8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | https://github.com/beroguedou/nmt-pytorch/tree/8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | 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, query, values):
query = torch.squeeze(query, 0)
query = torch.unsqueeze(query, 1)
query_transposed = query.transpose(2, 1)
... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self, feature_num):
super(Net, self).__init__()
self.layer_1 = nn.Linear(feature_num, 500)
self.layer_2 = nn.Linear(500, 20)
def forward(self, x):
x = F.relu(self.layer_1(x))... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | bm2-lab/scPrivacy | Net | false | 6,337 | [
"MIT"
] | 1 | 444c8f3a5e7b890c299cd823359e5414f73d6205 | https://github.com/bm2-lab/scPrivacy/tree/444c8f3a5e7b890c299cd823359e5414f73d6205 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, feature_num):
super().__init__()
self.layer_1 = nn.Linear(feature_num, 500)
self.layer_2 = nn.Linear(500, 20)
def forward(self, x):
x = F.relu(self.layer_1(x))
... |
MLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class MLP(nn.Module):
"""
Multi-Layer Perceptron
:param in_dim: int, size of input feature
:param n_classes: int, number of output classes
:param hidden_dim: int, size of hidden vector
:param dropout: fl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
from torch.nn import functional as F
assert_size_stride = t... | bigdata-ustc/DisenQNet | MLP | false | 6,338 | [
"MIT"
] | 1 | 908fadeb9b8d278450213deff70205703bd91da6 | https://github.com/bigdata-ustc/DisenQNet/tree/908fadeb9b8d278450213deff70205703bd91da6 | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""
Multi-Layer Perceptron
:param in_dim: int, size of input feature
:param n_classes: int, number of output classes
:param hidden_dim: int, size of hidden vector
:param dropout: ... |
PairwiseBCELoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from abc import abstractmethod
import torch.utils.data.dataloader
import torch.nn.functional as F
import torch.nn as nn
import torch.nn
import torch.optim.optimizer
class SimilarityLoss(nn.Module):
def __init__(self):
super(SimilarityLoss, self).__init__()
@abstractmethod
def forwar... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from abc im... | bogdankostic/flair | PairwiseBCELoss | false | 6,339 | [
"MIT"
] | 1 | 8cf03eab19512e94c1bcb4a30409bb065d37fe25 | https://github.com/bogdankostic/flair/tree/8cf03eab19512e94c1bcb4a30409bb065d37fe25 | import torch
from abc import abstractmethod
import torch.utils.data.dataloader
import torch.nn.functional as F
import torch.nn as nn
import torch.nn
import torch.optim.optimizer
class SimilarityLoss(nn.Module):
def __init__(self):
super().__init__()
@abstractmethod
def forward(self, inputs, targ... |
FociDetector | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class FociDetector(nn.Module):
def __init__(self, input_channels=3, input_size=17, ksize=5,
hidden_channels=10):
super(FociDetector, self).__init__()
self.conv1 = nn.Conv2d(input_channels, hidden_channels, ksize,
strid... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | bharath272/centrosome-analysis | FociDetector | false | 6,340 | [
"MIT"
] | 1 | 6ae3744be464812b3767909420d7b78cea9da670 | https://github.com/bharath272/centrosome-analysis/tree/6ae3744be464812b3767909420d7b78cea9da670 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, input_channels=3, input_size=17, ksize=5,
hidden_channels=10):
super().__init__()
self.conv1 = nn.Conv2d(input_channels, hidden_channels, ksize,
stride=2, padding=int((ksize -... |
LuongAttentionGeneral | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 LuongAttentionGeneral(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.W = nn.Linear(hidden_size, hidden_size)
def forward(self, query, values):
query = torch.squeeze(query, 0)
query ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | beroguedou/nmt-pytorch | LuongAttentionGeneral | false | 6,341 | [
"MIT"
] | 1 | 8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | https://github.com/beroguedou/nmt-pytorch/tree/8758ba33e2d5f4eca7f1ac2d04582678332bbcd5 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, hidden_size):
super().__init__()
self.W = nn.Linear(hidden_size, hidden_size)
def forward(self, query, values):
query = torch.squeeze(query, 0)
query = torch.unsqueez... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def hidden_unit(layer):
inp = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(inp)
return -lim, lim
class Actor(nn.Module):
def __init__(self, state_size, action_size, seed=2, fc_units=256):
super(Actor, s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | bnriiitb/Deep-Reinforcement-Learning | Actor | false | 6,342 | [
"MIT"
] | 1 | 5649a9d86fbec32fe3ac9cbb923d0d3a4c692d1e | https://github.com/bnriiitb/Deep-Reinforcement-Learning/tree/5649a9d86fbec32fe3ac9cbb923d0d3a4c692d1e | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def hidden_unit(layer):
inp = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(inp)
return -lim, lim
class Model(nn.Module):
def __init__(self, state_size, action_size, seed=2, fc_units=256):
super().__init... |
PositionwiseFeedforwardLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PositionwiseFeedforwardLayer(nn.Module):
def __init__(self, hid_dim: 'int', pf_dim: 'int', dropout: 'float') ->None:
super().__init__()
self.fc_1 = nn.Linear(hid_dim, pf_dim)
self.fc_2 = nn.Linear(pf_dim, hid_dim)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | bob80333/investigating_extrapolation | PositionwiseFeedforwardLayer | false | 6,343 | [
"MIT"
] | 1 | fc4f72baa46b8490968f7ad546897937feb8b25d | https://github.com/bob80333/investigating_extrapolation/tree/fc4f72baa46b8490968f7ad546897937feb8b25d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, hid_dim: 'int', pf_dim: 'int', dropout: 'float') ->None:
super().__init__()
self.fc_1 = nn.Linear(hid_dim, pf_dim)
self.fc_2 = nn.Linear(pf_dim, hid_dim)
self.dropout = nn... |
KopoinANNNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 KopoinANNNetwork(nn.Module):
def __init__(self, featShape):
super(KopoinANNNetwork, self).__init__()
self.featShape = featShape
self.act = nn.Sigmoid()
self.layer0 = nn.Linear(featShape, featShape // 2)
self.layer1 = nn.Linear(featS... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | bmd2007/benchmark_eval | KopoinANNNetwork | false | 6,344 | [
"MIT"
] | 1 | aa42bb3369e79db4cb63e1963afcc8af6d8f5696 | https://github.com/bmd2007/benchmark_eval/tree/aa42bb3369e79db4cb63e1963afcc8af6d8f5696 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, featShape):
super().__init__()
self.featShape = featShape
self.act = nn.Sigmoid()
self.layer0 = nn.Linear(featShape, featShape // 2)
self.layer1 = nn.Linear(featShape // 2, featShape // 2)
... |
BertPooler | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
import torch.nn.functional
from torch import nn
class BertPooler(nn.Module):
def __init__(self, config):
super(BertPooler, self).__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.GELU()... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.fun... | bj1103/FaST-VGS-Family | BertPooler | false | 6,345 | [
"BSD-3-Clause"
] | 1 | 824f987a5bd647fc17aa34b98eb1d9109441d64b | https://github.com/bj1103/FaST-VGS-Family/tree/824f987a5bd647fc17aa34b98eb1d9109441d64b | from _paritybench_helpers import _mock_config
import torch
import torch.nn.functional
from torch import nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.GELU()
def forward(sel... |
PatchMerge | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PatchMerge(nn.Module):
"""
Implements the Patch Merge operator from Swin Transformer
"""
def __init__(self, channels: 'int', window_size: 'int'=2):
super(PatchMerge, self).__init__()
self.merger = nn.Conv2d(in_channels=channels, out_channels=
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_st... | bradezard131/swin-transformer | PatchMerge | false | 6,346 | [
"MIT"
] | 1 | 72e38cbae8bda332d03dced814d10b45185c04de | https://github.com/bradezard131/swin-transformer/tree/72e38cbae8bda332d03dced814d10b45185c04de | import torch
from torch import nn
class Model(nn.Module):
"""
Implements the Patch Merge operator from Swin Transformer
"""
def __init__(self, channels: 'int', window_size: 'int'=2):
super().__init__()
self.merger = nn.Conv2d(in_channels=channels, out_channels=
window_size... |
PatchEmbed | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PatchEmbed(nn.Module):
""" Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
num_patches = img_size // patch_size * (img_size // patch_size)
self.img_size = img_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... | bmi-imaginelab/CD-Net-Histopathology-Representation-Learning-using-Pyramidal-Context-Detail-Network | PatchEmbed | false | 6,347 | [
"Apache-2.0"
] | 1 | cc4dad85cdeea7295cb48f6f947fd1ac25d8862e | https://github.com/bmi-imaginelab/CD-Net-Histopathology-Representation-Learning-using-Pyramidal-Context-Detail-Network/tree/cc4dad85cdeea7295cb48f6f947fd1ac25d8862e | import torch
import torch.nn as nn
class Model(nn.Module):
""" Image to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
num_patches = img_size // patch_size * (img_size // patch_size)
self.img_size = img_size
... |
LunarLanderDQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 LunarLanderDQN(nn.Module):
def __init__(self, state_space_dim, action_space_dim, hidden=12):
super(LunarLanderDQN, self).__init__()
self.hidden = hidden
self.fc1 = nn.Linear(state_space_dim, hidden)
self.fc2 ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | breno-aberle/rl-pong-project | LunarLanderDQN | false | 6,348 | [
"MIT"
] | 1 | 9dc0d12e4bbcdb2905d46f66e84fac6d70c7831d | https://github.com/breno-aberle/rl-pong-project/tree/9dc0d12e4bbcdb2905d46f66e84fac6d70c7831d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_space_dim, action_space_dim, hidden=12):
super().__init__()
self.hidden = hidden
self.fc1 = nn.Linear(state_space_dim, hidden)
self.fc2 = nn.Linear(hidden, hidden)
... |
DuelingQNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 DuelingQNetwork(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed, fc1_units=48):
"""Initialize parameters and build model.
Params
======
state_size (int): Dimen... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | bobiblazeski/navigation | DuelingQNetwork | false | 6,349 | [
"MIT"
] | 1 | bb863b4475a90ff26bede20af647ae4882a0f6fb | https://github.com/bobiblazeski/navigation/tree/bb863b4475a90ff26bede20af647ae4882a0f6fb | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed, fc1_units=48):
"""Initialize parameters and build model.
Params
======
state_size (int): Dimension of ea... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 5)
self.pool = nn.MaxPool2d(2, 2)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
return x... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | bongsang/face-landmark | Net | false | 6,350 | [
"MIT"
] | 1 | bc7644480be1ddf8d35c2875d251bc84c00ccaa7 | https://github.com/bongsang/face-landmark/tree/bc7644480be1ddf8d35c2875d251bc84c00ccaa7 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, 5)
self.pool = nn.MaxPool2d(2, 2)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
return x
def ... |
RankingLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from abc import abstractmethod
import torch.utils.data.dataloader
import torch.nn.functional as F
import torch.nn as nn
import torch.nn
import torch.optim.optimizer
class SimilarityLoss(nn.Module):
def __init__(self):
super(SimilarityLoss, self).__init__()
@abstractmethod
def forwar... | 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 abc import abstractmethod
import torch.utils.data.dataloader
import torch.nn as nn
i... | bogdankostic/flair | RankingLoss | false | 6,351 | [
"MIT"
] | 1 | 8cf03eab19512e94c1bcb4a30409bb065d37fe25 | https://github.com/bogdankostic/flair/tree/8cf03eab19512e94c1bcb4a30409bb065d37fe25 | import torch
from abc import abstractmethod
import torch.utils.data.dataloader
import torch.nn.functional as F
import torch.nn as nn
import torch.nn
import torch.optim.optimizer
class SimilarityLoss(nn.Module):
def __init__(self):
super().__init__()
@abstractmethod
def forward(self, inputs, targ... |
AttnModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class MLP(nn.Module):
"""
Multi-Layer Perceptron
:param in_dim: int, size of input feature
:param n_classes: int, number of output classes
:param hidden_dim: int, size of hidden vector
:param dropout: fl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | bigdata-ustc/DisenQNet | AttnModel | false | 6,352 | [
"MIT"
] | 1 | 908fadeb9b8d278450213deff70205703bd91da6 | https://github.com/bigdata-ustc/DisenQNet/tree/908fadeb9b8d278450213deff70205703bd91da6 | import torch
from torch import nn
from torch.nn import functional as F
class MLP(nn.Module):
"""
Multi-Layer Perceptron
:param in_dim: int, size of input feature
:param n_classes: int, number of output classes
:param hidden_dim: int, size of hidden vector
:param dropout: fl... |
QNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class QNetwork(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed, fc1_units=48):
"""Initialize parameters and build model.
Params
======
state_size (int): Dimension of... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | bobiblazeski/navigation | QNetwork | false | 6,353 | [
"MIT"
] | 1 | bb863b4475a90ff26bede20af647ae4882a0f6fb | https://github.com/bobiblazeski/navigation/tree/bb863b4475a90ff26bede20af647ae4882a0f6fb | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""Actor (Policy) Model."""
def __init__(self, state_size, action_size, seed, fc1_units=48):
"""Initialize parameters and build model.
Params
======
state_size (int): Dimension of ea... |
Block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
from torch import nn
import torch.nn.functional as F
def drop_path(x, drop_prob: 'float'=0.0, training: 'bool'=False):
if drop_prob == 0.0 or not training:
return x
keep_prob = 1 - drop_prob
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
random_tensor = keep_prob +... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | au55555/classification-pytorch | Block | false | 6,354 | [
"MIT"
] | 1 | 1937599ae6e688ed7af7470f69964fb6f97241c4 | https://github.com/au55555/classification-pytorch/tree/1937599ae6e688ed7af7470f69964fb6f97241c4 | import torch
import numpy as np
from torch import nn
import torch.nn.functional as F
def drop_path(x, drop_prob: 'float'=0.0, training: 'bool'=False):
if drop_prob == 0.0 or not training:
return x
keep_prob = 1 - drop_prob
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
random_tensor = keep_prob +... |
MaskedLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.cuda
from torch.nn.functional import *
class MaskedLinear(torch.nn.Linear):
def forward(self, x, mask):
out = super().forward(x)
if mask.is_floating_point():
out = out * mask
else:
out = out * mask.type_as(out)
return out
def get... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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.cuda
from torch.nn.functional import *
assert_size_stride = torch._... | bratao/DeepSpeed | MaskedLinear | false | 6,355 | [
"MIT"
] | 1 | c50d8955e942e5e26cf81835d59ec3f20ef8540d | https://github.com/bratao/DeepSpeed/tree/c50d8955e942e5e26cf81835d59ec3f20ef8540d | import torch
import torch.cuda
from torch.nn.functional import *
class Model(torch.nn.Linear):
def forward(self, x, mask):
out = super().forward(x)
if mask.is_floating_point():
out = out * mask
else:
out = out * mask.type_as(out)
return out
def get_inputs... |
CartpoleDQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 CartpoleDQN(nn.Module):
def __init__(self, state_space_dim, action_space_dim, hidden=12):
super(CartpoleDQN, self).__init__()
self.hidden = hidden
self.fc1 = nn.Linear(state_space_dim, hidden)
self.fc2 = nn.L... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | breno-aberle/rl-pong-project | CartpoleDQN | false | 6,356 | [
"MIT"
] | 1 | 9dc0d12e4bbcdb2905d46f66e84fac6d70c7831d | https://github.com/breno-aberle/rl-pong-project/tree/9dc0d12e4bbcdb2905d46f66e84fac6d70c7831d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_space_dim, action_space_dim, hidden=12):
super().__init__()
self.hidden = hidden
self.fc1 = nn.Linear(state_space_dim, hidden)
self.fc2 = nn.Linear(hidden, action_sp... |
AvgPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | from torch.nn import Module
import torch
import torch as th
class AvgPool2d(Module):
"""
This class is the beginning of an exact python port of the torch.nn.AvgPool2d
module. Because PySyft cannot hook into layers which are implemented in C++,
our special functionalities (such as encrypted computation... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch.nn import Module
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._em... | brandonhee/PySyft | AvgPool2d | false | 6,357 | [
"Apache-2.0"
] | 1 | 31217f28aa3d996b2bb84477fb15a990f0cb9a80 | https://github.com/brandonhee/PySyft/tree/31217f28aa3d996b2bb84477fb15a990f0cb9a80 | from torch.nn import Module
import torch
import torch as th
class Model(Module):
"""
This class is the beginning of an exact python port of the torch.nn.AvgPool2d
module. Because PySyft cannot hook into layers which are implemented in C++,
our special functionalities (such as encrypted computation) do... |
Critic | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def hidden_unit(layer):
inp = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(inp)
return -lim, lim
class Critic(nn.Module):
def __init__(self, state_size, action_size, seed=2, fc1_units=256,
fc2_units=256... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | bnriiitb/Deep-Reinforcement-Learning | Critic | false | 6,358 | [
"MIT"
] | 1 | 5649a9d86fbec32fe3ac9cbb923d0d3a4c692d1e | https://github.com/bnriiitb/Deep-Reinforcement-Learning/tree/5649a9d86fbec32fe3ac9cbb923d0d3a4c692d1e | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
def hidden_unit(layer):
inp = layer.weight.data.size()[0]
lim = 1.0 / np.sqrt(inp)
return -lim, lim
class Model(nn.Module):
def __init__(self, state_size, action_size, seed=2, fc1_units=256,
fc2_units=256,... |
SimpleModel | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.cuda
from torch.nn.functional import *
class SimpleModel(torch.nn.Module):
def __init__(self, hidden_dim, empty_grad=False, rank=0):
super(SimpleModel, self).__init__()
self.linear = torch.nn.Linear(hidden_dim, hidden_dim)
if empty_grad:
self.linear2 ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | bratao/DeepSpeed | SimpleModel | false | 6,359 | [
"MIT"
] | 1 | c50d8955e942e5e26cf81835d59ec3f20ef8540d | https://github.com/bratao/DeepSpeed/tree/c50d8955e942e5e26cf81835d59ec3f20ef8540d | import torch
import torch.cuda
from torch.nn.functional import *
class Model(torch.nn.Module):
def __init__(self, hidden_dim, empty_grad=False, rank=0):
super().__init__()
self.linear = torch.nn.Linear(hidden_dim, hidden_dim)
if empty_grad:
self.linear2 = torch.nn.Linear(hidde... |
Mid_block | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
class Mid_block(nn.Module):
def __init__(self, chanIn, chanOut, ks=3, stride=1):
super().__init__()
self.conv1 = nn.Conv3d(chanIn, chanOut, ks, padding=1)
self.conv2 = nn.Conv3d(chanOut, chanOut, ks, padding=1)
def forward(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.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dyn... | basharbme/3d_segmentation | Mid_block | false | 6,360 | [
"MIT"
] | 1 | efcd966f74ebb74614515c38930e820ea1c4744e | https://github.com/basharbme/3d_segmentation/tree/efcd966f74ebb74614515c38930e820ea1c4744e | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, chanIn, chanOut, ks=3, stride=1):
super().__init__()
self.conv1 = nn.Conv3d(chanIn, chanOut, ks, padding=1)
self.conv2 = nn.Conv3d(chanOut, chanOut, ks, padding=1)
def forward(self, ... |
MaskedLinearSeqDup | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.cuda
from torch.nn.functional import *
class MaskedLinear(torch.nn.Linear):
def forward(self, x, mask):
out = super().forward(x)
if mask.is_floating_point():
out = out * mask
else:
out = out * mask.type_as(out)
return out
class M... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.cuda
from torch.nn.functional import *
assert_size_stride = torch._... | bratao/DeepSpeed | MaskedLinearSeqDup | false | 6,361 | [
"MIT"
] | 1 | c50d8955e942e5e26cf81835d59ec3f20ef8540d | https://github.com/bratao/DeepSpeed/tree/c50d8955e942e5e26cf81835d59ec3f20ef8540d | import torch
import torch.cuda
from torch.nn.functional import *
class MaskedLinear(torch.nn.Linear):
def forward(self, x, mask):
out = super().forward(x)
if mask.is_floating_point():
out = out * mask
else:
out = out * mask.type_as(out)
return out
class M... |
MultiChannelCombinedScorer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.functional as F
class FociDetector(nn.Module):
def __init__(self, input_channels=3, input_size=17, ksize=5,
hidden_channels=10):
super(FociDetector, self).__init__()
self.conv1 = nn.Conv2d(input_channels, hidden_ch... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | bharath272/centrosome-analysis | MultiChannelCombinedScorer | false | 6,362 | [
"MIT"
] | 1 | 6ae3744be464812b3767909420d7b78cea9da670 | https://github.com/bharath272/centrosome-analysis/tree/6ae3744be464812b3767909420d7b78cea9da670 | import torch
import torch.nn as nn
import torch.utils.data
import torch.nn.functional as F
class FociDetector(nn.Module):
def __init__(self, input_channels=3, input_size=17, ksize=5,
hidden_channels=10):
super().__init__()
self.conv1 = nn.Conv2d(input_channels, hidden_channels, ksize,
... |
SmoothBCEwLogits | # 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.functional as F
from torch.nn.modules.loss import _WeightedLoss
class SmoothBCEwLogits(_WeightedLoss):
def __init__(self, weight=None, reduction='mean', smoothing=0.0,
pos_weight=None):
super().__init__(weight=weight, reduction=reduction)
... | 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... | broadinstitute/lincs-profiling-comparison | SmoothBCEwLogits | false | 6,363 | [
"BSD-3-Clause"
] | 1 | 075c3bc60eeb3934fc42c30bae6aeed8cda1cd6d | https://github.com/broadinstitute/lincs-profiling-comparison/tree/075c3bc60eeb3934fc42c30bae6aeed8cda1cd6d | import torch
import torch.utils.data
import torch.nn.functional as F
from torch.nn.modules.loss import _WeightedLoss
class Model(_WeightedLoss):
def __init__(self, weight=None, reduction='mean', smoothing=0.0,
pos_weight=None):
super().__init__(weight=weight, reduction=reduction)
self.smo... |
Net | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self, input_seq_length, output_num_classes):
"""Initialize model layers"""
super(Net, self).__init__()
self.input_seq_length = input_seq_length
self.output_num_classes = output_nu... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | bradford415/multiclassification | Net | false | 6,364 | [
"MIT"
] | 1 | ee0234ec0a85b04f78cd86c3e5c52e5d658f19ac | https://github.com/bradford415/multiclassification/tree/ee0234ec0a85b04f78cd86c3e5c52e5d658f19ac | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_seq_length, output_num_classes):
"""Initialize model layers"""
super().__init__()
self.input_seq_length = input_seq_length
self.output_num_classes = output_num_class... |
L2loss | # 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 L2loss(torch.nn.Module):
def __init__(self):
super(L2loss, self).__init__()
def forward(self, y, yhat):
loss = (y - yhat).pow(2).sum() / y.shape[0]
return loss
def get_inputs():
return [torch.rand([4, 4, 4, 4]), 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
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | btolooshams/densae | L2loss | false | 6,365 | [
"MIT"
] | 1 | a1e4c4cc1b4be0386d42136f2695615ea3cf4815 | https://github.com/btolooshams/densae/tree/a1e4c4cc1b4be0386d42136f2695615ea3cf4815 | import torch
class Model(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, y, yhat):
loss = (y - yhat).pow(2).sum() / y.shape[0]
return loss
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
retur... |
FeedForwardActorNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 FeedForwardActorNN(nn.Module):
def __init__(self, in_dim, out_dim, is_discrete):
super(FeedForwardActorNN, self).__init__()
self.layer1 = nn.Linear(in_dim, 64)
self.layer2 = nn.Linear(64, 64)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | britig/policy-refinement-bo | FeedForwardActorNN | false | 6,366 | [
"MIT"
] | 1 | c8a1e347d6e27c991e945afae9b5d9b482806f4b | https://github.com/britig/policy-refinement-bo/tree/c8a1e347d6e27c991e945afae9b5d9b482806f4b | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, in_dim, out_dim, is_discrete):
super().__init__()
self.layer1 = nn.Linear(in_dim, 64)
self.layer2 = nn.Linear(64, 64)
self.layer3 = nn.Linear(64, out_di... |
Disc | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
from torch.nn import functional as F
class MLP(nn.Module):
"""
Multi-Layer Perceptron
:param in_dim: int, size of input feature
:param n_classes: int, number of output classes
:param hidden_dim: int, size of hidden vector
:param dropout: fl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
from torch.nn import functional as F
assert_size_stride = t... | bigdata-ustc/DisenQNet | Disc | false | 6,367 | [
"MIT"
] | 1 | 908fadeb9b8d278450213deff70205703bd91da6 | https://github.com/bigdata-ustc/DisenQNet/tree/908fadeb9b8d278450213deff70205703bd91da6 | import torch
from torch import nn
from torch.nn import functional as F
class MLP(nn.Module):
"""
Multi-Layer Perceptron
:param in_dim: int, size of input feature
:param n_classes: int, number of output classes
:param hidden_dim: int, size of hidden vector
:param dropout: fl... |
MultiheadAttentionWrapper | # 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
from torch.nn.utils import weight_norm
from torch.optim.lr_scheduler import *
import torch.utils.data
import torch.onnx.operators
import torch.optim
import torch.optim.lr_scheduler
def linear(x):
return x
def activation(func_a):
"""Activatio... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils import weight_norm
from torch.optim.lr_scheduler import *
import t... | brightgems/BartWithRL | MultiheadAttentionWrapper | false | 6,368 | [
"MIT"
] | 1 | 17614c4009ec976cdc73dacaf94573a6d8f6d529 | https://github.com/brightgems/BartWithRL/tree/17614c4009ec976cdc73dacaf94573a6d8f6d529 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils import weight_norm
from torch.optim.lr_scheduler import *
import torch.utils.data
import torch.onnx.operators
import torch.optim
import torch.optim.lr_scheduler
def linear(x):
return x
def activation(func_a):
"""Activatio... |
CNNCifar | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.nn.functional as F
class CNNCifar(nn.Module):
def __init__(self, args):
super(CNNCifar, self).__init__()
self.conv1 = nn.Conv2d(3, 64, 5)
self.pool1 = nn.MaxPool2d(2, 2)
self.conv2 = nn.Co... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | bobvo23/Federated-Learning-PyTorch | CNNCifar | false | 6,369 | [
"MIT"
] | 1 | e5cffe8f39cfad76c13c78b9f1c6ef0976e4cc81 | https://github.com/bobvo23/Federated-Learning-PyTorch/tree/e5cffe8f39cfad76c13c78b9f1c6ef0976e4cc81 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, args):
super().__init__()
self.conv1 = nn.Conv2d(3, 64, 5)
self.pool1 = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(64, 64, 5)
... |
MLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
class MLP(nn.Module):
def __init__(self, input_size, output_size, hidden=128):
super(MLP, self).__init__()
self.linear1 = nn.Linear(input_size, hidden, bias=False)
self.linear2 = nn.Linear(hidden, output_size, bias=False)
def forw... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | bwubrian/cherry | MLP | false | 6,370 | [
"Apache-2.0"
] | 1 | de0cd2d833336144bce2a0b97e4dad40cbd78d7c | https://github.com/bwubrian/cherry/tree/de0cd2d833336144bce2a0b97e4dad40cbd78d7c | import torch
import torch as th
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, output_size, hidden=128):
super().__init__()
self.linear1 = nn.Linear(input_size, hidden, bias=False)
self.linear2 = nn.Linear(hidden, output_size, bias=False)
def forward(sel... |
Parseval_Conv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
class Parseval_Conv2d(nn.Conv2d):
def forward(self, input):
new_weight = self.weight / np.sqrt(2 * self.kernel_size[0] * self.
kernel_size[1] + 1)
return F.conv2d(input, new_weight, self.bias, self.s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | cadurosar/laplacian_networks | Parseval_Conv2d | false | 6,371 | [
"MIT"
] | 1 | 27f6f2d7145426b38f578e9c1beecae3e7392f1b | https://github.com/cadurosar/laplacian_networks/tree/27f6f2d7145426b38f578e9c1beecae3e7392f1b | import torch
import numpy as np
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Conv2d):
def forward(self, input):
new_weight = self.weight / np.sqrt(2 * self.kernel_size[0] * self.
kernel_size[1] + 1)
return F.conv2d(input, new_weight, self.bias, self.stride, sel... |
SuperLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.utils.data
from torch import nn
import torch
class netMSELoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, target):
return self.computeLoss(output, target)
def computeLoss(self, output, target):
loss = torch.mean((output ... | 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
from torch import nn
import torch
assert_size_stride = torch._C._... | brown-ivl/beacon | SuperLoss | false | 6,372 | [
"MIT"
] | 1 | 66a1714473b362294f787f261561e39c52f00e42 | https://github.com/brown-ivl/beacon/tree/66a1714473b362294f787f261561e39c52f00e42 | import torch
import torch.utils.data
from torch import nn
import torch
class netMSELoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, output, target):
return self.computeLoss(output, target)
def computeLoss(self, output, target):
loss = torch.mean((output ... |
Bicubic | # 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 Bicubic(nn.Module):
def __init__(self, scale_factor=2):
super().__init__()
self.scale_factor = scale_factor
def forward(self, inputs):
bicubic_output = F.interpolate(inputs, scale_factor=self.
scale_... | 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... | bui-thanh-lam/image-super-resolution | Bicubic | false | 6,373 | [
"BSD-2-Clause"
] | 1 | 8eee69c9fdd3aaf760fabfb5a294f083c7ddf4ac | https://github.com/bui-thanh-lam/image-super-resolution/tree/8eee69c9fdd3aaf760fabfb5a294f083c7ddf4ac | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, scale_factor=2):
super().__init__()
self.scale_factor = scale_factor
def forward(self, inputs):
bicubic_output = F.interpolate(inputs, scale_factor=self.
scale_fa... |
FCBottleNeck | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.functional as F
from torch import nn
import torch
class FCBottleNeck(nn.Module):
def __init__(self, InFeatureSize):
super().__init__()
self.FC1 = nn.Linear(InFeatureSize, 2048)
self.FC2 = nn.Linear(2048, 2048)
self.FC3 = nn.Line... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
from ... | brown-ivl/beacon | FCBottleNeck | false | 6,374 | [
"MIT"
] | 1 | 66a1714473b362294f787f261561e39c52f00e42 | https://github.com/brown-ivl/beacon/tree/66a1714473b362294f787f261561e39c52f00e42 | import torch
import torch.utils.data
import torch.nn.functional as F
from torch import nn
import torch
class Model(nn.Module):
def __init__(self, InFeatureSize):
super().__init__()
self.FC1 = nn.Linear(InFeatureSize, 2048)
self.FC2 = nn.Linear(2048, 2048)
self.FC3 = nn.Linear(2048... |
CustomizedNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.utils.data.distributed
class CustomizedNet(nn.Module):
def __init__(self, dropout, input_size, input_feature_num, hidden_dim,
output_size):
"""
Simply use linear layers for multi-variate single-step forecasting.
"""
super()._... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import ... | cabuliwallah/analytics-zoo | CustomizedNet | false | 6,375 | [
"Apache-2.0"
] | 1 | 5e662bd01c5fc7eed412973119594cf2ecea8b11 | https://github.com/cabuliwallah/analytics-zoo/tree/5e662bd01c5fc7eed412973119594cf2ecea8b11 | import torch
import torch.nn as nn
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, dropout, input_size, input_feature_num, hidden_dim,
output_size):
"""
Simply use linear layers for multi-variate single-step forecasting.
"""
super().__init__(... |
Policy | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Policy(nn.Module):
"""
implements both actor and critic in one model
"""
def __init__(self):
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.action_head = nn.Linear(128, 2)
se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | caimingxue/Reinforcement-Learning | Policy | false | 6,376 | [
"MIT"
] | 1 | 5ccb8a6a25b41526f4d6195e69964245abc46d38 | https://github.com/caimingxue/Reinforcement-Learning/tree/5ccb8a6a25b41526f4d6195e69964245abc46d38 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
implements both actor and critic in one model
"""
def __init__(self):
super().__init__()
self.affine1 = nn.Linear(4, 128)
self.action_head = nn.Linear(128, 2)
self.value_head... |
Decoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class RC(nn.Module):
"""
A wrapper class for ReflectionPad2d, Conv2d and an optional relu
"""
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1,
activation_function=True):
super().__init__()
self.pad... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | benningtonlee7/AdaIn_Style_Transfer_From_Scratch_In_Pytorch | Decoder | false | 6,377 | [
"MIT"
] | 1 | 50dfe4bdcbcdd0f4e647f9ee45de2a3f81eb6722 | https://github.com/benningtonlee7/AdaIn_Style_Transfer_From_Scratch_In_Pytorch/tree/50dfe4bdcbcdd0f4e647f9ee45de2a3f81eb6722 | import torch
import torch.nn as nn
import torch.nn.functional as F
class RC(nn.Module):
"""
A wrapper class for ReflectionPad2d, Conv2d and an optional relu
"""
def __init__(self, in_dim, out_dim, kernel_size=3, padding=1,
activation_function=True):
super().__init__()
self.pad... |
DurationPredictorLoss | # 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 DurationPredictorLoss(torch.nn.Module):
"""Loss function module for duration predictor.
The loss value is Calculated in log domain to make it Gaussian.
"""
def __init__(self, offset=1.0):
"""Initilize duration predictor loss module.
Args:
offset (floa... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
assert_size_stride = t... | carankt/FastSpeech2-1 | DurationPredictorLoss | false | 6,378 | [
"Apache-2.0"
] | 1 | 42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | https://github.com/carankt/FastSpeech2-1/tree/42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | import torch
class Model(torch.nn.Module):
"""Loss function module for duration predictor.
The loss value is Calculated in log domain to make it Gaussian.
"""
def __init__(self, offset=1.0):
"""Initilize duration predictor loss module.
Args:
offset (float, optional): Of... |
MessageNorm | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
import torch.nn.functional as F
from torch.nn import Parameter
import torch.fx
import torch.utils.data
from inspect import Parameter
from torch.nn.parameter import Parameter
class MessageNorm(torch.nn.Module):
"""Applies message normalization over the aggregated messages as d... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch.nn import Paramet... | camus1337/pytorch_geometric | MessageNorm | false | 6,379 | [
"MIT"
] | 1 | 38514197a327541eb47abb69d4ab224910852605 | https://github.com/camus1337/pytorch_geometric/tree/38514197a327541eb47abb69d4ab224910852605 | import torch
from torch import Tensor
import torch.nn.functional as F
from torch.nn import Parameter
import torch.fx
import torch.utils.data
from inspect import Parameter
from torch.nn.parameter import Parameter
class Model(torch.nn.Module):
"""Applies message normalization over the aggregated messages as describ... |
PGNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PGNetwork(nn.Module):
def __init__(self, state_dim, action_dim):
super(PGNetwork, self).__init__()
self.fc1 = nn.Linear(state_dim, 20)
self.fc2 = nn.Linear(20, action_dim)
def forward(self, x):
out = F.r... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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_... | caimingxue/Reinforcement-Learning | PGNetwork | false | 6,380 | [
"MIT"
] | 1 | 5ccb8a6a25b41526f4d6195e69964245abc46d38 | https://github.com/caimingxue/Reinforcement-Learning/tree/5ccb8a6a25b41526f4d6195e69964245abc46d38 | 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.fc1 = nn.Linear(state_dim, 20)
self.fc2 = nn.Linear(20, action_dim)
def forward(self, x):
out = F.relu(self.fc1(x))
... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
class LayerNorm(torch.nn.Module):
def __init__(self, nout: 'int'):
super(LayerNorm, self).__init__()
self.layer_norm = torch.nn.LayerNorm(nout, eps=1e-12)
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
x = self.layer_norm(x.transpose(1, -1))
x = x.transpose... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_c... | carankt/FastSpeech2-1 | LayerNorm | false | 6,381 | [
"Apache-2.0"
] | 1 | 42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | https://github.com/carankt/FastSpeech2-1/tree/42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | import torch
class Model(torch.nn.Module):
def __init__(self, nout: 'int'):
super().__init__()
self.layer_norm = torch.nn.LayerNorm(nout, eps=1e-12)
def forward(self, x: 'torch.Tensor') ->torch.Tensor:
x = self.layer_norm(x.transpose(1, -1))
x = x.transpose(1, -1)
ret... |
LayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import Tensor
from torch.nn import Parameter
from torch.nn import LayerNorm
from typing import Optional
import torch.fx
from typing import Any
import torch.utils.data
from inspect import Parameter
from torch.nn.parameter import Parameter
def maybe_num_nodes(edge_index, num_nodes=None):
if ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import Tensor
fro... | camus1337/pytorch_geometric | LayerNorm | false | 6,382 | [
"MIT"
] | 1 | 38514197a327541eb47abb69d4ab224910852605 | https://github.com/camus1337/pytorch_geometric/tree/38514197a327541eb47abb69d4ab224910852605 | import torch
from torch import Tensor
from torch.nn import Parameter
from torch.nn import LayerNorm
from typing import Optional
import torch.fx
from typing import Any
import torch.utils.data
from inspect import Parameter
from torch.nn.parameter import Parameter
def maybe_num_nodes(edge_index, num_nodes=None):
if ... |
MultiLayeredConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MultiLayeredConv1d(torch.nn.Module):
"""Multi-layered conv1d for Transformer block.
This is a module of multi-leyered conv1d designed to replace positionwise feed-forward network
in Transforner block, which is introduced in `FastSpeech: Fast, Robust and Controllable Text to Speech`_.
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C... | carankt/FastSpeech2-1 | MultiLayeredConv1d | false | 6,383 | [
"Apache-2.0"
] | 1 | 42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | https://github.com/carankt/FastSpeech2-1/tree/42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | import torch
class Model(torch.nn.Module):
"""Multi-layered conv1d for Transformer block.
This is a module of multi-leyered conv1d designed to replace positionwise feed-forward network
in Transforner block, which is introduced in `FastSpeech: Fast, Robust and Controllable Text to Speech`_.
Args:
... |
DepthConv2d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 DepthConv2d(nn.Module):
def __init__(self, input_channel, hidden_channel, kernel, padding,
dilation=1):
super(DepthConv2d, self).__init__()
self.conv2d = nn.Conv2d(input_channel, hidden_channel, 1)
self.padding = padding
self.dconv2... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | c-ma13/sepTFNet | DepthConv2d | false | 6,384 | [
"MIT"
] | 1 | a06c89c080f9449ac2e5090f80d9645deea7f23a | https://github.com/c-ma13/sepTFNet/tree/a06c89c080f9449ac2e5090f80d9645deea7f23a | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_channel, hidden_channel, kernel, padding,
dilation=1):
super().__init__()
self.conv2d = nn.Conv2d(input_channel, hidden_channel, 1)
self.padding = padding
self.dconv2d = nn.Conv2d(hidden_ch... |
SequenceQuantizerSoftEMA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.cuda
class SequenceQuantizerSoftEMA(nn.Module):
def __init__(self, codebook_size, d_model, l1_cost=1000, entropy_cost=
5e-05, num_samples=10, temp=1.0, epsilon=1e-05, padding_idx=None):
super(SequenceQuantizerSoftEMA,... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | brcsomnath/SemAE | SequenceQuantizerSoftEMA | false | 6,385 | [
"MIT"
] | 1 | 8da5de73a5b334c6cb0b22eadaaacc35e98126ed | https://github.com/brcsomnath/SemAE/tree/8da5de73a5b334c6cb0b22eadaaacc35e98126ed | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.cuda
class Model(nn.Module):
def __init__(self, codebook_size, d_model, l1_cost=1000, entropy_cost=
5e-05, num_samples=10, temp=1.0, epsilon=1e-05, padding_idx=None):
super().__init__()
self.d_model = d_model
... |
BertAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super(BertLayerNorm, self).__init__... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | caldoe/BERT-NL2SPARQL | BertAttention | false | 6,386 | [
"MIT"
] | 1 | 2e09c1aeffc855bc7f1dc8c182e21153b2bc73a8 | https://github.com/caldoe/BERT-NL2SPARQL/tree/2e09c1aeffc855bc7f1dc8c182e21153b2bc73a8 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super().__init__()
self.wei... |
CTLoss | # 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.onnx
def _neg_loss(preds, gt):
pos_inds = gt.eq(1)
neg_inds = gt.lt(1)
neg_weights = torch.pow(1 - gt[neg_inds], 4)
loss = 0
for pred in preds:
pos_pred = pred[pos_inds]
neg_pred = pred[neg_inds]
pos_loss = torch.log(pos_pred)... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
import torch.onnx
assert_size_stride = torch._C._dynamo.guards.asse... | c464851257/extremenet-lite | CTLoss | false | 6,387 | [
"BSD-3-Clause"
] | 1 | 331446f2c5d9524d46d2b33823eff02416f43052 | https://github.com/c464851257/extremenet-lite/tree/331446f2c5d9524d46d2b33823eff02416f43052 | import torch
import torch.nn as nn
import torch.onnx
def _neg_loss(preds, gt):
pos_inds = gt.eq(1)
neg_inds = gt.lt(1)
neg_weights = torch.pow(1 - gt[neg_inds], 4)
loss = 0
for pred in preds:
pos_pred = pred[pos_inds]
neg_pred = pred[neg_inds]
pos_loss = torch.log(pos_pred)... |
upsampleBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 swish(x):
return x * torch.sigmoid(x)
class upsampleBlock(nn.Module):
def __init__(self, in_channels, out_channels):
super(upsampleBlock, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, 3, stride=1, padding=1
)
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | carl-zjr/super-resolution-reconstruction | upsampleBlock | false | 6,388 | [
"Apache-2.0"
] | 1 | 37b5b42ea6e8864c12a93a7e90d3bf0920f502d4 | https://github.com/carl-zjr/super-resolution-reconstruction/tree/37b5b42ea6e8864c12a93a7e90d3bf0920f502d4 | import torch
import torch.nn as nn
def swish(x):
return x * torch.sigmoid(x)
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.conv = nn.Conv2d(in_channels, out_channels, 3, stride=1, padding=1
)
self.shuffler = nn.PixelShuffl... |
SeparableConvBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.optim
class SeparableConvBlock(nn.Module):
def __init__(self, inplanes, planes):
super(SeparableConvBlock, self).__init__()
self.depthwise_conv = nn.Conv2d(inplanes, inplanes, kernel_size=3,
stride=1, padding=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
import torch.nn.parallel
import torch.optim
assert_size_st... | carol007/pytorch-ImageNet-CIFAR-COCO-VOC-training | SeparableConvBlock | false | 6,389 | [
"MIT"
] | 1 | e8b37046e6fbe914f6a68bbde1fe419c46373c1d | https://github.com/carol007/pytorch-ImageNet-CIFAR-COCO-VOC-training/tree/e8b37046e6fbe914f6a68bbde1fe419c46373c1d | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
class Model(nn.Module):
def __init__(self, inplanes, planes):
super().__init__()
self.depthwise_conv = nn.Conv2d(inplanes, inplanes, kernel_size=3,
stride=1, padding=1, groups=inplanes, bias=False)
... |
GlobalChannelLayerNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 GlobalChannelLayerNorm(nn.Module):
"""
Global channel layer normalization
"""
def __init__(self, dim, eps=1e-05, elementwise_affine=True):
super(GlobalChannelLayerNorm, self).__init__()
self.eps = eps
self.normalized_dim = dim
s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_... | c-ma13/sepTFNet | GlobalChannelLayerNorm | false | 6,390 | [
"MIT"
] | 1 | a06c89c080f9449ac2e5090f80d9645deea7f23a | https://github.com/c-ma13/sepTFNet/tree/a06c89c080f9449ac2e5090f80d9645deea7f23a | import torch
import torch.nn as nn
class Model(nn.Module):
"""
Global channel layer normalization
"""
def __init__(self, dim, eps=1e-05, elementwise_affine=True):
super().__init__()
self.eps = eps
self.normalized_dim = dim
self.elementwise_affine = elementwise_affine
... |
HighwayNetwork | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class HighwayNetwork(nn.Module):
def __init__(self, size):
super().__init__()
self.W1 = nn.Linear(size, size)
self.W2 = nn.Linear(size, size)
self.W1.bias.data.fill_(0.0)
def forward(self, x):
x1 = sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | cassiavb/Tacotron | HighwayNetwork | false | 6,391 | [
"MIT"
] | 1 | 946408f8cd7b5fe9c53931c631267ba2a723910d | https://github.com/cassiavb/Tacotron/tree/946408f8cd7b5fe9c53931c631267ba2a723910d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, size):
super().__init__()
self.W1 = nn.Linear(size, size)
self.W2 = nn.Linear(size, size)
self.W1.bias.data.fill_(0.0)
def forward(self, x):
x1 = self.W1(x)
... |
LevelVariabilityLoss | # 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 LevelVariabilityLoss(nn.Module):
"""Computes the variability penalty for the level.
levels: levels obtained from exponential smoothing component of ESRNN.
tensor with shape (batch, n_time).
level_variability_penalty: float.
return: level_var_loss
"""
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | cchallu/esrnn | LevelVariabilityLoss | false | 6,392 | [
"MIT"
] | 1 | 543ca365c70be2775a4b5863820b246071ccde3c | https://github.com/cchallu/esrnn/tree/543ca365c70be2775a4b5863820b246071ccde3c | import torch
import torch.nn as nn
class Model(nn.Module):
"""Computes the variability penalty for the level.
levels: levels obtained from exponential smoothing component of ESRNN.
tensor with shape (batch, n_time).
level_variability_penalty: float.
return: level_var_loss
"""
def __init__(s... |
MultiHeadedAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import numpy as np
from typing import Optional
from torch import nn
class MultiHeadedAttention(nn.Module):
"""Multi-Head Attention layer
:param int n_head: the number of head s
:param int n_feat: the number of features
:param float dropout_rate: dropout rate
"""
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
from torch._inductor.runtime.... | carankt/FastSpeech2-1 | MultiHeadedAttention | false | 6,393 | [
"Apache-2.0"
] | 1 | 42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | https://github.com/carankt/FastSpeech2-1/tree/42c06e4fbdf741a0719154d1cb4617b7d3f15a5c | import math
import torch
import numpy as np
from typing import Optional
from torch import nn
class Model(nn.Module):
"""Multi-Head Attention layer
:param int n_head: the number of head s
:param int n_feat: the number of features
:param float dropout_rate: dropout rate
"""
def __init__(self, ... |
MaskedInstanceNorm1d | # 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.cuda
from torch import nn
import torch.utils.data
import torch.optim
class MaskedInstanceNorm1d(nn.Module):
"""Instance norm + masking."""
MAX_CNT = 100000.0
def __init__(self, d_channel: 'int', unbiased: 'bool'=True, affine:
'bool'=False):
super().__init__()
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
import torch.cuda
from torch... | carolmanderson/NeMo | MaskedInstanceNorm1d | false | 6,394 | [
"Apache-2.0"
] | 1 | be7114e2d983af751e1af4119465c626682747b7 | https://github.com/carolmanderson/NeMo/tree/be7114e2d983af751e1af4119465c626682747b7 | import torch
import torch.cuda
from torch import nn
import torch.utils.data
import torch.optim
class Model(nn.Module):
"""Instance norm + masking."""
MAX_CNT = 100000.0
def __init__(self, d_channel: 'int', unbiased: 'bool'=True, affine:
'bool'=False):
super().__init__()
self.d_cha... |
MaxPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from typing import *
from torch import nn
class MaxPool2d(nn.Module):
def __init__(self, kernel_size, **kwargs):
super().__init__()
stride = kwargs.setdefault('stride', kernel_size)
padding = kwargs.setdefault('padding', 0)
dilation = kwargs.setdefault('dilation', 1)
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from typing import *
from torch import nn
assert_size_stride = torch._C._dynamo.guards.as... | cbarrick/csb | MaxPool2d | false | 6,395 | [
"MIT"
] | 1 | 0368036ddb7594c0b6e7cdc704aeec918786e58a | https://github.com/cbarrick/csb/tree/0368036ddb7594c0b6e7cdc704aeec918786e58a | import torch
from typing import *
from torch import nn
class Model(nn.Module):
def __init__(self, kernel_size, **kwargs):
super().__init__()
stride = kwargs.setdefault('stride', kernel_size)
padding = kwargs.setdefault('padding', 0)
dilation = kwargs.setdefault('dilation', 1)
... |
DeepNeuralNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 DeepNeuralNet(torch.nn.Module):
"""
This is a six-layer neural network.
This is the default network for initializing sigma and center parameters
"""
def __init__(self, n_feature, n_hidden1, n_hidden2, n_hidden3,
n_hidden4, n_hidden5, n_hidden6, n_output):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C... | cassberk/xps_peakfit | DeepNeuralNet | false | 6,396 | [
"MIT"
] | 1 | bbdd62dbfc4d64ec2af0c509361de81b0762bd41 | https://github.com/cassberk/xps_peakfit/tree/bbdd62dbfc4d64ec2af0c509361de81b0762bd41 | import torch
class Model(torch.nn.Module):
"""
This is a six-layer neural network.
This is the default network for initializing sigma and center parameters
"""
def __init__(self, n_feature, n_hidden1, n_hidden2, n_hidden3,
n_hidden4, n_hidden5, n_hidden6, n_output):
"""
... |
ConvReLUNorm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.cuda
import torch.utils.data
import torch.optim
class ConvReLUNorm(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=1, dropout=0.0):
super(ConvReLUNorm, self).__init__()
self.conv = torch.nn.Conv1d(in_channels, out_channels, kernel_size=
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | carolmanderson/NeMo | ConvReLUNorm | false | 6,397 | [
"Apache-2.0"
] | 1 | be7114e2d983af751e1af4119465c626682747b7 | https://github.com/carolmanderson/NeMo/tree/be7114e2d983af751e1af4119465c626682747b7 | import torch
import torch.cuda
import torch.utils.data
import torch.optim
class Model(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size=1, dropout=0.0):
super().__init__()
self.conv = torch.nn.Conv1d(in_channels, out_channels, kernel_size=
kernel_size, paddin... |
SineLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SineLayer(nn.Module):
def __init__(self, in_features, out_features, bias=True, is_first=False,
omega_0=30):
super().__init__()
self.omega_0 = omega_0
self.is_first = is_first
self.in_features = in_features
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import numpy ... | ccxiaotoancai/Anim-NeRF | SineLayer | false | 6,398 | [
"MIT"
] | 1 | 1342a9e2d02411a09acecac40ac325f38708b9c9 | https://github.com/ccxiaotoancai/Anim-NeRF/tree/1342a9e2d02411a09acecac40ac325f38708b9c9 | import torch
import numpy as np
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_features, out_features, bias=True, is_first=False,
omega_0=30):
super().__init__()
self.omega_0 = omega_0
self.is_first = is_first
self.in_features = in_features
sel... |
Generator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class Generator(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.fc3 = nn.Lin... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_s... | cclaypool/pytorch-dcgan | Generator | false | 6,399 | [
"MIT"
] | 1 | a2096daf7bb75bf95e189bb3d2f820c51147b61c | https://github.com/cclaypool/pytorch-dcgan/tree/a2096daf7bb75bf95e189bb3d2f820c51147b61c | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, hidden_size)
self.fc3 = nn.Linear(... |
Generator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Generator(nn.Module):
def __init__(self, dim, hidden_dim, y_dim, sigma=0.02):
super(Generator, self).__init__()
input_dim = dim
hidden_size = hidden_dim
self.fc1 = nn.Linear(input_dim, hidden_size)
se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | ccha23/miml | Generator | false | 6,400 | [
"MIT"
] | 1 | 6a41de1c0bb41d38e3cdc6e9c27363215b7729b9 | https://github.com/ccha23/miml/tree/6a41de1c0bb41d38e3cdc6e9c27363215b7729b9 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim, hidden_dim, y_dim, sigma=0.02):
super().__init__()
input_dim = dim
hidden_size = hidden_dim
self.fc1 = nn.Linear(input_dim, hidden_size)
self.fc2 = nn.Linear(... |
StochasticPool2d | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class StochasticPool2d(torch.nn.Module):
def __init__(self, kernel_size=2, stride=2, padding=0):
super(StochasticPool2d, self).__init__()
self.kernel_size = kernel_size
self.stride = stride
self.padding = padding
self.grid_size ... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
@triton.j... | cclauss/DL4AGX | StochasticPool2d | false | 6,401 | [
"Apache-2.0"
] | 1 | b4d73f6c39b0428e32ce5656352800cc7e2cfb22 | https://github.com/cclauss/DL4AGX/tree/b4d73f6c39b0428e32ce5656352800cc7e2cfb22 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
def __init__(self, kernel_size=2, stride=2, padding=0):
super().__init__()
self.kernel_size = kernel_size
self.stride = stride
self.padding = padding
self.grid_size = kernel_size
self.paddin... |
GKDLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.nn.functional as F
class GKDLoss(nn.Module):
"""Knowledge Distillation Loss"""
def __init__(self, T):
super().__init__()
self.t = T
def forward(self, stu_pred, tea_pred, label):
stu_pred_l... | 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
... | carol007/pytorch-ImageNet-CIFAR-COCO-VOC-training | GKDLoss | false | 6,402 | [
"MIT"
] | 1 | e8b37046e6fbe914f6a68bbde1fe419c46373c1d | https://github.com/carol007/pytorch-ImageNet-CIFAR-COCO-VOC-training/tree/e8b37046e6fbe914f6a68bbde1fe419c46373c1d | import torch
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.nn.functional as F
class Model(nn.Module):
"""Knowledge Distillation Loss"""
def __init__(self, T):
super().__init__()
self.t = T
def forward(self, stu_pred, tea_pred, label):
stu_pred_log... |
makeStyle | # 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 makeStyle(nn.Module):
def __init__(self):
super().__init__()
self.flatten = nn.Flatten()
def forward(self, x0):
style = F.avg_pool2d(x0, kernel_size=(x0.shape[-2], x0.shape[-1]))
style = self.flatten(sty... | 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_... | cellimnet/scellseg-publish | makeStyle | false | 6,403 | [
"BSD-3-Clause"
] | 1 | 03bfbae11fedcf430c40419c9afadf55cbd3034d | https://github.com/cellimnet/scellseg-publish/tree/03bfbae11fedcf430c40419c9afadf55cbd3034d | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.flatten = nn.Flatten()
def forward(self, x0):
style = F.avg_pool2d(x0, kernel_size=(x0.shape[-2], x0.shape[-1]))
style = self.flatten(style)
... |
LocalMLP | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class LocalMLP(nn.Module):
def __init__(self, dim_in: 'int', use_norm: 'bool'=True):
"""a Local 1 layer MLP
:param dim_in: feat in size
:type dim_in: int
:param use_norm: if to apply layer norm, defaults to True
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | cdicle-motional/l5kit | LocalMLP | false | 6,404 | [
"Apache-2.0"
] | 1 | 4dc4ee5391479bb71f0b373f39c316f9eef5a961 | https://github.com/cdicle-motional/l5kit/tree/4dc4ee5391479bb71f0b373f39c316f9eef5a961 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, dim_in: 'int', use_norm: 'bool'=True):
"""a Local 1 layer MLP
:param dim_in: feat in size
:type dim_in: int
:param use_norm: if to apply layer norm, defaults to True
... |
MV_Softmax | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
from torch.nn import functional as F
import torch._utils
from torch.nn import Parameter
from itertools import product as product
import torch.utils.data.distributed
class MV_Softmax(Module):
"""Implementation for "Mis-classified Vector Guided Softmax Loss for F... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | cavalleria/FaceX-Zoo | MV_Softmax | false | 6,405 | [
"Apache-2.0"
] | 1 | c4bf8924f1858928f8cf83efabf8ad237c67f620 | https://github.com/cavalleria/FaceX-Zoo/tree/c4bf8924f1858928f8cf83efabf8ad237c67f620 | from torch.nn import Module
import math
import torch
from torch.nn import functional as F
import torch._utils
from torch.nn import Parameter
from itertools import product as product
import torch.utils.data.distributed
class Model(Module):
"""Implementation for "Mis-classified Vector Guided Softmax Loss for Face R... |
ShakeResNeXt | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.si... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 math
from torch import... | cdtalley/AutoML | ShakeResNeXt | false | 6,406 | [
"MIT"
] | 1 | 918cda6bb1bd55b4ca974bdcdd59e32b2e28399d | https://github.com/cdtalley/AutoML/tree/918cda6bb1bd55b4ca974bdcdd59e32b2e28399d | import math
import torch
from torch import nn
from numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.si... |
p_model | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
class p_model(nn.Module):
"""
input: N * C * W * H
output: N * 1 * W * H
"""
def __init__(self):
super(p_model, self).__init__()
def forward(self, x):
n, c, w, h = x.size()
x = x.view(n, c, w * h).permu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_str... | cenkcorapci/visual-fashion-item-search | p_model | false | 6,407 | [
"MIT"
] | 1 | 47b93f97383c1b7f9ec23bb4ff66f90504db3da8 | https://github.com/cenkcorapci/visual-fashion-item-search/tree/47b93f97383c1b7f9ec23bb4ff66f90504db3da8 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
input: N * C * W * H
output: N * 1 * W * H
"""
def __init__(self):
super().__init__()
def forward(self, x):
n, c, w, h = x.size()
x = x.view(n, c, w * h).permute(0, 2, 1)
... |
ShakeResNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
from numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.si... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 math
from torch import... | cdtalley/AutoML | ShakeResNet | false | 6,408 | [
"MIT"
] | 1 | 918cda6bb1bd55b4ca974bdcdd59e32b2e28399d | https://github.com/cdtalley/AutoML/tree/918cda6bb1bd55b4ca974bdcdd59e32b2e28399d | import math
import torch
from torch import nn
from numpy import int64 as int64
import torch.nn.functional as F
from torch.autograd import Variable
class ShakeShake(torch.autograd.Function):
@staticmethod
def forward(ctx, x1, x2, training=True):
if training:
alpha = torch.FloatTensor(x1.si... |
LanguageModelCriterion | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.autograd import *
class LanguageModelCriterion(nn.Module):
def __init__(self):
super(LanguageModelCriterion, self).__init__()
def forward(self, input, target, mask):
target = target[:, :input.size(1)]
mask = mask[:, :input.size(1)]
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.autograd import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | chagmgang/object_relation_transformer | LanguageModelCriterion | false | 6,409 | [
"MIT"
] | 1 | 04b88514f97232c12b576720e4b82226751c3c48 | https://github.com/chagmgang/object_relation_transformer/tree/04b88514f97232c12b576720e4b82226751c3c48 | import torch
import torch.nn as nn
from torch.autograd import *
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, target, mask):
target = target[:, :input.size(1)]
mask = mask[:, :input.size(1)]
output = -input.gather(2, target.unsqueeze(... |
BertSelfOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super(BertLayerNorm, 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.triton_helpers import libdevice
from torch import n... | caldoe/BERT-NL2SPARQL | BertSelfOutput | false | 6,410 | [
"MIT"
] | 1 | 2e09c1aeffc855bc7f1dc8c182e21153b2bc73a8 | https://github.com/caldoe/BERT-NL2SPARQL/tree/2e09c1aeffc855bc7f1dc8c182e21153b2bc73a8 | from _paritybench_helpers import _mock_config
import torch
from torch import nn
class BertLayerNorm(nn.Module):
def __init__(self, hidden_size, eps=1e-05):
"""Construct a layernorm module in the TF style (epsilon inside the square root).
"""
super().__init__()
self.weight = nn.Par... |
Norm | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.onnx
class Norm(nn.Module):
def __init__(self, emb_dim, eps=1e-06):
super().__init__()
self.size = emb_dim
self.alpha = nn.Parameter(torch.ones(self.size))
self.bias = nn.Parameter(torch.zeros(self.size))
self.eps = eps
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.onnx
assert_size_stride = torch._C._dynamo.g... | chandar-lab/CriticalGradientOptimization | Norm | false | 6,411 | [
"MIT"
] | 1 | 1af4b1df40489991289bb50bb69859a00b2c97c6 | https://github.com/chandar-lab/CriticalGradientOptimization/tree/1af4b1df40489991289bb50bb69859a00b2c97c6 | import torch
import torch.nn as nn
import torch.onnx
class Model(nn.Module):
def __init__(self, emb_dim, eps=1e-06):
super().__init__()
self.size = emb_dim
self.alpha = nn.Parameter(torch.ones(self.size))
self.bias = nn.Parameter(torch.zeros(self.size))
self.eps = eps
... |
RewardCriterion | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
from torch.autograd import *
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
else:
return tensor.contiguous()
class RewardCriterion(nn.Module):
def __init__(self):
super(RewardCriterion, self).__init__()
def forward(sel... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
from torch.autograd import *
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | chagmgang/object_relation_transformer | RewardCriterion | false | 6,412 | [
"MIT"
] | 1 | 04b88514f97232c12b576720e4b82226751c3c48 | https://github.com/chagmgang/object_relation_transformer/tree/04b88514f97232c12b576720e4b82226751c3c48 | import torch
import torch.nn as nn
from torch.autograd import *
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
else:
return tensor.contiguous()
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, input, seq, reward):
... |
DiceLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class DiceLoss(nn.Module):
def __init__(self, weight=None, size_average=True):
super(DiceLoss, self).__init__()
def forward(self, inputs, targets, smooth=1):
inputs = torch.sigmoid(inputs)
inputs = inputs.view(-1)
targets = targets.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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | chakerouari/UNET_segmetation | DiceLoss | false | 6,413 | [
"MIT"
] | 1 | a7d9e9ccd31595d482f620cbf9a625a486f5f0df | https://github.com/chakerouari/UNET_segmetation/tree/a7d9e9ccd31595d482f620cbf9a625a486f5f0df | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, weight=None, size_average=True):
super().__init__()
def forward(self, inputs, targets, smooth=1):
inputs = torch.sigmoid(inputs)
inputs = inputs.view(-1)
targets = targets.view(-1)
intersect... |
LocalSubGraphLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
from torch import nn
import torch.nn.functional as F
class LocalMLP(nn.Module):
def __init__(self, dim_in: 'int', use_norm: 'bool'=True):
"""a Local 1 layer MLP
:param dim_in: feat in size
:type dim_in: int
:param use_norm: if to apply layer norm, defaults to True
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | cdicle-motional/l5kit | LocalSubGraphLayer | false | 6,414 | [
"Apache-2.0"
] | 1 | 4dc4ee5391479bb71f0b373f39c316f9eef5a961 | https://github.com/cdicle-motional/l5kit/tree/4dc4ee5391479bb71f0b373f39c316f9eef5a961 | import torch
from torch import nn
import torch.nn.functional as F
class LocalMLP(nn.Module):
def __init__(self, dim_in: 'int', use_norm: 'bool'=True):
"""a Local 1 layer MLP
:param dim_in: feat in size
:type dim_in: int
:param use_norm: if to apply layer norm, defaults to True
... |
PinballLoss | # 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 PinballLoss(nn.Module):
"""Computes the pinball loss between y and y_hat.
y: actual values in torch tensor.
y_hat: predicted values in torch tensor.
tau: a float between 0 and 1 the slope of the pinball loss. In the context
of quantile regression, the value of alph... | 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... | cchallu/esrnn | PinballLoss | false | 6,415 | [
"MIT"
] | 1 | 543ca365c70be2775a4b5863820b246071ccde3c | https://github.com/cchallu/esrnn/tree/543ca365c70be2775a4b5863820b246071ccde3c | import torch
import torch.nn as nn
class Model(nn.Module):
"""Computes the pinball loss between y and y_hat.
y: actual values in torch tensor.
y_hat: predicted values in torch tensor.
tau: a float between 0 and 1 the slope of the pinball loss. In the context
of quantile regression, the value of alpha dete... |
TripletMarginLossCosine | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
import torch.nn.functional as F
class TripletMarginLossCosine(nn.Module):
def __init__(self, margin=1.0):
super(TripletMarginLossCosine, self).__init__()
self.margin = margin
def forward(self, anchor, positive, negative):
d_p = 1 - F.cosine_similarit... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from torch import nn
assert_... | cenkcorapci/visual-fashion-item-search | TripletMarginLossCosine | false | 6,416 | [
"MIT"
] | 1 | 47b93f97383c1b7f9ec23bb4ff66f90504db3da8 | https://github.com/cenkcorapci/visual-fashion-item-search/tree/47b93f97383c1b7f9ec23bb4ff66f90504db3da8 | import torch
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, margin=1.0):
super().__init__()
self.margin = margin
def forward(self, anchor, positive, negative):
d_p = 1 - F.cosine_similarity(anchor, positive).view(-1, 1)
d_n = 1... |
ImgPatches | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ImgPatches(nn.Module):
def __init__(self, input_channel=3, dim=768, patch_size=4):
super().__init__()
self.patch_embed = nn.Conv2d(input_channel, dim, kernel_size=
patch_size, stride=patch_size)
def forward(self, img):
patches = 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.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | ch0n9waiu/TransCycleGAN | ImgPatches | false | 6,417 | [
"MIT"
] | 1 | a3e846e21101400282a9f1393c1f8d150a3d92c9 | https://github.com/ch0n9waiu/TransCycleGAN/tree/a3e846e21101400282a9f1393c1f8d150a3d92c9 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_channel=3, dim=768, patch_size=4):
super().__init__()
self.patch_embed = nn.Conv2d(input_channel, dim, kernel_size=
patch_size, stride=patch_size)
def forward(self, img):
patches = self.pa... |
MultiHeadAttn | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.cuda
from torch.nn import functional as F
from torch import nn
import torch.utils.data
import torch.optim
class MultiHeadAttn(nn.Module):
def __init__(self, n_head, d_model, d_head, dropout, dropatt=0.1,
pre_lnorm=False):
super(MultiHeadAttn, self).__init__()
sel... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | carolmanderson/NeMo | MultiHeadAttn | false | 6,418 | [
"Apache-2.0"
] | 1 | be7114e2d983af751e1af4119465c626682747b7 | https://github.com/carolmanderson/NeMo/tree/be7114e2d983af751e1af4119465c626682747b7 | import torch
import torch.cuda
from torch.nn import functional as F
from torch import nn
import torch.utils.data
import torch.optim
class Model(nn.Module):
def __init__(self, n_head, d_model, d_head, dropout, dropatt=0.1,
pre_lnorm=False):
super().__init__()
self.n_head = n_head
s... |
FeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx
class FeedForward(nn.Module):
def __init__(self, emb_dim, ff_dim=2048, dropout=0.1):
super().__init__()
self.linear_1 = nn.Linear(emb_dim, ff_dim)
self.dropout = nn.Dropout(dropout)
self.linear_2 ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.onnx
assert_size_stride = torch._C._dynamo.gu... | chandar-lab/CriticalGradientOptimization | FeedForward | false | 6,419 | [
"MIT"
] | 1 | 1af4b1df40489991289bb50bb69859a00b2c97c6 | https://github.com/chandar-lab/CriticalGradientOptimization/tree/1af4b1df40489991289bb50bb69859a00b2c97c6 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx
class Model(nn.Module):
def __init__(self, emb_dim, ff_dim=2048, dropout=0.1):
super().__init__()
self.linear_1 = nn.Linear(emb_dim, ff_dim)
self.dropout = nn.Dropout(dropout)
self.linear_2 = nn.L... |
RNN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 RNN(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(RNN, self).__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | chauhankartik/DeepLearning-EarlySteps | RNN | false | 6,420 | [
"MIT"
] | 1 | 44b0189cf6e81f8032a6a80cc33ff80496ebd462 | https://github.com/chauhankartik/DeepLearning-EarlySteps/tree/44b0189cf6e81f8032a6a80cc33ff80496ebd462 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx
class MultiHeadAttention(nn.Module):
def __init__(self, num_heads, emb_dim, dim_k=None, dropout=0.1):
super().__init__()
self.emb_dim = emb_dim
self.dim_k = dim_k if dim_k else emb_dim // num_... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | chandar-lab/CriticalGradientOptimization | MultiHeadAttention | false | 6,421 | [
"MIT"
] | 1 | 1af4b1df40489991289bb50bb69859a00b2c97c6 | https://github.com/chandar-lab/CriticalGradientOptimization/tree/1af4b1df40489991289bb50bb69859a00b2c97c6 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx
class Model(nn.Module):
def __init__(self, num_heads, emb_dim, dim_k=None, dropout=0.1):
super().__init__()
self.emb_dim = emb_dim
self.dim_k = dim_k if dim_k else emb_dim // num_heads
... |
Actor | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Actor(nn.Module):
def __init__(self, state_dim, action_dim, max_action):
super(Actor, self).__init__()
self.l1 = nn.Linear(state_dim, 5)
self.l2 = nn.Linear(5, 3)
self.l3 = nn.Linear(3, action_dim)
se... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | chenbq1234/CityLearn | Actor | false | 6,422 | [
"MIT"
] | 1 | baa162435954ecd58e7f4769a46fa9046f4d2cf6 | https://github.com/chenbq1234/CityLearn/tree/baa162435954ecd58e7f4769a46fa9046f4d2cf6 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, state_dim, action_dim, max_action):
super().__init__()
self.l1 = nn.Linear(state_dim, 5)
self.l2 = nn.Linear(5, 3)
self.l3 = nn.Linear(3, action_dim)
self.max_acti... |
BayesConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
def calculate_kl(mu_p, sig_p, mu_q, sig_q):
"""
Calculates the Kullback-Leibler divergence between two univariate Gaussians (p and q)
Args:
mu_p: mean of the Gaussian p
sig_p: standard... | 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... | chapmanbe/uncertainty | BayesConv1d | false | 6,423 | [
"Apache-2.0"
] | 1 | d4eec00e937c76043d57a13ffcc9618b1e08d967 | https://github.com/chapmanbe/uncertainty/tree/d4eec00e937c76043d57a13ffcc9618b1e08d967 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
def calculate_kl(mu_p, sig_p, mu_q, sig_q):
"""
Calculates the Kullback-Leibler divergence between two univariate Gaussians (p and q)
Args:
mu_p: mean of the Gaussian p
sig_p: standard... |
BayesLinear | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
def calculate_kl(mu_p, sig_p, mu_q, sig_q):
"""
Calculates the Kullback-Leibler divergence between two univariate Gaussians (p and q)
Args:
mu_p: mean of the Gaussian p
sig_p: standard... | import torch
from torch import device
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libd... | chapmanbe/uncertainty | BayesLinear | false | 6,424 | [
"Apache-2.0"
] | 1 | d4eec00e937c76043d57a13ffcc9618b1e08d967 | https://github.com/chapmanbe/uncertainty/tree/d4eec00e937c76043d57a13ffcc9618b1e08d967 | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
def calculate_kl(mu_p, sig_p, mu_q, sig_q):
"""
Calculates the Kullback-Leibler divergence between two univariate Gaussians (p and q)
Args:
mu_p: mean of the Gaussian p
sig_p: standard... |
PositionwiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class LayerNorm(nn.Module):
"""
Layer Normalization class
"""
def __init__(self, features, eps=1e-06):
super(LayerNorm, self).__init__()
self.weight = nn.Parameter(torch.ones(features))
self.bias = nn.Parameter(torch.zeros(features))
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | chengjunyan1/Graph-Sparse-Transformer | PositionwiseFeedForward | false | 6,425 | [
"Apache-2.0"
] | 1 | 2c3b77f81789ca80e0c30c32f0c702b2d3bac048 | https://github.com/chengjunyan1/Graph-Sparse-Transformer/tree/2c3b77f81789ca80e0c30c32f0c702b2d3bac048 | import torch
import torch.nn as nn
class LayerNorm(nn.Module):
"""
Layer Normalization class
"""
def __init__(self, features, eps=1e-06):
super().__init__()
self.weight = nn.Parameter(torch.ones(features))
self.bias = nn.Parameter(torch.zeros(features))
self.eps = ... |
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, 7)
self.l2 = nn.Linear(7, 6)
self.l3 = nn.Linear(6, 1)
self.l4 ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | chenbq1234/CityLearn | Critic | false | 6,426 | [
"MIT"
] | 1 | baa162435954ecd58e7f4769a46fa9046f4d2cf6 | https://github.com/chenbq1234/CityLearn/tree/baa162435954ecd58e7f4769a46fa9046f4d2cf6 | 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, 7)
self.l2 = nn.Linear(7, 6)
self.l3 = nn.Linear(6, 1)
self.l4 = nn.Linear(s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.