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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
TotalVariation | # 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 TotalVariation(nn.Module):
"""TotalVariation: calculates the total variation of a patch.
Module providing the functionality necessary to calculate the total vatiation (TV) of an adversarial patch.
"""
def __init__(self):
super(TotalVariation, self)._... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert... | PJ-Steeman/2020_Masterproef | TotalVariation | false | 5,718 | [
"MIT"
] | 1 | 5bd77b4039a897d328fafe9a0b70dc8e593e2899 | https://github.com/PJ-Steeman/2020_Masterproef/tree/5bd77b4039a897d328fafe9a0b70dc8e593e2899 | import torch
import torch.nn as nn
class Model(nn.Module):
"""TotalVariation: calculates the total variation of a patch.
Module providing the functionality necessary to calculate the total vatiation (TV) of an adversarial patch.
"""
def __init__(self):
super().__init__()
def forward(se... |
CosNorm_Classifier | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class CosNorm_Classifier(nn.Module):
def __init__(self, in_dims, out_dims, scale=16, margin=0.5, init_std=0.001
):
super(CosNorm_Classifier, self).__init__()
self.in_dims = in_dims
self.out_dim... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import math
import ... | PiperLiu/AliProducts | CosNorm_Classifier | false | 5,719 | [
"MIT"
] | 1 | f51884c4dae035a879dbaca2c1575797f30ee7d3 | https://github.com/PiperLiu/AliProducts/tree/f51884c4dae035a879dbaca2c1575797f30ee7d3 | import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
class Model(nn.Module):
def __init__(self, in_dims, out_dims, scale=16, margin=0.5, init_std=0.001
):
super().__init__()
self.in_dims = in_dims
self.out_dims = out_dims
self.scale = sca... |
DownConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import copy
import torch
import torch.nn as nn
def get_conv(dim=3):
"""Chooses an implementation for a convolution layer."""
if dim == 3:
return nn.Conv3d
elif dim == 2:
return nn.Conv2d
else:
raise ValueError('dim has to be 2 or 3')
def planar_kernel(x):
"""Returns a "pl... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import copy
import torch.nn a... | PlayWeird/ct-volume-preprocessing | DownConv | false | 5,720 | [
"MIT"
] | 1 | 8bacf58c36c001fcdb809d4f74e9a39acb00bcbe | https://github.com/PlayWeird/ct-volume-preprocessing/tree/8bacf58c36c001fcdb809d4f74e9a39acb00bcbe | import copy
import torch
import torch.nn as nn
def get_conv(dim=3):
"""Chooses an implementation for a convolution layer."""
if dim == 3:
return nn.Conv3d
elif dim == 2:
return nn.Conv2d
else:
raise ValueError('dim has to be 2 or 3')
def planar_kernel(x):
"""Returns a "pl... |
CustomInverse | # 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 CustomInverse(torch.nn.Module):
def forward(self, x, y):
ress = torch.inverse(x) + x
return ress, torch.all(y)
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return [[], {}]
| import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torc... | QPC-database/onnxruntime-extensions | CustomInverse | false | 5,721 | [
"MIT"
] | 1 | 7fd96c8e9700425335b479ca042b16fe92f8b8e8 | https://github.com/QPC-database/onnxruntime-extensions/tree/7fd96c8e9700425335b479ca042b16fe92f8b8e8 | import torch
class Model(torch.nn.Module):
def forward(self, x, y):
ress = torch.inverse(x) + x
return ress, torch.all(y)
def get_inputs():
return [torch.rand([4, 4, 4, 4]), torch.rand([4, 4, 4, 4])]
def get_init_inputs():
return []
|
ConvBlock | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class ConvBlock(nn.Module):
def __init__(self):
super(ConvBlock, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
def forward(self, x):
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_... | Propaler/FedMA | ConvBlock | false | 5,722 | [
"MIT"
] | 1 | e235d971e192fb0e93abd4ad37ac603552b6484c | https://github.com/Propaler/FedMA/tree/e235d971e192fb0e93abd4ad37ac603552b6484c | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
def forward(self, x):
x = self.pool(F.relu... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
from torch import nn
import torch.nn
import torch.optim
class ContrastiveLoss(nn.Module):
"""
Contrastive loss
Takes embeddings of two samples and a target label == 1 if samples are from the same class and label == 0 otherwise
Credit due to: https://github.... | 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
import ... | QPC-database/multimodal-affinities | ContrastiveLoss | false | 5,723 | [
"Apache-2.0"
] | 1 | c3298e8db56a8b41110cc5681852f9f15d6deaa6 | https://github.com/QPC-database/multimodal-affinities/tree/c3298e8db56a8b41110cc5681852f9f15d6deaa6 | import torch
import torch.nn.functional as F
from torch import nn
import torch.nn
import torch.optim
class Model(nn.Module):
"""
Contrastive loss
Takes embeddings of two samples and a target label == 1 if samples are from the same class and label == 0 otherwise
Credit due to: https://github.com/adambi... |
BertSelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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 BertSelfAttention(nn.Module):
def __init__(self, config):
super(BertSelfAttention, self).__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | McGill-NLP/imagecode | BertSelfAttention | false | 5,724 | [
"MIT"
] | 1 | 2c636c6c41d705b4c5861841f29ff689748113d1 | https://github.com/McGill-NLP/imagecode/tree/2c636c6c41d705b4c5861841f29ff689748113d1 | from _paritybench_helpers import _mock_config
import math
import torch
from torch import nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
'The hidden size (%d) is not a ... |
SimpleCNNContainerConvBlocks | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SimpleCNNContainerConvBlocks(nn.Module):
def __init__(self, input_channel, num_filters, kernel_size, output_dim=10):
super(SimpleCNNContainerConvBlocks, self).__init__()
"""
A testing cnn container, which allows 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
import torch.nn as nn
assert_... | Propaler/FedMA | SimpleCNNContainerConvBlocks | false | 5,725 | [
"MIT"
] | 1 | e235d971e192fb0e93abd4ad37ac603552b6484c | https://github.com/Propaler/FedMA/tree/e235d971e192fb0e93abd4ad37ac603552b6484c | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_channel, num_filters, kernel_size, output_dim=10):
super().__init__()
"""
A testing cnn container, which allows initializing a CNN with given dims
We use this one to... |
AE | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 AE(nn.Module):
def __init__(self, input_shape):
super().__init__()
self.encoder_hidden_layer = nn.Linear(in_features=input_shape,
out_features=128)
self.encoder_output_layer = nn.Linear(in_features=128, out_features=128
)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | PtrMan/21V1 | AE | false | 5,726 | [
"MIT"
] | 1 | fbac4deb5bec3a5e50b81e1e91c4a8a9820d6aaa | https://github.com/PtrMan/21V1/tree/fbac4deb5bec3a5e50b81e1e91c4a8a9820d6aaa | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_shape):
super().__init__()
self.encoder_hidden_layer = nn.Linear(in_features=input_shape,
out_features=128)
self.encoder_output_layer = nn.Linear(in_features=128, out_features=128
)... |
BertMixedLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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
import torch.nn
import torch.nn as nn
class BertAttention(nn.Module):
"""BERT attention layer.
Based on: BERT (pytorch-transformer)
https://github.com/huggingface/transformers
"""
def __init__(self, config) ->None:
sup... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Erotemic/MONAI | BertMixedLayer | false | 5,727 | [
"Apache-2.0"
] | 1 | a9cd2d88168107281a2abcc2f63efaed80580e79 | https://github.com/Erotemic/MONAI/tree/a9cd2d88168107281a2abcc2f63efaed80580e79 | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn
import torch.nn as nn
class BertAttention(nn.Module):
"""BERT attention layer.
Based on: BERT (pytorch-transformer)
https://github.com/huggingface/transformers
"""
def __init__(self, config) ->None:
sup... |
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
import torch.nn as nn
class BertSelfOutput(nn.Module):
def __init__(self, config):
super(BertSelfOutput, self).__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.dropout = nn.Dropout(config.hidden_dropo... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | QuLiang132/nlp-notebook | BertSelfOutput | false | 5,728 | [
"MIT"
] | 1 | b7659867b967d1e541bee5617cee017b3b67d9ba | https://github.com/QuLiang132/nlp-notebook/tree/b7659867b967d1e541bee5617cee017b3b67d9ba | from _paritybench_helpers import _mock_config
import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
self.LayerNo... |
SelfOutput | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SelfOutput(nn.Module):
def __init__(self, hidden_size, dropout):
super(SelfOutput, self).__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.Layer_norm = nn.LayerNorm(hidden_size)
self.dropout = nn.Dropout(dropout)
def for... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | QuLiang132/nlp-notebook | SelfOutput | false | 5,729 | [
"MIT"
] | 1 | b7659867b967d1e541bee5617cee017b3b67d9ba | https://github.com/QuLiang132/nlp-notebook/tree/b7659867b967d1e541bee5617cee017b3b67d9ba | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, hidden_size, dropout):
super().__init__()
self.dense = nn.Linear(hidden_size, hidden_size)
self.Layer_norm = nn.LayerNorm(hidden_size)
self.dropout = nn.Dropout(dropout)
def forward(self, hidden_sta... |
FCLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 FCLayer(nn.Module):
def __init__(self, input_dim, output_dim, dropout_rate=0.0,
use_activation=True):
super(FCLayer, self).__init__()
self.use_activation = use_activation
self.dropout = nn.Dropout(dropout_rate)
self.linear = 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.triton_helpers import libdevice
import torch.nn as ... | Raiselimit/TorchBlocks | FCLayer | false | 5,730 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, input_dim, output_dim, dropout_rate=0.0,
use_activation=True):
super().__init__()
self.use_activation = use_activation
self.dropout = nn.Dropout(dropout_rate)
self.linear = nn.Linear(input_dim, o... |
KdMseLoss | # 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 KdMseLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, logits_S, logits_T, temperature=1):
"""
Calculate the mse loss between logits_S and logits_T
:param logits_S: Tensor of sha... | 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... | Raiselimit/TorchBlocks | KdMseLoss | false | 5,731 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | 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, logits_S, logits_T, temperature=1):
"""
Calculate the mse loss between logits_S and logits_T
:param logits_S: Tensor of shape (... |
ANNDigitDetect | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ANNDigitDetect(nn.Module):
def __init__(self):
super(ANNDigitDetect, self).__init__()
self.fc1 = nn.Linear(32 * 32, 120)
self.fc2 = nn.Linear(120, 32)
self.fc3 = nn.Linear(32, 10)
def forward(self, x):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Quest2GM/timestamp_detection_algorithm | ANNDigitDetect | false | 5,732 | [
"MIT"
] | 1 | 8a5a7fba5a924a37402d7daece90fdf626a6a905 | https://github.com/Quest2GM/timestamp_detection_algorithm/tree/8a5a7fba5a924a37402d7daece90fdf626a6a905 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(32 * 32, 120)
self.fc2 = nn.Linear(120, 32)
self.fc3 = nn.Linear(32, 10)
def forward(self, x):
x = x.view(-1, 32 * 32... |
AttMseLoss | # 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 AttMseLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, attention_S, attention_T, mask=None):
"""
Calculate the mse loss between attention_S and attention_T.
:param logits_S: Ten... | 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... | Raiselimit/TorchBlocks | AttMseLoss | false | 5,733 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | 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, attention_S, attention_T, mask=None):
"""
Calculate the mse loss between attention_S and attention_T.
:param logits_S: Tensor o... |
MaxPoolWithMask | # 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 MaxPoolWithMask(nn.Module):
"""
带mask矩阵的max pooling。在做max-pooling的时候不会考虑mask值为0的位置。
"""
def __init__(self):
super(MaxPoolWithMask, self).__init__()
self.inf = 10000000000000.0
def forward(self, tensor, mask, dim=1):
"""
:pa... | 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... | Raiselimit/TorchBlocks | MaxPoolWithMask | false | 5,734 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
带mask矩阵的max pooling。在做max-pooling的时候不会考虑mask值为0的位置。
"""
def __init__(self):
super().__init__()
self.inf = 10000000000000.0
def forward(self, tensor, mask, dim=1):
"""
:param torch.FloatTensor tensor: [... |
CosAttention | # 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 CosAttention(nn.Module):
def __init__(self):
super(CosAttention, self).__init__()
def forward(self, q, k, v):
"""
q: (batchsize, hidden_dim)
k: (batchsize, seqlen, hidden_dim)
v: (batchsize, seqlen, hidden_dim)
"""
... | 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... | Raiselimit/TorchBlocks | CosAttention | false | 5,735 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, q, k, v):
"""
q: (batchsize, hidden_dim)
k: (batchsize, seqlen, hidden_dim)
v: (batchsize, seqlen, hidden_dim)
"""
seq_len = k.size()[1]... |
AvgPool | # 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 AvgPool(nn.Module):
"""
给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size]
"""
def __init__(self, stride=None, padding=0):
super(AvgPool, self).__init__()
self.stride = stride
self.padding = paddi... | 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... | Raiselimit/TorchBlocks | AvgPool | false | 5,736 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size]
"""
def __init__(self, stride=None, padding=0):
super().__init__()
self.stride = stride
self.padding = padding
def for... |
FeatureAssembler | # 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 Optional
import torch.nn as nn
import torch.nn
import torch.optim
class FeatureAssembler(nn.Module):
def __init__(self, T: 'int', embed_static: 'Optional[FeatureEmbedder]'=
None, embed_dynamic: 'Optional[FeatureEmbedder]'=None) ->None:
super().__init__()
se... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from typing import Optional
import torch.nn as nn
import torch.nn
import torch.optim
assert_size_stride = torch._C._dynamo.guards.assert_siz... | RSNirwan/gluon-ts | FeatureAssembler | false | 5,737 | [
"Apache-2.0"
] | 1 | ae4cfdef539e49f93a87034aa2f2bec194c4b7d8 | https://github.com/RSNirwan/gluon-ts/tree/ae4cfdef539e49f93a87034aa2f2bec194c4b7d8 | import torch
from typing import Optional
import torch.nn as nn
import torch.nn
import torch.optim
class Model(nn.Module):
def __init__(self, T: 'int', embed_static: 'Optional[FeatureEmbedder]'=
None, embed_dynamic: 'Optional[FeatureEmbedder]'=None) ->None:
super().__init__()
self.T = T
... |
AvgPoolWithMask | # 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 AvgPoolWithMask(nn.Module):
"""
给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size], pooling
的时候只会考虑mask为1的位置
"""
def __init__(self):
super(AvgPoolWithMask, self).__init__()
self.inf = 10000000000000.0... | 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... | Raiselimit/TorchBlocks | AvgPoolWithMask | false | 5,738 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
给定形如[batch_size, max_len, hidden_size]的输入，在最后一维进行avg pooling. 输出为[batch_size, hidden_size], pooling
的时候只会考虑mask为1的位置
"""
def __init__(self):
super().__init__()
self.inf = 10000000000000.0
def forward(self, tensor,... |
CosLoss | # 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 CosLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, state_S, state_T, mask=None):
"""
This is the loss used in DistilBERT
:param state_S: Tensor of shape (batch_size, length, h... | 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... | Raiselimit/TorchBlocks | CosLoss | false | 5,739 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | 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, state_S, state_T, mask=None):
"""
This is the loss used in DistilBERT
:param state_S: Tensor of shape (batch_size, length, hid... |
PrimaryCaps | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 squash(inputs, axis=-1):
"""capsule输出的激活函数"""
norm = torch.norm(inputs, dim=axis, keepdim=True)
scale = norm ** 2 / (1 + norm ** 2) / (norm + 1e-08)
return scale * inputs
class PrimaryCaps(nn.Module):
"""计算第一层capsules的输入，转换成32*6*6个8维的capsule vector
in_c... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | RacleRay/-Have_Fun_Doing | PrimaryCaps | false | 5,740 | [
"Apache-2.0"
] | 1 | 8ebb7fcabc6148571d38f2f51eac47952ce54424 | https://github.com/RacleRay/-Have_Fun_Doing/tree/8ebb7fcabc6148571d38f2f51eac47952ce54424 | import torch
import torch.nn as nn
def squash(inputs, axis=-1):
"""capsule输出的激活函数"""
norm = torch.norm(inputs, dim=axis, keepdim=True)
scale = norm ** 2 / (1 + norm ** 2) / (norm + 1e-08)
return scale * inputs
class Model(nn.Module):
"""计算第一层capsules的输入，转换成32*6*6个8维的capsule vector
in_channel... |
KL | # 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 KL(nn.Module):
def __init__(self, reduction='batchmean'):
super(KL, self).__init__()
self.reduction = reduction
def forward(self, input, target):
input = input.float()
target = target.float()
los... | 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... | Raiselimit/TorchBlocks | KL | false | 5,741 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, reduction='batchmean'):
super().__init__()
self.reduction = reduction
def forward(self, input, target):
input = input.float()
target = target.float()
loss = F... |
PointWiseFeedForward | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PointWiseFeedForward(nn.Module):
def __init__(self, d_model, d_affine, fc_dorpout=0.2):
super().__init__()
self.d_model = d_model
self.d_affine = d_affine
self.linear_1 = nn.Linear(self.d_model, self.d_affine)
self.linear_2 = 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.triton_helpers import libdevice
import torch.nn as ... | RacleRay/TextSummerize | PointWiseFeedForward | false | 5,742 | [
"MIT"
] | 1 | fe2572d26d65bdf849ce89fbb0c5adf5607f06b1 | https://github.com/RacleRay/TextSummerize/tree/fe2572d26d65bdf849ce89fbb0c5adf5607f06b1 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, d_model, d_affine, fc_dorpout=0.2):
super().__init__()
self.d_model = d_model
self.d_affine = d_affine
self.linear_1 = nn.Linear(self.d_model, self.d_affine)
self.linear_2 = nn.Linear(self.d_affi... |
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
import torch.nn as nn
class BertSelfAttention(nn.Module):
"""
self attention层
原理可看这篇博客: http://jalammar.github.io/illustrated-transformer/
"""
def __init__(self, config):
super(BertSelfAttention, 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.... | QuLiang132/nlp-notebook | BertAttention | false | 5,743 | [
"MIT"
] | 1 | b7659867b967d1e541bee5617cee017b3b67d9ba | https://github.com/QuLiang132/nlp-notebook/tree/b7659867b967d1e541bee5617cee017b3b67d9ba | from _paritybench_helpers import _mock_config
import math
import torch
import torch.nn as nn
class BertSelfAttention(nn.Module):
"""
self attention层
原理可看这篇博客: http://jalammar.github.io/illustrated-transformer/
"""
def __init__(self, config):
super().__init__()
if config.hi... |
GatedConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MaskedConv1d(nn.Conv1d):
def __init__(self, in_channels, out_channels, kernel_size, dilation=1,
groups=1, bias=True, causal=True):
if causal:
padding = (kernel_size - 1) * dilation
else:
padding = (kernel_size - 1) * dilatio... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Raiselimit/TorchBlocks | GatedConv1d | false | 5,744 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class MaskedConv1d(nn.Conv1d):
def __init__(self, in_channels, out_channels, kernel_size, dilation=1,
groups=1, bias=True, causal=True):
if causal:
padding = (kernel_size - 1) * dilation
else:
padding = (kernel_size - 1) * dilatio... |
AttCeLoss | # 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 AttCeLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, attention_S, attention_T, mask=None):
"""
Calculate the cross entropy between attention_S and attention_T.
:param logits_S... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
... | Raiselimit/TorchBlocks | AttCeLoss | false | 5,745 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | 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, attention_S, attention_T, mask=None):
"""
Calculate the cross entropy between attention_S and attention_T.
:param logits_S: Te... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import math
import torch
from torch import nn
import torch.utils.data
import torch.optim
class MultiHeadAttention(nn.Module):
"""
Multi-head scaled dot-product attention layer.
Args:
hidden_size: size of the embeddings in the model, also known as d_model
num_attention_heads: number of hea... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | RPrenger/NeMo | MultiHeadAttention | false | 5,746 | [
"Apache-2.0"
] | 1 | e8912ca6e3321347272a6a7da18e052812fb2062 | https://github.com/RPrenger/NeMo/tree/e8912ca6e3321347272a6a7da18e052812fb2062 | import math
import torch
from torch import nn
import torch.utils.data
import torch.optim
class Model(nn.Module):
"""
Multi-head scaled dot-product attention layer.
Args:
hidden_size: size of the embeddings in the model, also known as d_model
num_attention_heads: number of heads in multi-h... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.nn.functional as F
class FocalLoss(nn.Module):
"""
Softmax and sigmoid focal loss
"""
def __init__(self, num_labels, activation_type='softmax', gamma=2.0,
alpha=0.25, epsilon=1e-09):
super(FocalLoss, self).__init__()
self.num_lab... | 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
... | Raiselimit/TorchBlocks | FocalLoss | false | 5,747 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Softmax and sigmoid focal loss
"""
def __init__(self, num_labels, activation_type='softmax', gamma=2.0,
alpha=0.25, epsilon=1e-09):
super().__init__()
self.num_labels = num_labels
... |
AttCeMeanLoss | # 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 AttCeMeanLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, attention_S, attention_T, mask=None):
"""
Calculate the cross entropy between attention_S and attention_T, the dim of num_heads... | 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
... | Raiselimit/TorchBlocks | AttCeMeanLoss | false | 5,748 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | 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, attention_S, attention_T, mask=None):
"""
Calculate the cross entropy between attention_S and attention_T, the dim of num_heads is aver... |
SKL | # 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 SKL(nn.Module):
def __init__(self, epsilon=1e-08):
super(SKL, self).__init__()
self.epsilon = epsilon
def forward(self, input, target):
logit = input.view(-1, input.size(-1)).float()
target = target.view... | 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
... | Raiselimit/TorchBlocks | SKL | false | 5,749 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, epsilon=1e-08):
super().__init__()
self.epsilon = epsilon
def forward(self, input, target):
logit = input.view(-1, input.size(-1)).float()
target = target.view(-1, ta... |
MultiSampleDropout | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MultiSampleDropout(nn.Module):
"""
# multisample dropout (wut): https://arxiv.org/abs/1905.09788
"""
def __init__(self, hidden_size, num_labels, K=5, p=0.5):
super().__init__()
self.K = K
self.dropout = nn.Dropout(p)
self.classi... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Raiselimit/TorchBlocks | MultiSampleDropout | false | 5,750 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Module):
"""
# multisample dropout (wut): https://arxiv.org/abs/1905.09788
"""
def __init__(self, hidden_size, num_labels, K=5, p=0.5):
super().__init__()
self.K = K
self.dropout = nn.Dropout(p)
self.classifier = nn.Lin... |
Gate | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Gate(nn.Module):
"""Gate Unit
g = sigmoid(Wx)
x = g * x
"""
def __init__(self, input_size, dropout_rate=0.0):
super(Gate, self).__init__()
self.linear = nn.Linear(input_size, input_size, bias=False)
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... | Raiselimit/TorchBlocks | Gate | false | 5,751 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Gate Unit
g = sigmoid(Wx)
x = g * x
"""
def __init__(self, input_size, dropout_rate=0.0):
super().__init__()
self.linear = nn.Linear(input_size, input_size, bias=False)
self.dropo... |
SpaceToDepth | # 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.parallel
class SpaceToDepth(nn.Module):
def __init__(self, block_size=4):
super().__init__()
assert block_size == 4
self.bs = block_size
def forward(self, x):
N, C, H, W = x.size()
x = x.view(N, C, H // self.bs, self.b... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch import nn
import torch.nn.parallel
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C.... | Randl/TResNet | SpaceToDepth | false | 5,752 | [
"Apache-2.0"
] | 1 | 18514caf61d77c7e000a71dde9d1f86ba792b38d | https://github.com/Randl/TResNet/tree/18514caf61d77c7e000a71dde9d1f86ba792b38d | import torch
from torch import nn
import torch.nn.parallel
class Model(nn.Module):
def __init__(self, block_size=4):
super().__init__()
assert block_size == 4
self.bs = block_size
def forward(self, x):
N, C, H, W = x.size()
x = x.view(N, C, H // self.bs, self.bs, W //... |
_CAEAD | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 _CAEAD(nn.Module):
def __init__(self, input_size):
super(_CAEAD, self).__init__()
self.en_1 = nn.Conv1d(1, 64, 3, padding=1)
self.pool1 = nn.MaxPool1d(2, 2)
self.en_2 = nn.Conv1d(64, 32, 3, 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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Pheobe-Sun/anomaly-detection-challenge-2020 | _CAEAD | false | 5,753 | [
"MIT"
] | 1 | 71e34350023023a17338b7931da70af035b2454c | https://github.com/Pheobe-Sun/anomaly-detection-challenge-2020/tree/71e34350023023a17338b7931da70af035b2454c | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size):
super().__init__()
self.en_1 = nn.Conv1d(1, 64, 3, padding=1)
self.pool1 = nn.MaxPool1d(2, 2)
self.en_2 = nn.Conv1d(64, 32, 3, padding=1)
self.pool2 =... |
HighwayLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class HighwayLayer(nn.Module):
def __init__(self, in_units, out_units):
super(HighwayLayer, self).__init__()
self.highway_linear = nn.Linear(in_features=in_units, out_features=
out_units, bias=True)
self.highway_gate = nn.Linear(in_features=i... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | RandolphVI/HyperNet | HighwayLayer | false | 5,754 | [
"Apache-2.0"
] | 1 | e9f376f5eb087e57360ca41cca2533c3ca967e47 | https://github.com/RandolphVI/HyperNet/tree/e9f376f5eb087e57360ca41cca2533c3ca967e47 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_units, out_units):
super().__init__()
self.highway_linear = nn.Linear(in_features=in_units, out_features=
out_units, bias=True)
self.highway_gate = nn.Linear(in_features=in_units, out_features=
... |
SEModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.parallel
class GlobalAvgPool2d:
def __init__(self, flatten=False):
self.flatten = flatten
def __call__(self, x):
if self.flatten:
in_size = x.size()
return x.view((in_size[0], in_size[1], -1)).mean(dim=2)
else:... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
import t... | Randl/TResNet | SEModule | false | 5,755 | [
"Apache-2.0"
] | 1 | 18514caf61d77c7e000a71dde9d1f86ba792b38d | https://github.com/Randl/TResNet/tree/18514caf61d77c7e000a71dde9d1f86ba792b38d | import torch
from torch import nn
import torch.nn.parallel
class GlobalAvgPool2d:
def __init__(self, flatten=False):
self.flatten = flatten
def __call__(self, x):
if self.flatten:
in_size = x.size()
return x.view((in_size[0], in_size[1], -1)).mean(dim=2)
else:... |
ContrastiveLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn.functional as F
class ContrastiveLoss(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super(ContrastiveLoss, self).__init__()
self.margin =... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
assert_size_stride = torch._... | Rajat-Mehta/Vehicle-Re-identification-UI | ContrastiveLoss | false | 5,756 | [
"MIT"
] | 1 | 9769ae9dac8bd43a3b66f705cb2830fa498649d2 | https://github.com/Rajat-Mehta/Vehicle-Re-identification-UI/tree/9769ae9dac8bd43a3b66f705cb2830fa498649d2 | import torch
import torch.nn.functional as F
class Model(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super().__init__()
self.margin = margin
def forward(self, ... |
ConvLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm
class ConvLayer(nn.Module):
def __init__(self, input_units, output_units, filter_size,
padding_sizes, dropout=0.2):
super(ConvLayer, self).__init__()
self.conv = weight_norm(nn.Conv1d(in_channels=input_units,
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | RandolphVI/HyperNet | ConvLayer | false | 5,757 | [
"Apache-2.0"
] | 1 | e9f376f5eb087e57360ca41cca2533c3ca967e47 | https://github.com/RandolphVI/HyperNet/tree/e9f376f5eb087e57360ca41cca2533c3ca967e47 | import torch
import torch.nn as nn
from torch.nn.utils import weight_norm
class Model(nn.Module):
def __init__(self, input_units, output_units, filter_size,
padding_sizes, dropout=0.2):
super().__init__()
self.conv = weight_norm(nn.Conv1d(in_channels=input_units,
out_channels=... |
UnfoldTemporalWindows | # 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 UnfoldTemporalWindows(nn.Module):
def __init__(self, window_size, window_stride, window_dilation=1):
super().__init__()
self.window_size = window_size
self.window_stride = window_stride
self.window_dilation = window_dilation
self.pa... | 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... | Rgtemze/PersonalityRecognition | UnfoldTemporalWindows | false | 5,758 | [
"MIT"
] | 1 | 90ddd9c02e595d685b8c395ae94d50090288d1f0 | https://github.com/Rgtemze/PersonalityRecognition/tree/90ddd9c02e595d685b8c395ae94d50090288d1f0 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, window_size, window_stride, window_dilation=1):
super().__init__()
self.window_size = window_size
self.window_stride = window_stride
self.window_dilation = window_dilation
self.padding = (window_... |
DeepHeadModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from math import sqrt as sqrt
from itertools import product as product
import torchvision.transforms.functional as F
from torch.nn import functional ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | RedHenLab/RedHenAnonymizer | DeepHeadModule | false | 5,759 | [
"MIT"
] | 1 | 3560f1ac5cd5b9c6c7ed8bf322b807d57aedc06a | https://github.com/RedHenLab/RedHenAnonymizer/tree/3560f1ac5cd5b9c6c7ed8bf322b807d57aedc06a | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from math import sqrt as sqrt
from itertools import product as product
import torchvision.transforms.functional as F
from torch.nn import functional ... |
MaskedConv1d | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 MaskedConv1d(nn.Conv1d):
def __init__(self, in_channels, out_channels, kernel_size, dilation=1,
groups=1, bias=True, causal=True):
if causal:
padding = (kernel_size - 1) * dilation
else:
padding = (kernel_size - 1) * dilatio... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Raiselimit/TorchBlocks | MaskedConv1d | false | 5,760 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | import torch
import torch.nn as nn
class Model(nn.Conv1d):
def __init__(self, in_channels, out_channels, kernel_size, dilation=1,
groups=1, bias=True, causal=True):
if causal:
padding = (kernel_size - 1) * dilation
else:
padding = (kernel_size - 1) * dilation // 2
... |
KdCeLoss | # 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 KdCeLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, logits_S, logits_T, temperature=1):
"""
Calculate the cross entropy between logits_S and logits_T
:param logits_S: Tensor of... | 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
... | Raiselimit/TorchBlocks | KdCeLoss | false | 5,761 | [
"MIT"
] | 1 | a5baecb9a2470ff175087475630f2b7db3f7ef51 | https://github.com/Raiselimit/TorchBlocks/tree/a5baecb9a2470ff175087475630f2b7db3f7ef51 | 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, logits_S, logits_T, temperature=1):
"""
Calculate the cross entropy between logits_S and logits_T
:param logits_S: Tensor of sh... |
Loss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
class Loss(nn.Module):
def __init__(self):
super(Loss, self).__init__()
self.BCELoss = nn.BCELoss(reduce=True, size_average=True)
def forward(self, predict_y, input_y):
loss = self.BCELoss(predict_y, input_y)
return loss
def get_inputs():
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torc... | RandolphVI/HyperNet | Loss | false | 5,762 | [
"Apache-2.0"
] | 1 | e9f376f5eb087e57360ca41cca2533c3ca967e47 | https://github.com/RandolphVI/HyperNet/tree/e9f376f5eb087e57360ca41cca2533c3ca967e47 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.BCELoss = nn.BCELoss(reduce=True, size_average=True)
def forward(self, predict_y, input_y):
loss = self.BCELoss(predict_y, input_y)
return loss
def get_inputs():
retur... |
ContentLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class ContentLoss(nn.Module):
"""Module to compute the content loss. Allows arbitrary size style images
during initialization and updating the content target.
Usage: During loss network definition set compute_loss to False, to allow,
after initialization iterate throu... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empt... | RicCu/NeuralStyle | ContentLoss | false | 5,763 | [
"MIT"
] | 1 | 97dc6aec6b2072a9a187276e047aea885566e1be | https://github.com/RicCu/NeuralStyle/tree/97dc6aec6b2072a9a187276e047aea885566e1be | import torch
from torch import nn
class Model(nn.Module):
"""Module to compute the content loss. Allows arbitrary size style images
during initialization and updating the content target.
Usage: During loss network definition set compute_loss to False, to allow,
after initialization iterate through Con... |
LRN | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.utils.data
class LRN(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, ACROSS_CHANNELS=True
):
super(LRN, self).__init__()
self.ACROSS_CHANNELS = ACROSS_CHANNELS
if ACROSS_CHANNELS:
self.average = nn.AvgP... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dy... | Richard456/Dann | LRN | false | 5,764 | [
"MIT"
] | 1 | 1971cf1a7b9ecadc17932a8ecb3f0c34609751a3 | https://github.com/Richard456/Dann/tree/1971cf1a7b9ecadc17932a8ecb3f0c34609751a3 | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, ACROSS_CHANNELS=True
):
super().__init__()
self.ACROSS_CHANNELS = ACROSS_CHANNELS
if ACROSS_CHANNELS:
self.average = nn.AvgPool3d(k... |
Conv2dTime | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Conv2dTime(nn.Conv2d):
def __init__(self, in_channels, *args, **kwargs):
"""
Code adapted from https://github.com/EmilienDupont/augmented-neural-odes
Conv2d module where time gets concatenated as a feature map.
Makes ODE func aware of the ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | Ravimk07/neural-odes-segmentation | Conv2dTime | false | 5,765 | [
"MIT"
] | 1 | aebda2df029e447ed6a649778ea2f8ea5a169081 | https://github.com/Ravimk07/neural-odes-segmentation/tree/aebda2df029e447ed6a649778ea2f8ea5a169081 | import torch
import torch.nn as nn
class Model(nn.Conv2d):
def __init__(self, in_channels, *args, **kwargs):
"""
Code adapted from https://github.com/EmilienDupont/augmented-neural-odes
Conv2d module where time gets concatenated as a feature map.
Makes ODE func aware of the curre... |
ActivationQuantizer | # 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.autograd import Function
import torch
import torch.nn as nn
class Round(Function):
@staticmethod
def forward(self, input):
output = torch.round(input)
return output
@staticmethod
def backward(self, grad_output):
grad_input = grad_output.clone()
return grad_... | 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.autograd import F... | RiccardoRuggiero/micronet | ActivationQuantizer | false | 5,766 | [
"MIT"
] | 1 | bfdac2a50a5f0f8484a253b356c06a166bf7e6a0 | https://github.com/RiccardoRuggiero/micronet/tree/bfdac2a50a5f0f8484a253b356c06a166bf7e6a0 | from torch.autograd import Function
import torch
import torch.nn as nn
class Round(Function):
@staticmethod
def forward(self, input):
output = torch.round(input)
return output
@staticmethod
def backward(self, grad_output):
grad_input = grad_output.clone()
return grad_... |
ConvTran | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 ConvTran(nn.Module):
def __init__(self, in_channels, out_channels):
super(ConvTran, self).__init__()
self.conv_t = nn.ConvTranspose2d(in_channels, out_channels, 3, 2, 1, 1)
self.batch_norm = nn.InstanceNorm2d(out... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | RicCu/NeuralStyle | ConvTran | false | 5,767 | [
"MIT"
] | 1 | 97dc6aec6b2072a9a187276e047aea885566e1be | https://github.com/RicCu/NeuralStyle/tree/97dc6aec6b2072a9a187276e047aea885566e1be | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
def __init__(self, in_channels, out_channels):
super().__init__()
self.conv_t = nn.ConvTranspose2d(in_channels, out_channels, 3, 2, 1, 1)
self.batch_norm = nn.InstanceNorm2d(out_channels)
d... |
WeightQuantizer | # 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.autograd import Function
import torch
import torch.nn as nn
class Round(Function):
@staticmethod
def forward(self, input):
output = torch.round(input)
return output
@staticmethod
def backward(self, grad_output):
grad_input = grad_output.clone()
return grad_... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch.... | RiccardoRuggiero/micronet | WeightQuantizer | false | 5,768 | [
"MIT"
] | 1 | bfdac2a50a5f0f8484a253b356c06a166bf7e6a0 | https://github.com/RiccardoRuggiero/micronet/tree/bfdac2a50a5f0f8484a253b356c06a166bf7e6a0 | from torch.autograd import Function
import torch
import torch.nn as nn
class Round(Function):
@staticmethod
def forward(self, input):
output = torch.round(input)
return output
@staticmethod
def backward(self, grad_output):
grad_input = grad_output.clone()
return grad_... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class Attention(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
.. math::
\\begin{array}{ll}
x = context*output \\\\
attn = exp(x_i) / sum_j exp(x_j) \\\\
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Replie/replie-pythorch | Attention | false | 5,769 | [
"Apache-2.0"
] | 1 | b432f88fcd0b3275d18abee7e2909b997570a5dc | https://github.com/Replie/replie-pythorch/tree/b432f88fcd0b3275d18abee7e2909b997570a5dc | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Applies an attention mechanism on the output features from the decoder.
.. math::
\\begin{array}{ll}
x = context*output \\\\
attn = exp(x_i) / sum_j exp(x_j) \\\\
... |
Generator_mnist | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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.utils.data
from torch import nn
import torch.nn.parallel
from collections import OrderedDict
class Generator_mnist(nn.Module):
def __init__(self, opt):
super(Generator_mnist, self).__init__()
self.decoder = nn.Sequential(Orde... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | RicoFio/disentangle_mlp | Generator_mnist | false | 5,770 | [
"MIT"
] | 1 | 1fb3b6070b5846051b8b9e9333e8ee61418f4893 | https://github.com/RicoFio/disentangle_mlp/tree/1fb3b6070b5846051b8b9e9333e8ee61418f4893 | from _paritybench_helpers import _mock_config
import torch
import torch.utils.data
from torch import nn
import torch.nn.parallel
from collections import OrderedDict
class Model(nn.Module):
def __init__(self, opt):
super().__init__()
self.decoder = nn.Sequential(OrderedDict([('deconv1', nn.
... |
FocalLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
class FocalLoss(torch.nn.Module):
def __init__(self, gamma=2, alpha=0.5, size_average=True):
super(FocalLoss, self).__init__()
self.gamma = gamma
self.alpha = alpha
self.size_average = size_average
self.elipson = 1e-06
def forward(self, logits, labels):
... | 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... | RuiBai1999/HiMatch | FocalLoss | false | 5,771 | [
"MIT"
] | 1 | 199ebc6b06b3cce2b3f2298cb9e20f81c01dc7a6 | https://github.com/RuiBai1999/HiMatch/tree/199ebc6b06b3cce2b3f2298cb9e20f81c01dc7a6 | import torch
class Model(torch.nn.Module):
def __init__(self, gamma=2, alpha=0.5, size_average=True):
super().__init__()
self.gamma = gamma
self.alpha = alpha
self.size_average = size_average
self.elipson = 1e-06
def forward(self, logits, labels):
pt = torch.s... |
GCNdecoder | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, 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
import torch.nn as nn
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
from torch.nn import functional as F
class GCN(Module):
"""
Graph Convolutional Network
"""
def __init__(self, in_features, out_features, bias... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch.nn import Module
i... | Roxbili/topoGAN | GCNdecoder | false | 5,772 | [
"MIT"
] | 1 | 25cc397bf8925e485d3a39837b8bce552118f5dc | https://github.com/Roxbili/topoGAN/tree/25cc397bf8925e485d3a39837b8bce552118f5dc | from torch.nn import Module
import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
from torch.nn import functional as F
class GCN(Module):
"""
Graph Convolutional Network
"""
def __init__(self, in_features, out_features, bias... |
MultiHeadAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
from torch import nn
import torch.nn.functional as F
class MultiHeadAttention(nn.Module):
"""
input:
query --- [N, T_q, query_dim]
key --- [N, T_k, key_dim]
output:
out --- [N, T_q, num_units]
"""
def __init__(self, query_dim, key_dim, ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Regnac/Emotional_TTS | MultiHeadAttention | false | 5,773 | [
"BSD-3-Clause"
] | 1 | 38158f622d6a3e14e4b5539f2c2ee34e7cd88885 | https://github.com/Regnac/Emotional_TTS/tree/38158f622d6a3e14e4b5539f2c2ee34e7cd88885 | import torch
import torch.utils.data
from torch import nn
import torch.nn.functional as F
class Model(nn.Module):
"""
input:
query --- [N, T_q, query_dim]
key --- [N, T_k, key_dim]
output:
out --- [N, T_q, num_units]
"""
def __init__(self, query_dim, key_dim, num_units, nu... |
Residual | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Residual(nn.Module):
"""Unlinke other blocks, this module receives unpadded inputs."""
def __init__(self, channels, kernel_size=3):
super(Residual, self).__init__()
padding = int((kernel_size - 1) / 2)
self.p... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | RicCu/NeuralStyle | Residual | false | 5,774 | [
"MIT"
] | 1 | 97dc6aec6b2072a9a187276e047aea885566e1be | https://github.com/RicCu/NeuralStyle/tree/97dc6aec6b2072a9a187276e047aea885566e1be | import torch
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
"""Unlinke other blocks, this module receives unpadded inputs."""
def __init__(self, channels, kernel_size=3):
super().__init__()
padding = int((kernel_size - 1) / 2)
self.pad = nn.Reflectio... |
_BoundaryRefineModule | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
from torch.optim.lr_scheduler import *
class _BoundaryRefineModule(nn.Module):
def __init__(self, dim):
super(_BoundaryRefineModule, self).__init__()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, 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
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
from to... | Rocketbase-AI/rockets-mobilepose | _BoundaryRefineModule | false | 5,775 | [
"MIT"
] | 1 | be7273dff7fcf7d1023f431f4b63ac8d82978182 | https://github.com/Rocketbase-AI/rockets-mobilepose/tree/be7273dff7fcf7d1023f431f4b63ac8d82978182 | import torch
import torch.nn as nn
from torch.optim.lr_scheduler import *
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(dim, dim, kernel_size=3... |
Discriminator | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | from torch.nn import Module
import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
from torch.nn import functional as F
class GCN(Module):
"""
Graph Convolutional Network
"""
def __init__(self, in_features, out_features, bias... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | Roxbili/topoGAN | Discriminator | false | 5,776 | [
"MIT"
] | 1 | 25cc397bf8925e485d3a39837b8bce552118f5dc | https://github.com/Roxbili/topoGAN/tree/25cc397bf8925e485d3a39837b8bce552118f5dc | from torch.nn import Module
import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
from torch.nn import functional as F
class GCN(Module):
"""
Graph Convolutional Network
"""
def __init__(self, in_features, out_features, bias... |
_TextureConvGroup | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
def reflect_padding(x, f, s, half=False):
if half:
denom = 2
else:
denom = 1
_, _, h, w = x.shape
pad_w = w * (s / denom - 1) + f - s
pad_h = h * (s / denom - 1) + f - s
if pad_w % 2 == 1:
pad_l = in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
fr... | RicCu/NeuralStyle | _TextureConvGroup | false | 5,777 | [
"MIT"
] | 1 | 97dc6aec6b2072a9a187276e047aea885566e1be | https://github.com/RicCu/NeuralStyle/tree/97dc6aec6b2072a9a187276e047aea885566e1be | import torch
from torch import nn
from torch.nn import functional as F
def reflect_padding(x, f, s, half=False):
if half:
denom = 2
else:
denom = 1
_, _, h, w = x.shape
pad_w = w * (s / denom - 1) + f - s
pad_h = h * (s / denom - 1) + f - s
if pad_w % 2 == 1:
pad_l = in... |
MLP3_clamp_eval | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class MLP3_clamp_eval(nn.Module):
def __init__(self):
super(MLP3_clamp_eval, self).__init__()
self.fc1 = nn.Linear(32 * 32, 51... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | RuokaiYin/UnarySim | MLP3_clamp_eval | false | 5,778 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(32 * 32, 512)
self.fc2 = nn.Linear... |
HUBHardsigmoid | # 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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class HUBHardsigmoid(torch.nn.Module):
"""
This is a hub scaled addition (x+1)/2.
"""
def __init__(self, scale=3):
super(HUBHardsigmoid, self).__init__()
self.scale = s... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.da... | RuokaiYin/UnarySim | HUBHardsigmoid | false | 5,779 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(torch.nn.Module):
"""
This is a hub scaled addition (x+1)/2.
"""
def __init__(self, scale=3):
super().__init__()
self.scale = scale
def forward(self, x... |
MLP3 | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class MLP3(nn.Module):
def __init__(self, width=512, p=0.5):
super(MLP3, self).__init__()
self.fc1 = nn.Linear(32 * 32, width)... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | RuokaiYin/UnarySim | MLP3 | false | 5,780 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, width=512, p=0.5):
super().__init__()
self.fc1 = nn.Linear(32 * 32, width)
... |
MLP3_clamp_train | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class MLP3_clamp_train(nn.Module):
"""
For unary training, activation clamp is better to be after relu.
no difference for inference whe... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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.... | RuokaiYin/UnarySim | MLP3_clamp_train | false | 5,781 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
"""
For unary training, activation clamp is better to be after relu.
no difference for inference whether clamp ... |
FEM | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from math import sqrt as sqrt
from itertools import product as product
import torchvision.transforms.functional as F
from torch.nn import functional ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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 ... | RedHenLab/RedHenAnonymizer | FEM | false | 5,782 | [
"MIT"
] | 1 | 3560f1ac5cd5b9c6c7ed8bf322b807d57aedc06a | https://github.com/RedHenLab/RedHenAnonymizer/tree/3560f1ac5cd5b9c6c7ed8bf322b807d57aedc06a | import torch
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
from math import sqrt as sqrt
from itertools import product as product
import torchvision.transforms.functional as F
from torch.nn import functional ... |
TVLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import nn
class TVLoss(nn.Module):
"""Implements Anisotropic Total Variation regularization"""
def __init__(self):
super(TVLoss, self).__init__()
self.criterion = nn.L1Loss()
def forward(self, x):
X = x.detach()
XX = x
_b, _c, h, w = X.shap... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_... | RicCu/NeuralStyle | TVLoss | false | 5,783 | [
"MIT"
] | 1 | 97dc6aec6b2072a9a187276e047aea885566e1be | https://github.com/RicCu/NeuralStyle/tree/97dc6aec6b2072a9a187276e047aea885566e1be | import torch
from torch import nn
class Model(nn.Module):
"""Implements Anisotropic Total Variation regularization"""
def __init__(self):
super().__init__()
self.criterion = nn.L1Loss()
def forward(self, x):
X = x.detach()
XX = x
_b, _c, h, w = X.shape
y_t... |
MLP3_hardsig | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class MLP3_hardsig(nn.Module):
def __init__(self, width=512, p=0.5):
super(MLP3_hardsig, self).__init__()
self.fc1 = nn.Linear... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | RuokaiYin/UnarySim | MLP3_hardsig | false | 5,784 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, width=512, p=0.5):
super().__init__()
self.fc1 = nn.Linear(32 * 32, width)
... |
EntropyLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import numpy as np
from torch import nn
from torch.nn import functional as F
class EntropyLoss(nn.Module):
""" Module to compute entropy loss """
def __init__(self, normalize):
super(EntropyLoss, self).__init__()
self.normalize = normalize
def forward(self, x):
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 import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch ... | SAP-samples/emnlp2021-attention-contrastive-learning | EntropyLoss | false | 5,785 | [
"Apache-2.0"
] | 1 | dfad1c7c416d963b1b9b018d4182bebbb11ecf1c | https://github.com/SAP-samples/emnlp2021-attention-contrastive-learning/tree/dfad1c7c416d963b1b9b018d4182bebbb11ecf1c | import torch
import numpy as np
from torch import nn
from torch.nn import functional as F
class Model(nn.Module):
""" Module to compute entropy loss """
def __init__(self, normalize):
super().__init__()
self.normalize = normalize
def forward(self, x):
eps = 1e-05
b = F.so... |
PKT | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.optim
class PKT(nn.Module):
"""Probabilistic Knowledge Transfer for deep representation learning
Code from author: https://github.com/passalis/probabilistic_kt"""
def __init__(self):
super(PKT, self).__init__()
def forward(self, f_s, f_t):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
im... | RylanSchaeffer/RepDistiller | PKT | false | 5,786 | [
"BSD-2-Clause"
] | 1 | 3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | https://github.com/RylanSchaeffer/RepDistiller/tree/3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
"""Probabilistic Knowledge Transfer for deep representation learning
Code from author: https://github.com/passalis/probabilistic_kt"""
def __init__(self):
super().__init__()
def forward(self, f_s, f_t):
ret... |
HardMGUCell | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
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 Tensor
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
def truncated_normal(t, mean=0.0, std=0.01):
torch.nn.init.normal_(t, mean=mea... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from 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
import torch.nn a... | RuokaiYin/UnarySim | HardMGUCell | false | 5,787 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import math
import torch
from torch import Tensor
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
def truncated_normal(t, mean=0.0, std=0.01):
torch.nn.init.normal_(t, mean=mea... |
FactorTransfer | # 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
import torch.optim
class FactorTransfer(nn.Module):
"""Paraphrasing Complex Network: Network Compression via Factor Transfer, NeurIPS 2018"""
def __init__(self, p1=2, p2=1):
super(FactorTransfer, self).__init__()
self.p1 = p1
... | 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... | RylanSchaeffer/RepDistiller | FactorTransfer | false | 5,788 | [
"BSD-2-Clause"
] | 1 | 3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | https://github.com/RylanSchaeffer/RepDistiller/tree/3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
"""Paraphrasing Complex Network: Network Compression via Factor Transfer, NeurIPS 2018"""
def __init__(self, p1=2, p2=1):
super().__init__()
self.p1 = p1
self.p2 = p2
def... |
RKDLoss | # 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
import torch.optim
class RKDLoss(nn.Module):
"""Relational Knowledge Disitllation, CVPR2019"""
def __init__(self, w_d=25, w_a=50):
super(RKDLoss, self).__init__()
self.w_d = w_d
self.w_a = w_a
def forward(self, 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.... | RylanSchaeffer/RepDistiller | RKDLoss | false | 5,789 | [
"BSD-2-Clause"
] | 1 | 3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | https://github.com/RylanSchaeffer/RepDistiller/tree/3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim
class Model(nn.Module):
"""Relational Knowledge Disitllation, CVPR2019"""
def __init__(self, w_d=25, w_a=50):
super().__init__()
self.w_d = w_d
self.w_a = w_a
def forward(self, f_s, f_t):
... |
PA | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 PA(nn.Module):
def __init__(self, dim):
super().__init__()
self.pa_conv = nn.Conv3d(dim, dim, kernel_size=3, padding=1, groups=dim
)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
return x * self.sigmoid(self.pa_conv(x))... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_s... | SLKaMiHi/ResT-UNet-unsupervised-medical-image-registration-network-based-on-Transformer-and-CNN | PA | false | 5,790 | [
"MIT"
] | 1 | 728624f978f345a1e713046a7dde12d6f84fd3dd | https://github.com/SLKaMiHi/ResT-UNet-unsupervised-medical-image-registration-network-based-on-Transformer-and-CNN/tree/728624f978f345a1e713046a7dde12d6f84fd3dd | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, dim):
super().__init__()
self.pa_conv = nn.Conv3d(dim, dim, kernel_size=3, padding=1, groups=dim
)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
return x * self.sigmoid(self.pa_conv(... |
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.nn as nn
import torch.nn.functional as F
class MLP(nn.Module):
def __init__(self, input_size, output_size):
super(MLP, self).__init__()
self.fc1 = nn.Linear(input_size, 100)
self.policy = nn.Linear(100, output_size)
self.value = nn.Linear(100, 1)
def... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | SaneBow/AttentionAgentCarRacing | MLP | false | 5,791 | [
"Apache-2.0"
] | 1 | 944dc18b99b2c51a25c206f722a0bbc43cb7bbb0 | https://github.com/SaneBow/AttentionAgentCarRacing/tree/944dc18b99b2c51a25c206f722a0bbc43cb7bbb0 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, input_size, output_size):
super().__init__()
self.fc1 = nn.Linear(input_size, 100)
self.policy = nn.Linear(100, output_size)
self.value = nn.Linear(100, 1)
def forwar... |
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.nn as nn
import torch.nn.functional
import torch.nn.parallel
import torch.utils.data
import torch.optim
import torch.utils.data.distributed
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
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.triton_helpers import libdevice
import torch.nn as ... | SCIIX/CV-Backbones | Mlp | false | 5,792 | [
"Apache-2.0"
] | 1 | c76acf0742d8c0b7be9bd061ae2a7b247fa618ef | https://github.com/SCIIX/CV-Backbones/tree/c76acf0742d8c0b7be9bd061ae2a7b247fa618ef | import torch
import torch.nn as nn
import torch.nn.functional
import torch.nn.parallel
import torch.utils.data
import torch.optim
import torch.utils.data.distributed
class Model(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None,
act_layer=nn.GELU, drop=0.0):
supe... |
SPoC_pooling | # 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 SPoC_pooling(nn.Module):
def __init__(self):
super(SPoC_pooling, self).__init__()
def forward(self, x):
dim = x.size()
pool = nn.AvgPool2d(dim[-1])
x = pool(x)
return x.view(dim[0], dim[1])
def get_inputs():
return [torch... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | SIJIEJI/2020-ai-meets-beauty_ntubeauty | SPoC_pooling | false | 5,793 | [
"MIT"
] | 1 | fede564fb3e3029f3fadfe107484c5c7e39c29c5 | https://github.com/SIJIEJI/2020-ai-meets-beauty_ntubeauty/tree/fede564fb3e3029f3fadfe107484c5c7e39c29c5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
dim = x.size()
pool = nn.AvgPool2d(dim[-1])
x = pool(x)
return x.view(dim[0], dim[1])
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
de... |
ConcatAvgMaxPooling | # 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 ConcatAvgMaxPooling(nn.Module):
def __init__(self, kernel_size=12, stride=1):
super(ConcatAvgMaxPooling, self).__init__()
self.avgpool = nn.AvgPool2d(kernel_size, stride=1)
self.maxpool = nn.MaxPool2d(kernel_size, stride=1)
def forward(self, x... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | SamitHuang/CELNet | ConcatAvgMaxPooling | false | 5,794 | [
"MIT"
] | 1 | 51e067fdb16e723a45a0a60399d568b58cdc011d | https://github.com/SamitHuang/CELNet/tree/51e067fdb16e723a45a0a60399d568b58cdc011d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, kernel_size=12, stride=1):
super().__init__()
self.avgpool = nn.AvgPool2d(kernel_size, stride=1)
self.maxpool = nn.MaxPool2d(kernel_size, stride=1)
def forward(self, x):
x = torch.cat((self.avgpool(... |
SelfAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SelfAttention(nn.Module):
"""A simple self-attention solution."""
def __init__(self, data_dim, dim_q):
super(SelfAttention, self).__init__()
self._layers = []
self._fc_q = nn.Linear(data_dim, dim_q)
self._layers.append(self._fc_q)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import 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... | SaneBow/AttentionAgentCarRacing | SelfAttention | false | 5,795 | [
"Apache-2.0"
] | 1 | 944dc18b99b2c51a25c206f722a0bbc43cb7bbb0 | https://github.com/SaneBow/AttentionAgentCarRacing/tree/944dc18b99b2c51a25c206f722a0bbc43cb7bbb0 | import torch
import torch.nn as nn
class Model(nn.Module):
"""A simple self-attention solution."""
def __init__(self, data_dim, dim_q):
super().__init__()
self._layers = []
self._fc_q = nn.Linear(data_dim, dim_q)
self._layers.append(self._fc_q)
self._fc_k = nn.Linear(d... |
fullyCon | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 fullyCon(nn.Module):
def __init__(self):
super(fullyCon, self).__init__()
self.fc1 = nn.Linear(448 * 3 * 448, 500)
self.fc2 = nn.Linear(500, 100)
self.fc3 = nn.Linear(100, 5)
def forward(self, x):
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | Lightingooo/- | fullyCon | false | 5,796 | [
"MIT"
] | 1 | 7b48c2689b693617e46992ac081065cf08f14bf8 | https://github.com/Lightingooo/-/tree/7b48c2689b693617e46992ac081065cf08f14bf8 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(448 * 3 * 448, 500)
self.fc2 = nn.Linear(500, 100)
self.fc3 = nn.Linear(100, 5)
def forward(self, x):
x = x.view(-1, ... |
DQN | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
class DQN(nn.Module):
def __init__(self, inputs, outputs):
super(DQN, self).__init__()
val = int((inputs + outputs) / 2)
self.fc1 = nn.Linear(inputs, val)
self.fc2 = nn.Linear(val, val)
self.fc3 = nn.Linear... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Sai-56/Multi-Agent-DQN-Routing | DQN | false | 5,797 | [
"MIT"
] | 1 | c8e7038bd0dfb69b3bdbdeb60ff9b98bb081e95e | https://github.com/Sai-56/Multi-Agent-DQN-Routing/tree/c8e7038bd0dfb69b3bdbdeb60ff9b98bb081e95e | import torch
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self, inputs, outputs):
super().__init__()
val = int((inputs + outputs) / 2)
self.fc1 = nn.Linear(inputs, val)
self.fc2 = nn.Linear(val, val)
self.fc3 = nn.Linear(val, v... |
SpatialAttention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SpatialAttention(nn.Module):
def __init__(self, kernel_size=3, multi_branch=False):
super(SpatialAttention, self).__init__()
assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
self.conv1 = nn.Conv2d(2, 1, 3, padding=1, bias=False)
s... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | SamitHuang/CELNet | SpatialAttention | false | 5,798 | [
"MIT"
] | 1 | 51e067fdb16e723a45a0a60399d568b58cdc011d | https://github.com/SamitHuang/CELNet/tree/51e067fdb16e723a45a0a60399d568b58cdc011d | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, kernel_size=3, multi_branch=False):
super().__init__()
assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
self.conv1 = nn.Conv2d(2, 1, 3, padding=1, bias=False)
self.multi_branch = multi_branch
... |
RegWeightedL1Loss | # 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
def _gather_feat(feat, ind, mask=None):
dim = feat.size(2)
ind = ind.unsqueeze(2).expand(ind.size(0), ind.size(1), dim)
feat = feat.gather(1, ind)
if mask is not None:
mask = mask.unsqueeze(2).expand_as(feat)
feat = fea... | 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
... | SaqibMamoon/GSDT | RegWeightedL1Loss | false | 5,799 | [
"MIT"
] | 1 | e11c52a67291e973016ed34c3c95659e0af32d48 | https://github.com/SaqibMamoon/GSDT/tree/e11c52a67291e973016ed34c3c95659e0af32d48 | import torch
import torch.nn as nn
import torch.nn.functional as F
def _gather_feat(feat, ind, mask=None):
dim = feat.size(2)
ind = ind.unsqueeze(2).expand(ind.size(0), ind.size(1), dim)
feat = feat.gather(1, ind)
if mask is not None:
mask = mask.unsqueeze(2).expand_as(feat)
feat = fea... |
RawScale | # 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.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class RawScale(torch.nn.Module):
"""
Scale raw data to [-1, 1] in a symmetric manner, which meets bipolar/unipolar bitstream requirements.
The remaining data count for 'quantile' quantile o... | 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... | RuokaiYin/UnarySim | RawScale | false | 5,800 | [
"MIT"
] | 1 | 343ff9abf356a63d526b1df8eb946ad528690a27 | https://github.com/RuokaiYin/UnarySim/tree/343ff9abf356a63d526b1df8eb946ad528690a27 | import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
class Model(torch.nn.Module):
"""
Scale raw data to [-1, 1] in a symmetric manner, which meets bipolar/unipolar bitstream requirements.
The remaining data count for 'quantile' quantile of t... |
Base | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Base(nn.Module):
"""docstring for Base"""
def __init__(self, view_space, feature_space, num_actions, hidden_size):
super(Base, self).__init__()
self.view_space = view_space
self.feature_space =... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import numpy as np
import tor... | SJTUwbl/mfrl_pytorch | Base | false | 5,801 | [
"MIT"
] | 1 | 2b385121cc9a8aa16ed6d554d1dc10f02f2fc5d9 | https://github.com/SJTUwbl/mfrl_pytorch/tree/2b385121cc9a8aa16ed6d554d1dc10f02f2fc5d9 | import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""docstring for Base"""
def __init__(self, view_space, feature_space, num_actions, hidden_size):
super().__init__()
self.view_space = view_space
self.feature_space = feature_... |
CrossLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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.optim
class CrossLayer(nn.Module):
def __init__(self, d, dropout):
super().__init__()
self.linear = nn.Linear(d, d)
self.dropout = nn.Dropout(dropout)
def forward(self, x0, x):
return self.dropout(x0 * self.linear(x)) + x
def ... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._dynamo.g... | SauravMaheshkar/rtdl | CrossLayer | false | 5,802 | [
"Apache-2.0"
] | 1 | c3f8051210d1cd7fdffc5a63221e3c4e84415ed8 | https://github.com/SauravMaheshkar/rtdl/tree/c3f8051210d1cd7fdffc5a63221e3c4e84415ed8 | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
def __init__(self, d, dropout):
super().__init__()
self.linear = nn.Linear(d, d)
self.dropout = nn.Dropout(dropout)
def forward(self, x0, x):
return self.dropout(x0 * self.linear(x)) + x
def get_i... |
RegLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
def _reg_loss(regr, gt_regr, mask):
""" L1 regression loss
Arguments:
regr (batch x max_objects x dim)
gt_regr (batch x max_objects x dim)
mask (batch x max_objects)
"""
num = mask.float().sum()
mask = mask.unsqueeze(2).expand_as(gt_regr).float()
... | 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
... | SaqibMamoon/GSDT | RegLoss | false | 5,803 | [
"MIT"
] | 1 | e11c52a67291e973016ed34c3c95659e0af32d48 | https://github.com/SaqibMamoon/GSDT/tree/e11c52a67291e973016ed34c3c95659e0af32d48 | import torch
import torch.nn as nn
def _reg_loss(regr, gt_regr, mask):
""" L1 regression loss
Arguments:
regr (batch x max_objects x dim)
gt_regr (batch x max_objects x dim)
mask (batch x max_objects)
"""
num = mask.float().sum()
mask = mask.unsqueeze(2).expand_as(gt_regr).float()
... |
SpRes | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SpRes(nn.Module):
def __init__(self, in_channels=31):
super(SpRes, self).__init__()
self.conv1 = nn.Conv2d(in_channels=31, out_channels=3, bias=False,
kernel_size=1, stride=1)
def forward(self, x):
x = self.conv1(x)
x = nn.... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import libdevice
import torch.nn as ... | SeVEnMY/hyper-reconstruction | SpRes | false | 5,804 | [
"MIT"
] | 1 | 018c34aaf6884650c36a73bd7f4635f927a79da3 | https://github.com/SeVEnMY/hyper-reconstruction/tree/018c34aaf6884650c36a73bd7f4635f927a79da3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channels=31):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=31, out_channels=3, bias=False,
kernel_size=1, stride=1)
def forward(self, x):
x = self.conv1(x)
x = nn.Tanh()(x)
... |
L2N | # 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 L2N(nn.Module):
def __init__(self, eps=1e-06):
super(L2N, self).__init__()
self.eps = eps
def forward(self, x):
return x / (torch.norm(x, p=2, dim=1, keepdim=True) + self.eps
).expand_as(x)
def __repr__(self):
return 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_... | SIJIEJI/2020-ai-meets-beauty_ntubeauty | L2N | false | 5,805 | [
"MIT"
] | 1 | fede564fb3e3029f3fadfe107484c5c7e39c29c5 | https://github.com/SIJIEJI/2020-ai-meets-beauty_ntubeauty/tree/fede564fb3e3029f3fadfe107484c5c7e39c29c5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, eps=1e-06):
super().__init__()
self.eps = eps
def forward(self, x):
return x / (torch.norm(x, p=2, dim=1, keepdim=True) + self.eps
).expand_as(x)
def __repr__(self):
return self.__c... |
Correlation | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
import torch.nn as nn
import torch.optim
class Correlation(nn.Module):
"""Correlation Congruence for Knowledge Distillation, ICCV 2019.
The authors nicely shared the code with me. I restructured their code to be
compatible with my running framework. Credits go to the original author"""
... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime.triton_helpers import math as tl_math
import torch.nn as nn
import torch.optim
assert_size_stride = torch._C._d... | RylanSchaeffer/RepDistiller | Correlation | false | 5,806 | [
"BSD-2-Clause"
] | 1 | 3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | https://github.com/RylanSchaeffer/RepDistiller/tree/3612d9d8f6f913527c7aaec7e5ea557e72ed7c5e | import torch
import torch.nn as nn
import torch.optim
class Model(nn.Module):
"""Correlation Congruence for Knowledge Distillation, ICCV 2019.
The authors nicely shared the code with me. I restructured their code to be
compatible with my running framework. Credits go to the original author"""
def __... |
SobelConv | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 SobelConv(nn.Module):
def __init__(self, in_channel=31, batch_num=16):
super(SobelConv, self).__init__()
self.bz = batch_num
self.in_channel = in_channel
self.convx = nn.Conv2d(in_channels=31, out_channels=31, kernel_size
=3, st... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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.... | SeVEnMY/hyper-reconstruction | SobelConv | false | 5,807 | [
"MIT"
] | 1 | 018c34aaf6884650c36a73bd7f4635f927a79da3 | https://github.com/SeVEnMY/hyper-reconstruction/tree/018c34aaf6884650c36a73bd7f4635f927a79da3 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, in_channel=31, batch_num=16):
super().__init__()
self.bz = batch_num
self.in_channel = in_channel
self.convx = nn.Conv2d(in_channels=31, out_channels=31, kernel_size
=3, stride=1, bias=False,... |
CustomizedLayer | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 CustomizedLayer(nn.Module):
def __init__(self, in_dim):
super().__init__()
self.in_dim = in_dim
self.scale = nn.Parameter(torch.Tensor(self.in_dim))
self.bias = nn.Parameter(torch.Tensor(self.in_dim))
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.triton_helpers import libdevice
import torch.nn as nn
import torch.utils.data
assert_size_stride = torch._C._dy... | Serjio42/Torch-Pruning | CustomizedLayer | false | 5,808 | [
"MIT"
] | 1 | 8a096df38ddd95a2db39eca5f87b8a26c8d134ef | https://github.com/Serjio42/Torch-Pruning/tree/8a096df38ddd95a2db39eca5f87b8a26c8d134ef | import torch
import torch.nn as nn
import torch.utils.data
class Model(nn.Module):
def __init__(self, in_dim):
super().__init__()
self.in_dim = in_dim
self.scale = nn.Parameter(torch.Tensor(self.in_dim))
self.bias = nn.Parameter(torch.Tensor(self.in_dim))
def forward(self, x)... |
FastStyle | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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
def reflect_padding(x, f, s, half=False):
if half:
denom = 2
else:
denom = 1
_, _, h, w = x.shape
pad_w = w * (s / denom - 1) + f - s
pad_h = h * (s / denom - 1) + f - s
if pad_w % 2 == 1:
pad_l = in... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | RicCu/NeuralStyle | FastStyle | false | 5,809 | [
"MIT"
] | 1 | 97dc6aec6b2072a9a187276e047aea885566e1be | https://github.com/RicCu/NeuralStyle/tree/97dc6aec6b2072a9a187276e047aea885566e1be | import torch
from torch import nn
from torch.nn import functional as F
def reflect_padding(x, f, s, half=False):
if half:
denom = 2
else:
denom = 1
_, _, h, w = x.shape
pad_w = w * (s / denom - 1) + f - s
pad_h = h * (s / denom - 1) + f - s
if pad_w % 2 == 1:
pad_l = in... |
ConvNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
class ConvNet(nn.Module):
def __init__(self):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=
5, padding=2)
self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size
=3... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_... | SGeetansh/dffml | ConvNet | false | 5,810 | [
"MIT"
] | 1 | 04647bdcadef2f7e7b59cdd8ac1e89f17ef1095b | https://github.com/SGeetansh/dffml/tree/04647bdcadef2f7e7b59cdd8ac1e89f17ef1095b | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=
5, padding=2)
self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size
=3, padding=1)
... |
SoftCrossEntropyLoss | # AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _al... | import torch
from torch import Tensor
from typing import List
import torch.nn as nn
import torch.nn.functional as F
class SoftCrossEntropyLoss(nn.Module):
"""
Calculate the CrossEntropyLoss with soft targets
:param weight: Weight to assign to each of the classes. Default: None
:type weight: list of f... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import math as tl_math
from typing import Lis... | SenWu/fonduer | SoftCrossEntropyLoss | false | 5,811 | [
"MIT"
] | 1 | c4f8d95cec97552b34412c6787eb7370ae17424f | https://github.com/SenWu/fonduer/tree/c4f8d95cec97552b34412c6787eb7370ae17424f | import torch
from torch import Tensor
from typing import List
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""
Calculate the CrossEntropyLoss with soft targets
:param weight: Weight to assign to each of the classes. Default: None
:type weight: list of float
:param... |
LocalizationNet | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.utils.data
import torch.nn as nn
class LocalizationNet(nn.Module):
def __init__(self, inplanes, inputsize, nheads=1, use_bn=False):
super(LocalizationNet, self).__init__()
inputH, inputW = inputsize
self.use_bn = use_bn
if self.use_bn:
None
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.utils.data
impor... | Sanny26/indic-htr | LocalizationNet | false | 5,812 | [
"MIT"
] | 1 | c473573b05c251f6e266cbd69acaa7ab18837f37 | https://github.com/Sanny26/indic-htr/tree/c473573b05c251f6e266cbd69acaa7ab18837f37 | import torch
import torch.utils.data
import torch.nn as nn
class Model(nn.Module):
def __init__(self, inplanes, inputsize, nheads=1, use_bn=False):
super().__init__()
inputH, inputW = inputsize
self.use_bn = use_bn
if self.use_bn:
None
self.pool = nn.MaxPool2d(... |
Mac_Pooling | # 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 Mac_Pooling(nn.Module):
def __init__(self):
super(Mac_Pooling, self).__init__()
def forward(self, x):
dim = x.size()
pool = nn.MaxPool2d(dim[-1])
x = pool(x)
return x.view(dim[0], dim[1])
def get_inputs():
return [torch.r... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
emp... | SIJIEJI/2020-ai-meets-beauty_ntubeauty | Mac_Pooling | false | 5,813 | [
"MIT"
] | 1 | fede564fb3e3029f3fadfe107484c5c7e39c29c5 | https://github.com/SIJIEJI/2020-ai-meets-beauty_ntubeauty/tree/fede564fb3e3029f3fadfe107484c5c7e39c29c5 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
dim = x.size()
pool = nn.MaxPool2d(dim[-1])
x = pool(x)
return x.view(dim[0], dim[1])
def get_inputs():
return [torch.rand([4, 4, 4, 4])]
de... |
TARNetPhi | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class TARNetPhi(nn.Module):
def __init__(self, input_nodes, shared_nodes=200):
super(TARNetPhi, self).__init__()
self.shared1 = nn.Linear(in_features=input_nodes, out_features=
shared_nodes)
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language 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 ... | Shantanu48114860/PSSAM-GAN | TARNetPhi | false | 5,814 | [
"MIT"
] | 1 | c883431c1d0ebbb42691483f8ac8efaab65410b6 | https://github.com/Shantanu48114860/PSSAM-GAN/tree/c883431c1d0ebbb42691483f8ac8efaab65410b6 | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data
class Model(nn.Module):
def __init__(self, input_nodes, shared_nodes=200):
super().__init__()
self.shared1 = nn.Linear(in_features=input_nodes, out_features=
shared_nodes)
self.shared2 =... |
Mix | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from 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 Mix(nn.Module):
def __init__(self, m=-0.8):
super(Mix, self).__init__()
w = torch.nn.Parameter(torch.FloatTensor([m]), requires_grad=True)
w = torch.nn.Parameter(w, requires_grad=True)
self.w = w
self.mix_block = nn.Sigmoid()
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
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | ShenZheng2000/Syn2Real-Pytorch | Mix | false | 5,815 | [
"MIT"
] | 1 | 214c800914e2bcd57d4ca74a4c8476a11e1b5905 | https://github.com/ShenZheng2000/Syn2Real-Pytorch/tree/214c800914e2bcd57d4ca74a4c8476a11e1b5905 | import torch
import torch.nn as nn
class Model(nn.Module):
def __init__(self, m=-0.8):
super().__init__()
w = torch.nn.Parameter(torch.FloatTensor([m]), requires_grad=True)
w = torch.nn.Parameter(w, requires_grad=True)
self.w = w
self.mix_block = nn.Sigmoid()
def forw... |
Attention | # AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _alig... | import torch
import torch.nn.functional as F
import torch.nn as nn
class Attention(nn.Module):
"""
Computing the attention over the words
"""
def __init__(self, input_dim, proj_dim):
super(Attention, self).__init__()
self.input_dim = input_dim
self.proj_dim = proj_dim
... | import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.... | Sein-Jang/R2A | Attention | false | 5,816 | [
"MIT"
] | 1 | f70b69cedb4de3dd60a36963c4b6a881d9d090ee | https://github.com/Sein-Jang/R2A/tree/f70b69cedb4de3dd60a36963c4b6a881d9d090ee | import torch
import torch.nn.functional as F
import torch.nn as nn
class Model(nn.Module):
"""
Computing the attention over the words
"""
def __init__(self, input_dim, proj_dim):
super().__init__()
self.input_dim = input_dim
self.proj_dim = proj_dim
self.head = nn.Para... |
StochasticGate | # 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 torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class StochasticGate(nn.Module):
"""Stochastically merges features from two levels
with varying size of the receptive field
"""
def __init__(self):
super(StochasticGate, self).__i... | import torch
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_st... | SharhadBashar/1-stage-wseg | StochasticGate | false | 5,817 | [
"Apache-2.0"
] | 1 | 83bf13444f5039ffed2de1605f09b3f90b525586 | https://github.com/SharhadBashar/1-stage-wseg/tree/83bf13444f5039ffed2de1605f09b3f90b525586 | import torch
import torchvision.transforms.functional as F
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module):
"""Stochastically merges features from two levels
with varying size of the receptive field
"""
def __init__(self):
super().__init__()
self._mask_dr... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.