Kernel-Smith
Collection
A Unified Recipe for Evolutionary Kernel Optimization • 4 items • Updated
uuid int64 18.5k 561k | python_code stringlengths 189 56.8k | repo_id stringlengths 12 32 | repo_name stringlengths 2 100 | repo_star_count int64 0 148k | entry_point stringlengths 1 81 | level int64 1 3 |
|---|---|---|---|---|---|---|
18,605 | import torch
from torch import nn
class RMSNorm(nn.Module):
def __init__(self, in_channels: int, elementwise_affine: bool=False, eps: float=1e-06):
super().__init__()
self.eps = eps
self.learnable_scale = elementwise_affine
if self.learnable_scale:
self.weight = nn.Para... | R_kgDONmLyPg | stable_diffusion_3.5-pytorch-implementation | 2 | RMSNorm | 2 |
18,802 | import torch
import torch.nn as nn
class MockNetwork(nn.Module):
def __init__(self):
super(MockNetwork, self).__init__()
self.p = nn.Parameter(torch.zeros(1))
def forward(self, x):
x = self.p * x
return x
def get_inputs():
return [torch.rand([4, 3])]
def get_init_inputs(... | R_kgDONltf4A | pytorch-model-template | 0 | MockNetwork | 1 |
18,576 | import torch
from torch.nn import Module
class TensorPerAtomRMSE(Module):
"""Define RMSE Loss following the work:
Wilkins, David M., et al. "Accurate molecular polarizabilities with coupled cluster theory and machine learning."
Proceedings of the National Academy of Sciences 116.9 (2019): 3401-3406.
""... | R_kgDONkj93Q | ENINet | 2 | TensorPerAtomRMSE | 3 |
19,016 | import sys
import torch
class ZeroPadding2D(torch.nn.Module):
def __init__(self, padding, **kwargs):
super().__init__()
padding = (padding[1][0], padding[1][1], padding[0][0], padding[0][1])
self.task = None
self.pad = torch.nn.ZeroPad2d(padding=padding)
def forward(self, x):
... | R_kgDONkjAlw | Rex | 0 | ZeroPadding2D | 1 |
18,956 | import torch
esp = 1e-08
class Fidelity_Loss(torch.nn.Module):
def __init__(self):
super(Fidelity_Loss, self).__init__()
def forward(self, p, g):
g = g.view(-1, 1)
p = p.view(-1, 1)
loss = 1 - (torch.sqrt(p * g + esp) + torch.sqrt((1 - p) * (1 - g) + esp))
return torc... | R_kgDONlaCPA | AIGFD_EXIF | 3 | Fidelity_Loss | 3 |
18,893 | import torch
from torch import nn
class DivXActivation(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
try:
return 1 / x
except ZeroDivisionError:
return 0
def get_inputs():
return [torch.rand([4, 3, 4, 4])]
def get_init_inputs():... | R_kgDONlNDcw | learning-pytorch-from-daniel-bourke | 0 | DivXActivation | 1 |
19,131 | import torch
from torch import nn
class PACTReLU(nn.ReLU):
def __init__(self, alpha=1.0, inplace=False):
super().__init__(inplace)
self.alpha = torch.nn.Parameter(torch.tensor(alpha), requires_grad=True)
def forward(self, x):
return torch.clamp(x, torch.tensor(0).to(x.device), self.al... | R_kgDONlZvSg | compress | 0 | PACTReLU | 2 |
19,091 | import torch
import torch.nn as nn
import torch.nn.functional as F
class DisparitySmoothnessLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, disparites, images, separate=False):
image_gradient_x = self.gradient_x(images)
image_gradient_y = self.gradient_y(imag... | R_kgDONnWRwg | monodepth | 1 | DisparitySmoothnessLoss | 3 |
19,069 | import torch
from torch import nn
class ReadOut(nn.Module):
def __init__(self):
super().__init__()
self.sigm = nn.Sigmoid()
def forward(self, V):
out = torch.mean(V, 1)
return self.sigm(out)
def get_inputs():
return [torch.rand([4, 10, 8])]
def get_init_inputs():
ret... | R_kgDONlOr8A | graph-representation-learning | 0 | ReadOut | 1 |
18,577 | import torch
from torch import Tensor
class BesselRBF(torch.nn.Module):
"""
Sine for radial basis functions with coulomb decay (0th order bessel).
"""
def __init__(self, n_rbf: int, cutoff: float):
"""
Args:
cutoff: radial cutoff
n_rbf: number of basis functions... | R_kgDONkj93Q | ENINet | 2 | BesselRBF | 2 |
19,019 | import torch
class DepthwiseConv2D(torch.nn.Module):
def __init__(self, in_channels, kernel_size, strides=(1, 1), padding='same', use_bias=True, activation=None, dilation_rate=(1, 1), stride_offset=1, **kwargs):
super().__init__()
if padding == 'same' and strides in [2, (2, 2)]:
paddin... | R_kgDONkjAlw | Rex | 0 | DepthwiseConv2D | 1 |
18,925 | import torch
import torch.nn as nn
class CrossEntropyWrapper(nn.Module):
def __init__(self, weight, size_average):
super(CrossEntropyWrapper, self).__init__()
self.cross_entropy = nn.CrossEntropyLoss(weight=weight, size_average=size_average)
def forward(self, output, target):
x = outp... | R_kgDONm36GQ | PipeOptim | 0 | CrossEntropyWrapper | 2 |
18,611 | import torch
import math
import torch.nn as nn
class DWConvNormAct(nn.Module):
def __init__(self, d_model, k_size, dim):
super().__init__()
self.dim = dim
if dim == 2:
self.conv = nn.Conv2d(d_model, d_model, k_size, padding=k_size // 2, groups=d_model, bias=False)
elif ... | R_kgDONnXo3w | VLM-LwEIB | 10 | DWConvNormAct | 3 |
18,604 | import torch
from torch import nn
class SimplifiedLayerNorm(nn.Module):
def __init__(self, in_channels: int, eps=1e-06):
super().__init__()
self.weight = nn.Parameter(torch.ones(in_channels))
self.eps = eps
def forward(self, x: torch.Tensor) -> torch.Tensor:
var = x.pow(2).mea... | R_kgDONmLyPg | stable_diffusion_3.5-pytorch-implementation | 2 | SimplifiedLayerNorm | 2 |
18,899 | import torch
from torch import nn
class ModulusX(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.abs(x)
def get_inputs():
return [torch.rand([4, 3, 224, 224])]
def get_init_inputs():
return [[], {}] | R_kgDONlNDcw | learning-pytorch-from-daniel-bourke | 0 | ModulusX | 1 |
18,839 | import torch
import torch.nn as nn
import torch.nn.functional as F
class CLSTaskHead(nn.Module):
def __init__(self):
super().__init__()
self.fc = nn.Sequential(nn.Linear(50, 50), nn.ReLU(), nn.Linear(50, 10))
def forward(self, x):
assert (x != 0).sum() != 0
return F.log_softma... | R_kgDONm2Yew | EMTAL | 9 | CLSTaskHead | 2 |
18,871 | import torch
import torch.nn as nn
class BiLSTM(nn.Module):
def __init__(self, in_dim, out_dim):
super(BiLSTM, self).__init__()
self.layernorm = nn.LayerNorm(in_dim)
self.bilstm = nn.LSTM(in_dim, out_dim, batch_first=True, bidirectional=True, bias=False)
def forward(self, x):
... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | BiLSTM | 2 |
18,514 | import torch
from torch import Tensor, nn
class Downsample(nn.Module):
"""
下采样模块，用于在神经网络中降低特征图的空间分辨率。
该模块通过步幅为 2 的卷积层实现下采样，同时保持通道数不变。
参数:
in_channels (int): 输入特征的通道数。
"""
def __init__(self, in_channels: int):
super().__init__()
self.conv = nn.Conv2d(in_channels, in_ch... | R_kgDONnbfBg | FLUX-PyTorch | 3 | Downsample | 1 |
18,896 | import torch
from torch import nn
class BlobModel(nn.Module):
def __init__(self, input_size: int, output_size: int, hidden_layer_volume: int):
super().__init__()
self.input_size = input_size
self.output_size = output_size
self.hidden_layer_volume = hidden_layer_volume
self.... | R_kgDONlNDcw | learning-pytorch-from-daniel-bourke | 0 | BlobModel | 3 |
18,804 | import torch
import torch.nn as nn
class FNNGenerator(nn.Module):
"""
A customizable feedforward neural network generator.
"""
def __init__(self, input_size, output_size, hidden_layers, hidden_activations=None):
"""
Initializes the feedforward neural network.
Args:
... | R_kgDONlsjYA | PyTorch-wrapper | 0 | FNNGenerator | 1 |
18,597 | import torch
from torch import nn
from torch.nn import functional as F
class DenseGeluDense(nn.Module):
def __init__(self, in_channels: int, hidden_dim: int):
super().__init__()
self.wi_0 = nn.Linear(in_channels, hidden_dim, bias=False)
self.wi_1 = nn.Linear(in_channels, hidden_dim, bias=F... | R_kgDONmLyPg | stable_diffusion_3.5-pytorch-implementation | 2 | DenseGeluDense | 2 |
18,811 | import torch
from torch import nn
class TextTransformer(nn.Module):
def __init__(self, embed_dim, n_heads, n_layers, mlp_ratio, vocab_size, dropout, device):
super().__init__()
self.token_embedding = nn.Embedding(vocab_size, embed_dim)
self.positional_embedding = nn.Parameter(torch.zeros(1... | R_kgDONlQYzA | PyTorch-CLIP | 0 | TextTransformer | 3 |
18,719 | import torch
import torch.nn as nn
import torch.nn.init as init
class Maxout(nn.Module):
def __init__(self, in_features, out_features, num_pieces=5, bias=True):
super(Maxout, self).__init__()
assert in_features == out_features, 'For identity-like behavior, in_features must equal out_features.'
... | R_kgDONm_Q6Q | maxout_pytorch | 0 | Maxout | 3 |
18,816 | import torch
from types import SimpleNamespace
import torch.nn as nn
class MLP(nn.Module):
"""
多层感知机（MLP）模块，用于 Transformer 模型中的前馈神经网络部分。
MLP 模块由两个线性层和一个 GELU 激活函数组成，应用于 Transformer 块的残差连接之后。
"""
def __init__(self, config):
"""
初始化 MLP 模块。
参数:
config: 配置对象，包含以... | R_kgDONkz9jg | GPT-PyTorch | 1 | MLP | 2 |
18,897 | import torch
from torch import nn
class BaselineModel(nn.Module):
def __init__(self, input_size: int, output_size: int, hidden_units: int):
super().__init__()
self.prelu = nn.PReLU()
self.flatten = nn.Flatten()
self.layer_1 = nn.Linear(in_features=input_size, out_features=hidden_un... | R_kgDONlNDcw | learning-pytorch-from-daniel-bourke | 0 | BaselineModel | 2 |
18,558 | import torch
import torch.nn as nn
class MyNeuralNetwork(nn.Module):
def __init__(self):
super(MyNeuralNetwork, self).__init__()
self.fc1 = nn.Linear(6400, 6400)
self.fc2 = nn.Linear(6400, 100)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
r... | R_kgDONm4zTQ | dynamic_device_selector_pytorch | 2 | MyNeuralNetwork | 1 |
19,038 | import torch
import torch.nn as nn
class MLP(nn.Module):
"""
Following paper's detection head description:
Feed-forward network (FFN) for bounding box regression.
Note: Paper mentions using FFN for predictions but doesn't specify:
- Number of layers (we use 3 following DETR)
- Hidden dimen... | R_kgDONnIcsA | DECO | 3 | MLP | 1 |
18,869 | import torch
import torch.nn as nn
class CrossAttention(nn.Module):
def __init__(self, hidden_size, head_num=8):
super(CrossAttention, self).__init__()
self.head_num = head_num
self.s_d = hidden_size // self.head_num
self.all_head_size = self.head_num * self.s_d
self.Wq = n... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | CrossAttention | 3 |
18,598 | import torch
from torch import nn
from torch.nn import functional as F
# Dependent class from the same file
class SimplifiedLayerNorm(nn.Module):
def __init__(self, in_channels: int, eps=1e-06):
super().__init__()
self.weight = nn.Parameter(torch.ones(in_channels))
self.eps = eps
def ... | R_kgDONmLyPg | stable_diffusion_3.5-pytorch-implementation | 2 | FeedForward | 3 |
18,875 | import torch
import torch.nn as nn
class GGF(nn.Module):
def __init__(self, input_dim, intermediate_dim, output_dim):
super(GGF, self).__init__()
self.Wa = nn.Linear(input_dim, intermediate_dim)
self.Wv = nn.Linear(input_dim, intermediate_dim)
self.Wav = nn.Linear(input_dim, interm... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | GGF | 3 |
18,566 | import torch
import torch.nn as nn
class FeedForward(nn.Module):
def __init__(self, hidden_dim, ff_dim=None):
super().__init__()
if ff_dim is None:
ff_dim = hidden_dim * 4
self.linear1 = nn.Linear(hidden_dim, ff_dim)
self.linear2 = nn.Linear(ff_dim, hidden_dim)
... | R_kgDONlGiCw | pytorch-genie-world-model | 2 | FeedForward | 2 |
19,080 | import math
import torch
from torch.nn import Module, functional as F
from torch.nn.parameter import Parameter
class CosineLinear(Module):
def __init__(self, in_features: int, out_features: int, sigma: bool=True):
super(CosineLinear, self).__init__()
self.in_features = in_features
self.out... | R_kgDONlOr8A | graph-representation-learning | 0 | CosineLinear | 2 |
18,724 | import torch
import torch.nn as nn
class MyNN(nn.Module):
def __init__(self, in_size=256, layer_num=100):
super(MyNN, self).__init__()
self.in_size = in_size
self.FC = nn.Sequential(*[nn.Linear(in_size, in_size, bias=False) for _ in range(layer_num)])
self._initialize()
def fo... | R_kgDONnBN4g | pytorch_practice | 0 | MyNN | 1 |
19,081 | import math
import torch
from torch.nn import Module, functional as F
from torch.nn.parameter import Parameter
class GroupCosineLinear(Module):
def __init__(self, in_features: int, out_features: int, sigma: bool=True):
super(GroupCosineLinear, self).__init__()
self.in_features = in_features
... | R_kgDONlOr8A | graph-representation-learning | 0 | GroupCosineLinear | 3 |
19,060 | import torch
import numpy as np
from torch import nn
from torch.nn import functional as F
class RanPACLayer(nn.Module):
def __init__(self, input_dim, output_dim, lambda_value):
super(RanPACLayer, self).__init__()
self.projection = nn.Linear(input_dim, output_dim, bias=False)
for param in s... | R_kgDONlOr8A | graph-representation-learning | 0 | RanPACLayer | 2 |
19,006 | import torch
from torch import Tensor, nn
from torch.nn import functional as F
class Mlp(nn.Module):
def __init__(self, hidden_size: int, intermediate_size: int):
super().__init__()
self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
self.up_proj = nn.Linear(hidden_size,... | R_kgDONk9RsQ | minrl | 1 | Mlp | 2 |
18,959 | import torch
from torch import nn
class ValueHead(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.ModuleList()
self.layers.append(nn.Linear(512, 128))
self.layers.append(nn.BatchNorm1d(num_features=128))
self.layers.append(nn.Sigmoid())
self.laye... | R_kgDONmyrfw | ml-chess | 0 | ValueHead | 2 |
18,622 | import torch
from torch import nn
class Three_Layer_MLP(nn.Module):
def __init__(self) -> None:
super().__init__()
self.MLP1 = nn.Linear(784, 128)
self.MLP2 = nn.Linear(128, 64)
self.MLP3 = nn.Linear(64, 10)
self.ReLU = nn.ReLU()
self.softmax = nn.Softmax(dim=-1)
... | R_kgDONl-h3g | hand-written-digit-recognition | 3 | Three_Layer_MLP | 2 |
18,621 | import torch
from torch import nn
class One_Layer_MLP(nn.Module):
def __init__(self) -> None:
super().__init__()
self.MLP = nn.Linear(784, 10)
self.softmax = nn.Softmax(dim=-1)
self.loss = nn.CrossEntropyLoss()
def forward(self, images: torch.Tensor, label: torch.Tensor):
... | R_kgDONl-h3g | hand-written-digit-recognition | 3 | One_Layer_MLP | 2 |
18,782 | import torch
class SVMModel(torch.nn.Module):
def __init__(self):
super().__init__()
self.weights = torch.nn.Parameter(torch.randn(2))
self.bias = torch.nn.Parameter(torch.zeros(1))
def forward(self, X):
return X @ self.weights + self.bias
def get_inputs():
return [torch.... | R_kgDONlNiSQ | py-svm-pytorch | 0 | SVMModel | 1 |
18,829 | import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.distributions.normal import Normal
class ActorNet(nn.Module):
"""this is a NN that is going to be used to return the mean and standard deviations
of distribuitons of all the actions that are ... | R_kgDONlHOXA | Soft-Actor-Critic_pytorch | 0 | ActorNet | 2 |
18,923 | import torch
class Stage15(torch.nn.Module):
def __init__(self):
super(Stage15, self).__init__()
self.layer7 = torch.nn.Linear(in_features=4096, out_features=10, bias=True)
self._initialize_weights()
def forward(self, input0):
out0 = input0.clone()
out7 = self.layer7(o... | R_kgDONm36GQ | PipeOptim | 0 | Stage15 | 1 |
18,974 | import torch
import torch.nn as nn
class PaletteGenerator(nn.Module):
def __init__(self, noise_dim=100, output_dim=15):
super(PaletteGenerator, self).__init__()
self.model = nn.Sequential(nn.Linear(noise_dim, 128), nn.ReLU(), nn.Linear(128, 256), nn.ReLU(), nn.Linear(256, output_dim), nn.Sigmoid()... | R_kgDONmRkSw | palette_generator | 0 | PaletteGenerator | 2 |
18,652 | import torch
class FullyConnected(torch.nn.Module):
def __init__(self, input_size, output_size, activation_fn='linear'):
super(FullyConnected, self).__init__()
self.act_fn = activation_fn
self.relu = torch.nn.ReLU()
self.lrelu = torch.nn.LeakyReLU()
self.fc = torch.nn.Linea... | R_kgDONm8hnw | DL_Pytorch | 0 | FullyConnected | 1 |
18,525 | import torch
from torch import nn
class LinearLora(nn.Linear):
"""
LinearLora 类继承自 nn.Linear，添加了低秩自适应（LoRA）机制。
LoRA 通过在原始线性层的基础上添加低秩矩阵来实现高效微调，从而减少训练参数量并加速训练过程。
该类在前向传播过程中，将原始线性层的输出与 LoRA 矩阵的输出进行加和，实现低秩适应的效果。
参数:
in_features (int): 输入特征的维度。
out_features (int): 输出特征的维度。
bias... | R_kgDONnbfBg | FLUX-PyTorch | 3 | LinearLora | 2 |
18,554 | import torch
import torch.nn.functional as F
from torch import nn
class ConvChannelsMixer(nn.Module):
"""Linear activation block for PIPs's MLP Mixer."""
def __init__(self, in_channels):
super().__init__()
self.mlp2_up = nn.Linear(in_channels, in_channels * 4)
self.mlp2_down = nn.Linea... | R_kgDONmiq7A | TAPIR-pytorch | 2 | ConvChannelsMixer | 1 |
18,820 | import torch
from torch.nn import Linear
class HousingModel(torch.nn.Module):
def __init__(self, input_dim):
super(HousingModel, self).__init__()
self.linear = Linear(input_dim, 1)
def forward(self, x):
return self.linear(x)
def get_inputs():
return [torch.rand([4, 10])]
def get... | R_kgDONnu-Lg | linear-logistic-regressions | 0 | HousingModel | 1 |
18,929 | import torch
import torch.nn as nn
class Classifier(nn.Module):
"""
Fully-connected classifier
"""
def __init__(self, in_features, out_features, math='fp32'):
"""
Constructor for the Classifier.
:param in_features: number of input features
:param out_features: number o... | R_kgDONm36GQ | PipeOptim | 0 | Classifier | 1 |
18,827 | import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
class criticNetwork(nn.Module):
def __init__(self, in_dims, learning_rate, fc1_units=256, fc2_units=256, no_actions=2, name='critic', chk_file='tmp/sac'):
super(criticNetwork, self).__init__()
... | R_kgDONlHOXA | Soft-Actor-Critic_pytorch | 0 | criticNetwork | 2 |
18,781 | import torch
import torch.nn as nn
class SimpleNet(nn.Module):
"""Simple neural network for regression."""
def __init__(self):
super().__init__()
self.net = nn.Sequential(nn.Linear(10, 32), nn.ReLU(), nn.Linear(32, 16), nn.ReLU(), nn.Linear(16, 1))
def forward(self, x: torch.Tensor) -> to... | R_kgDONkd5zw | pytorch_basics_library | 1 | SimpleNet | 1 |
18,973 | import torch
import torch.nn as nn
class PaletteDiscriminator(nn.Module):
def __init__(self, input_dim=15):
super(PaletteDiscriminator, self).__init__()
self.model = nn.Sequential(nn.Linear(input_dim, 256), nn.LeakyReLU(0.2), nn.Linear(256, 128), nn.LeakyReLU(0.2), nn.Linear(128, 1), nn.Sigmoid())... | R_kgDONmRkSw | palette_generator | 0 | PaletteDiscriminator | 2 |
18,917 | import torch
class Stage1(torch.nn.Module):
def __init__(self):
super(Stage1, self).__init__()
self.layer1 = torch.nn.Linear(in_features=9216, out_features=4096, bias=True)
self.layer2 = torch.nn.ReLU(inplace=True)
self.layer3 = torch.nn.Dropout(p=0.5)
self.layer4 = torch.n... | R_kgDONm36GQ | PipeOptim | 0 | Stage1 | 2 |
18,873 | import torch
import torch.nn as nn
# Dependent class from the same file
class PositionWiseFeedForward(nn.Module):
"""
w2(relu(w1(layer_norm(x))+b1))+b2
"""
def __init__(self, TEXT_DIM, dropout=None):
super(PositionWiseFeedForward, self).__init__()
self.w_1 = nn.Linear(TEXT_DIM, 64)
... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | Conv1d4nonverbal | 2 |
18,898 | import torch
from torch import nn
# Dependent class from the same file
class SinusActivation(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.sin(x)
# Dependent class from the same file
class DivXActivation(nn.Module):
def __init__(self):
sup... | R_kgDONlNDcw | learning-pytorch-from-daniel-bourke | 0 | CircleModelV1 | 2 |
18,805 | import torch
from torch import nn
class ClassificationHead(nn.Module):
def __init__(self, embed_dim, n_classes):
super().__init__()
self.classifier = nn.Linear(embed_dim, n_classes)
def forward(self, x):
return self.classifier(x[:, 0])
def get_inputs():
return [torch.rand([4, 5, ... | R_kgDONlQYzA | PyTorch-CLIP | 0 | ClassificationHead | 2 |
18,784 | import torch
import torch.nn as nn
class DynamicAerodynamicDNN(nn.Module):
def __init__(self, input_dim, hidden_units_per_layer, output_units, activation):
super(DynamicAerodynamicDNN, self).__init__()
layers = []
layers.append(nn.Linear(input_dim, hidden_units_per_layer[0]))
layer... | R_kgDONmQT6g | airfoil-ml-pytorch | 0 | DynamicAerodynamicDNN | 1 |
19,018 | import torch
class Dense(torch.nn.Module):
def __init__(self, in_channels, units, activation=None, use_bias=True, **kwargs):
super().__init__()
self.linear = torch.nn.Linear(in_channels, units, bias=use_bias)
if activation == 'relu':
self.activation = torch.nn.ReLU()
el... | R_kgDONkjAlw | Rex | 0 | Dense | 1 |
18,924 | import torch
class Stage14(torch.nn.Module):
def __init__(self):
super(Stage14, self).__init__()
self.layer4 = torch.nn.Linear(in_features=4096, out_features=4096, bias=True)
self.layer5 = torch.nn.ReLU(inplace=True)
self.layer6 = torch.nn.Dropout(p=0.5)
self._initialize_we... | R_kgDONm36GQ | PipeOptim | 0 | Stage14 | 2 |
19,022 | import torch
import torch.nn as nn
class testModel(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 128, 2, padding='same')
self.conv2 = nn.Conv2d(128, 256, padding='same', kernel_size=2)
self.fco = nn.Linear(28 ** 2 * 256, 10)
def forward(self, x):... | R_kgDONmPdyg | torchTrainify | 0 | testModel | 2 |
18,628 | import torch
import torch.nn as nn
import typing
# Dependent class from the same file
class MLP(nn.Module):
def __init__(self, input_dim, hidden_sizes: typing.Iterable[int], out_dim, activation_function=nn.Sigmoid(), activation_out=None):
super(MLP, self).__init__()
i_h_sizes = [input_dim] + hidde... | R_kgDONnkKtA | pytorch_gnn | 0 | StateTransition | 3 |
18,721 | import torch
import torch.nn as nn
import torch.nn.functional as F
class PortraitNet(nn.Module):
def __init__(self, input_dim, hidden_dim):
super(PortraitNet, self).__init__()
self.lstm = nn.LSTM(input_size=input_dim, hidden_size=hidden_dim, batch_first=True)
self.layernorm = nn.LayerNorm(... | R_kgDONmb_lg | msdmt-pytorch | 0 | PortraitNet | 2 |
18,932 | import torch
class Stage2(torch.nn.Module):
def __init__(self):
super(Stage2, self).__init__()
self.layer1 = torch.nn.Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
self.layer2 = torch.nn.ReLU(inplace=True)
self.layer3 = torch.nn.Conv2d(384, 256, kernel_size=(3... | R_kgDONm36GQ | PipeOptim | 0 | Stage2 | 2 |
19,035 | import torch
import torch.nn as nn
class DECOEncoderLayer(nn.Module):
"""
A single 'ConvNeXt-like' block used in the DECO encoder:
- Depthwise 7x7 (or other kernel_size)
- LayerNorm
- 1x1 conv
- GELU
- 1x1 conv
- Skip connection
"""
def __init__(self, dim: int, kernel_size: int... | R_kgDONnIcsA | DECO | 3 | DECOEncoderLayer | 2 |
19,093 | import torch
import torch.nn as nn
import torch.nn.functional as F
class ReprojectionLoss(nn.Module):
def __init__(self):
super().__init__()
def forward(self, predicts, targets, separate=False):
loss = F.mse_loss(input=predicts, target=targets, reduction='none')
return torch.mean(loss... | R_kgDONnWRwg | monodepth | 1 | ReprojectionLoss | 2 |
18,655 | import torch
import torch.nn as nn
class ConvDown(nn.Module):
def __init__(self, c_in, c_out):
super(ConvDown, self).__init__()
self.conv1 = nn.Conv2d(c_in, c_out, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(c_out, c_out, kernel_size=3, padding=1)
self.bn1 = nn.BatchNorm2d(c_o... | R_kgDONm8hnw | DL_Pytorch | 0 | ConvDown | 2 |
18,623 | import torch
from torch import nn
class ResidualConnectionWithConv(nn.Module):
def __init__(self, in_dim: int, hidden_size: int):
super().__init__()
self.conv3x3_1 = nn.Conv2d(in_channels=in_dim, out_channels=hidden_size, kernel_size=3, padding=1)
self.batchnorm_1 = nn.BatchNorm2d(num_feat... | R_kgDONl-h3g | hand-written-digit-recognition | 3 | ResidualConnectionWithConv | 2 |
18,531 | import torch
from torch import nn
class MEBasic(nn.Module):
def __init__(self):
super().__init__()
self.relu = nn.ReLU()
self.conv1 = nn.Conv2d(8, 32, 7, 1, padding=3)
self.conv2 = nn.Conv2d(32, 64, 7, 1, padding=3)
self.conv3 = nn.Conv2d(64, 32, 7, 1, padding=3)
se... | R_kgDONnVguA | DCVC-B | 20 | MEBasic | 1 |
18,870 | import torch
import torch.nn as nn
class GatedMultimodalLayerWithFFN(nn.Module):
def __init__(self, size_in1, size_in2, dropout, size_out=32):
super(GatedMultimodalLayerWithFFN, self).__init__()
self.hidden_sigmoid = nn.Linear(size_in1 * 2, 1)
self.tanh_f = nn.Tanh()
self.sigmoid_f... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | GatedMultimodalLayerWithFFN | 2 |
19,014 | import torch
class Conv2D(torch.nn.Module):
def __init__(self, in_channels, filters, kernel_size, strides=(1, 1), padding='same', use_bias=True, activation=None, dilation_rate=(1, 1), stride_offset=1, **kwargs):
super().__init__()
if padding == 'same' and strides in [2, (2, 2)]:
paddin... | R_kgDONkjAlw | Rex | 0 | Conv2D | 1 |
18,910 | import torch
class Stage5(torch.nn.Module):
def __init__(self):
super(Stage5, self).__init__()
self.layer14 = torch.nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
self.layer15 = torch.nn.ReLU(inplace=True)
self._initialize_weights()
def forward(self, in... | R_kgDONm36GQ | PipeOptim | 0 | Stage5 | 2 |
18,722 | import torch
import torch.nn as nn
import torch.nn.functional as F
behavior_dim = 32
behavior_num = 101
maxlen = 64
timestep = 10
class BehaviorNet(nn.Module):
def __init__(self, behavior_num, emb_dim, maxlen, timestep, behavior_dim):
super(BehaviorNet, self).__init__()
self.emb = nn.Embedding(nu... | R_kgDONmb_lg | msdmt-pytorch | 0 | BehaviorNet | 3 |
18,726 | import torch
import torch.nn as nn
import torch.nn.functional as nnf
class LeNetGray(nn.Module):
def __init__(self):
super(LeNetGray, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5... | R_kgDONnBN4g | pytorch_practice | 0 | LeNetGray | 3 |
18,866 | import torch
import torch.nn as nn
class SelfAttention(nn.Module):
def __init__(self, hidden_size, head_num=8):
super(SelfAttention, self).__init__()
self.head_num = head_num
self.s_d = hidden_size // self.head_num
self.all_head_size = self.head_num * self.s_d
self.Wq = nn.... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | SelfAttention | 3 |
18,796 | import torch
import torch.nn as nn
class EncoderBlock(nn.Module):
"""
编码器块（EncoderBlock）。
该模块实现了一个卷积编码器块，用于逐步下采样和提取图像特征。
"""
def __init__(self, base_channel):
"""
初始化编码器块。
参数:
base_channel (int): 基础通道数，用于定义每个卷积层的输出通道数。
"""
super().__init__()
... | R_kgDONmcLJw | VAE-PyTorch | 1 | EncoderBlock | 1 |
18,780 | import torch
import torch.nn as nn
class ConvNet(nn.Module):
"""Simple CNN architecture for demonstration."""
def __init__(self, in_channels: int=3):
super().__init__()
self.features = nn.Sequential(nn.Conv2d(in_channels, 32, kernel_size=3, padding=1), nn.BatchNorm2d(32), nn.ReLU(), nn.MaxPool... | R_kgDONkd5zw | pytorch_basics_library | 1 | ConvNet | 3 |
18,939 | import torch
from torch import Tensor, nn
def conv_block(in_channels: int, out_channels: int, pool: bool=False) -> nn.Module:
layers = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(inplace=True)]
if pool:
layers.append(nn.MaxPool2d(2))
return nn.Sequential(*layers)
class... | R_kgDONmqDLw | TrainNets | 0 | cnn_small | 3 |
18,851 | import torch
import torch.nn as nn
LOWER = 5e-06
class Toy(nn.Module):
def __init__(self, scale=0.5):
super(Toy, self).__init__()
self.centers = torch.Tensor([[-3.0, 0], [3.0, 0]])
self.scale = scale
def forward(self, x, compute_grad=False):
x1 = x[0]
x2 = x[1]
... | R_kgDONm2Yew | EMTAL | 9 | Toy | 3 |
18,624 | import torch
from torch import nn
# Dependent class from the same file
class ResidualConnection(nn.Module):
def __init__(self, in_dim: int, hidden_size: int):
super().__init__()
self.conv3x3_1 = nn.Conv2d(in_channels=in_dim, out_channels=hidden_size, kernel_size=3, padding=1)
self.batchnor... | R_kgDONl-h3g | hand-written-digit-recognition | 3 | ResNet18 | 3 |
18,767 | import torch
import torch.nn as nn
class LightNN(nn.Module):
"""Lightweight neural network implementation to be used as student."""
def __init__(self, num_classes: int=10) -> None:
"""Initialize the lightweight neural network.
Args:
num_classes: Number of output classes
... | R_kgDONm7u9w | pytorch_knowledge_distill | 0 | LightNN | 3 |
18,848 | import torch
import torch.nn as nn
class RegressionHead(nn.Module):
def __init__(self, n_outputs, n_inputs=2048):
super(RegressionHead, self).__init__()
self.fc = nn.Linear(n_inputs, n_outputs, bias=True)
nn.init.kaiming_normal_(self.fc.weight)
if self.fc.bias is not None:
... | R_kgDONm2Yew | EMTAL | 9 | RegressionHead | 1 |
18,765 | import torch
import torch.nn as nn
class CosineEmbeddingDeepNN(nn.Module):
"""Deep neural network implementation to be used as teacher."""
def __init__(self, num_classes: int=10) -> None:
"""Initialize the deep neural network.
Args:
num_classes: Number of output classes
... | R_kgDONm7u9w | pytorch_knowledge_distill | 0 | CosineEmbeddingDeepNN | 3 |
19,102 | import torch
import torch.nn as nn
class ProjectionLinearLayer(torch.nn.Module):
def __init__(self, dec_output_dim: int, vocab_size: int, dropout: float=0.1):
super(ProjectionLinearLayer, self).__init__()
self.proj = nn.Linear(dec_output_dim, vocab_size)
self.dropout = nn.Dropout(dropout)
... | R_kgDONmli4w | transformer_implemenatation | 0 | ProjectionLinearLayer | 1 |
18,659 | import torch
import torch.nn as nn
# Dependent class from the same file
class ConvDPUnit(nn.Module):
def __init__(self, in_channels, out_channels, withBNRelu=True):
super(ConvDPUnit, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.conv1 = nn.Co... | R_kgDONnqJcQ | yunet_pytorch | 0 | Conv_head | 2 |
19,078 | import torch
from torch import nn
class Discriminator(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.bilinear = nn.Bilinear(input_dim, input_dim, 1)
self.input_dim = input_dim
for m in self.modules():
self.weights_init(m)
def weights_init(self, ... | R_kgDONlOr8A | graph-representation-learning | 0 | Discriminator | 2 |
18,660 | import torch
import torch.nn as nn
# Dependent class from the same file
class ConvDPUnit(nn.Module):
def __init__(self, in_channels, out_channels, withBNRelu=True):
super(ConvDPUnit, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.conv1 = nn.Co... | R_kgDONnqJcQ | yunet_pytorch | 0 | Conv4layerBlock | 2 |
18,888 | import torch
import torch.nn as nn
# Simplified implementation of dependent class Swish
class Swish(nn.Module):
def __init__(self, *args, **kwargs):
super().__init__()
for key, value in kwargs.items():
setattr(self, key, value)
def forward(self, x):
return x
class FFN(nn.M... | R_kgDONmuGkg | best-rq | 0 | FFN | 2 |
18,794 | import torch
import torch.nn as nn
class UpsampleDecoder(nn.Module):
"""
上采样解码器（UpsampleDecoder）。
该模块实现了一个使用上采样和卷积层的解码器，用于将潜在空间表示逐步上采样并转换为原始图像。
"""
def __init__(self, latent_dim):
"""
初始化上采样解码器。
参数:
latent_dim (int): 潜在空间的维度。
"""
super().__init... | R_kgDONmcLJw | VAE-PyTorch | 1 | UpsampleDecoder | 3 |
18,941 | import torch
from torch import Tensor, nn
from typing import Callable, Optional
# Dependent class from the same file
class Sine(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x: Tensor) -> Tensor:
return torch.sin(x)
class MLP(nn.Module):
"""
Multi Layer P... | R_kgDONmqDLw | TrainNets | 0 | MLP | 2 |
18,863 | import torch
import torch.nn as nn
class MultiModalShiftGate(nn.Module):
def __init__(self, dim, mu=0.5, ep=1e-07):
super(MultiModalShiftGate, self).__init__()
self.proj = nn.Linear(2 * dim, dim)
self.mu = nn.Parameter(torch.tensor([mu]))
self.ep = ep
def forward(self, t, a, v... | R_kgDONkfJig | SomeModuleImplementedInPytorch | 1 | MultiModalShiftGate | 3 |
18,654 | import torch
import torch.nn as nn
class PSPModule(nn.Module):
def __init__(self, c_in):
super(PSPModule, self).__init__()
self.avgp1 = nn.AdaptiveAvgPool2d(output_size=(1, 1))
self.conv1 = nn.Conv2d(c_in, c_in // 4, kernel_size=1)
self.avgp2 = nn.AdaptiveAvgPool2d(output_size=(2, ... | R_kgDONm8hnw | DL_Pytorch | 0 | PSPModule | 3 |
18,922 | import torch
class Stage7(torch.nn.Module):
def __init__(self):
super(Stage7, self).__init__()
self.layer19 = torch.nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
self.layer20 = torch.nn.ReLU(inplace=True)
self._initialize_weights()
def forward(self, in... | R_kgDONm36GQ | PipeOptim | 0 | Stage7 | 2 |
18,763 | import torch
import torch.nn as nn
class DeepNN(nn.Module):
"""Deep neural network implementation to be used as teacher."""
def __init__(self, num_classes: int=10) -> None:
"""Initialize the deep neural network.
Args:
num_classes: Number of output classes
"""
... | R_kgDONm7u9w | pytorch_knowledge_distill | 0 | DeepNN | 3 |
19,162 | import torch
import torch.nn as nn
import torch.nn.functional as F
class Fer2013(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 64, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
self.pool1 = nn.MaxPool2d(2, stride=2... | R_kgDONlvAow | python-math | 1 | Fer2013 | 3 |
18,933 | import torch
class Stage10(torch.nn.Module):
def __init__(self):
super(Stage10, self).__init__()
self.layer26 = torch.nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
self.layer27 = torch.nn.ReLU(inplace=True)
self._initialize_weights()
def forward(self, ... | R_kgDONm36GQ | PipeOptim | 0 | Stage10 | 2 |
18,766 | import torch
import torch.nn as nn
class ModifiedDeepRegressorNN(nn.Module):
"""Deep neural network with regressor implementation to be used as teacher."""
def __init__(self, num_classes: int=10) -> None:
"""Initialize the deep neural network.
Args:
num_classes: Number of ... | R_kgDONm7u9w | pytorch_knowledge_distill | 0 | ModifiedDeepRegressorNN | 3 |
19,067 | import torch
from torch import nn
def make_linear_relu(input_dim, output_dim):
return nn.Sequential(nn.Linear(input_dim, output_dim), nn.ReLU())
class NodeSelfAtten(nn.Module):
def __init__(self, input_dim):
super(NodeSelfAtten, self).__init__()
self.F = input_dim
self.f = make_linear... | R_kgDONlOr8A | graph-representation-learning | 0 | NodeSelfAtten | 3 |
18,927 | import torch
class Stage11(torch.nn.Module):
def __init__(self):
super(Stage11, self).__init__()
self.layer28 = torch.nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
self.layer29 = torch.nn.ReLU(inplace=True)
self._initialize_weights()
def forward(self, ... | R_kgDONm36GQ | PipeOptim | 0 | Stage11 | 2 |
18,512 | import torch
from torch import nn
class Convnet(nn.Module):
"""Convnet for fashion articles classification"""
def __init__(self, conv2d_kernel_size=3):
super().__init__()
self.layer_stack = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=32, kernel_size=conv2d_kernel_size), nn.ReLU(), nn.M... | R_kgDONml3nA | pytorch-tutorial | 0 | Convnet | 2 |
18,785 | import torch
import torch.nn as nn
import torch.nn.functional as F
class VGGBlock(nn.Module):
"""Basic VGG block with optional batch normalization."""
def __init__(self, in_channels, out_channels, kernel_size, batch_normalization=True, kernel_reg=0.0, **kwargs):
"""Initialize the VGG block.
... | R_kgDONlQ1BA | Pytorch_SuperPoint | 0 | VGGBlock | 2 |
18,921 | import torch
class Stage9(torch.nn.Module):
def __init__(self):
super(Stage9, self).__init__()
self.layer23 = torch.nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
self.layer24 = torch.nn.ReLU(inplace=True)
self.layer25 = torch.nn.MaxPool2d(kernel_size=2, str... | R_kgDONm36GQ | PipeOptim | 0 | Stage9 | 2 |
End of preview. Expand in Data Studio
YAML Metadata Warning:empty or missing yaml metadata in repo card
Check out the documentation for more information.
If this work is useful to you, please cite:
@article{DBLP:journals/corr/abs-2603-28342,
author = {He Du and
Qiming Ge and
Jiakai Hu and
Aijun Yang and
Zheng Cai and
Zixian Huang and
Sheng Yuan and
Qinxiu Cheng and
Xinchen Xie and
Yicheng Chen and
Yining Li and
Jiaxing Xie and
Huanan Dong and
Yaguang Wu and
Xiangjun Huang and
Jian Yang and
Hui Wang and
Bowen Zhou and
Bowen Li and
Qipeng Guo and
Kai Chen},
title = {Kernel-Smith: {A} Unified Recipe for Evolutionary Kernel Optimization},
journal = {CoRR},
volume = {abs/2603.28342},
year = {2026},
url = {https://doi.org/10.48550/arXiv.2603.28342},
doi = {10.48550/ARXIV.2603.28342},
eprinttype = {arXiv},
eprint = {2603.28342},
timestamp = {Sun, 19 Apr 2026 07:44:57 +0200},
biburl = {https://dblp.org/rec/journals/corr/abs-2603-28342.bib},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
- Downloads last month
- 61