def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"GRU",
[
"input_size",
"hidden_size",
"num_layers",
"bias",
"batch_first",
"dropout",
"bidirectional",
],
)
self.params = self.template_fn(
input_size=IntParam(name="input_size", default=1),
hidden_size=Param(name="hidden_size", default=None),
num_layers=IntParam(name="num_layers", default=1),
bias=BinaryParam(name="bias", default=True, true_prob=0.5),
batch_first=BinaryParam(name="batch_first",
default=False,
true_prob=0.5),
dropout=IntParam(name="dropout", default=0.0),
bidirectional=BinaryParam(name="bidirectional",
default=False,
true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("AdaptiveAvgPool3d", ["output_size"])
self.params = self.template_fn(output_size=TupleParam(
name="output_size", size=3, default=(1, 1, 1)))
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("Softshrink", ["lambd"])
self.params = self.template_fn(
lambd=FloatParam(name="lambd", default=0.5))
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"SyncBatchNorm",
[
"num_features",
"eps",
"momentum",
"affine",
"track_running_stats",
"process_group",
],
)
self.params = self.template_fn(
num_features=Param(name="num_features", default=None),
eps=FloatParam(name="eps", default=1e-05),
momentum=FloatParam(name="momentum", default=0.1),
affine=BinaryParam(name="affine", default=False, true_prob=0.5),
track_running_stats=BinaryParam(name="track_running_stats",
default=False,
true_prob=0.5),
process_group=Param(name="process_group", default=None),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"AvgPool1d",
[
"kernel_size", "stride", "padding", "ceil_mode",
"count_include_pad"
],
)
self.params = self.template_fn(
kernel_size=TupleParam(name="kernel_size",
size=1,
limits=((1, ), (1, )),
default=(1, )),
stride=TupleParam(name="stride",
size=1,
limits=((1, ), (1, )),
default=(1, )),
padding=TupleParam(name="padding",
size=1,
limits=((0, ), (0, )),
default=(0, )),
ceil_mode=BinaryParam(name="ceil_mode",
default=False,
true_prob=0.5),
count_include_pad=BinaryParam(name="count_include_pad",
default=True,
true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"MultiheadAttention",
[
"embed_dim",
"num_heads",
"dropout",
"bias",
"add_bias_kv",
"add_zero_attn",
"kdim",
"vdim",
],
)
self.params = self.template_fn(
embed_dim=Param(name="embed_dim", default=None),
num_heads=Param(name="num_heads", default=None),
dropout=IntParam(name="dropout", default=0.0),
bias=BinaryParam(name="bias", default=True, true_prob=0.5),
add_bias_kv=BinaryParam(name="add_bias_kv",
default=False,
true_prob=0.5),
add_zero_attn=BinaryParam(name="add_zero_attn",
default=False,
true_prob=0.5),
kdim=Param(name="kdim", default=None),
vdim=Param(name="vdim", default=None),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"EmbeddingBag",
[
"num_embeddings",
"embedding_dim",
"max_norm",
"norm_type",
"scale_grad_by_freq",
"mode",
"sparse",
"_weight",
],
)
self.params = self.template_fn(
num_embeddings=IntParam(name="num_embeddings", default=1),
embedding_dim=IntParam(name="embedding_dim", default=1),
max_norm=Param(name="max_norm", default=None),
norm_type=IntParam(name="norm_type", default=2.0),
scale_grad_by_freq=BinaryParam(name="scale_grad_by_freq",
default=False,
true_prob=0.5),
mode=ChoiceParam(name="mode",
choices=("mean", ),
cprobs=(1, ),
default="mean"),
sparse=BinaryParam(name="sparse", default=False, true_prob=0.5),
_weight=Param(name="_weight", default=None),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("SELU", ["inplace"])
self.params = self.template_fn(
inplace=BinaryParam(name="inplace", default=False, true_prob=0.5))
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"FractionalMaxPool3d",
[
"kernel_size",
"output_size",
"output_ratio",
"return_indices",
"_random_samples",
],
)
self.params = self.template_fn(
kernel_size=TupleParam(
name="kernel_size",
size=3,
limits=((1, 1, 1), (1, 1, 1)),
default=(1, 1, 1),
),
output_size=TupleParam(name="output_size",
size=3,
default=(1, 1, 1)),
output_ratio=Param(name="output_ratio", default=None),
return_indices=BinaryParam(name="return_indices",
default=False,
true_prob=0.5),
_random_samples=Param(name="_random_samples", default=None),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("PixelShuffle", ["upscale_factor"])
self.params = self.template_fn(
upscale_factor=IntParam(name="upscale_factor", default=1)
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("Softplus", ["beta", "threshold"])
self.params = self.template_fn(
beta=FloatParam(name="beta", default=1),
threshold=IntParam(name="threshold", default=20),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("PReLU", ["num_parameters", "init"])
self.params = self.template_fn(
num_parameters=IntParam(name="num_parameters", default=1),
init=FloatParam(name="init", default=0.25),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("BasicBlock", ["inplanes", "planes"])
self.params = self.template_fn(
inplanes=IntParam(name="inplanes", default=1),
planes=IntParam(name="planes", default=1),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("CosineSimilarity", ["dim", "eps"])
self.params = self.template_fn(
dim=IntParam(name="dim", default=1),
eps=FloatParam(name="eps", default=1e-08),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("Flatten", ["start_dim", "end_dim"])
self.params = self.template_fn(
start_dim=IntParam(name="start_dim", default=1),
end_dim=IntParam(name="end_dim", default=-1),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("FeatureAlphaDropout", ["p", "inplace"])
self.params = self.template_fn(
p=FloatParam(name="p", default=0.5),
inplace=BinaryParam(name="inplace", default=False, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("ZeroPad2d", ["padding"])
self.params = self.template_fn(
padding=TupleParam(
name="padding", size=2, limits=((0, 0), (0, 0)), default=(0, 0)
)
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("UpsamplingBilinear2d",
["size", "scale_factor"])
self.params = self.template_fn(
size=Param(name="size", default=None),
scale_factor=IntParam(name="scale_factor", default=1),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("PairwiseDistance", ["p", "eps", "keepdim"])
self.params = self.template_fn(
p=IntParam(name="p", default=2.0),
eps=FloatParam(name="eps", default=1e-06),
keepdim=BinaryParam(name="keepdim", default=False, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("RReLU", ["lower", "upper", "inplace"])
self.params = self.template_fn(
lower=FloatParam(name="lower", default=0.125),
upper=FloatParam(name="upper", default=0.3333333333333333),
inplace=BinaryParam(name="inplace", default=False, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("LeakyReLU",
["negative_slope", "inplace"])
self.params = self.template_fn(
negative_slope=FloatParam(name="negative_slope", default=0.01),
inplace=BinaryParam(name="inplace", default=False, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("TransformerEncoder",
['encoder_layer', 'num_layers', 'norm'])
self.params = self.template_fn(
encoder_layer=Param(name="encoder_layer", default=None),
num_layers=Param(name="num_layers", default=None),
norm=Param(name="norm", default=None),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("Threshold",
["threshold", "value", "inplace"])
self.params = self.template_fn(
threshold=Param(name="threshold", default=None),
value=Param(name="value", default=None),
inplace=BinaryParam(name="inplace", default=False, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("ConstantPad1d", ["padding", "value"])
self.params = self.template_fn(
padding=TupleParam(
name="padding", size=1, limits=((0,), (0,)), default=(0,)
),
value=FloatParam(name="value", default=0.0),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("GRUCell",
["input_size", "hidden_size", "bias"])
self.params = self.template_fn(
input_size=IntParam(name="input_size", default=1),
hidden_size=Param(name="hidden_size", default=None),
bias=BinaryParam(name="bias", default=True, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("Linear",
["in_features", "out_features", "bias"])
self.params = self.template_fn(
in_features=IntParam(name="in_features", default=1),
out_features=IntParam(name="out_features", default=1),
bias=BinaryParam(name="bias", default=True, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("CrossMapLRN2d",
["size", "alpha", "beta", "k"])
self.params = self.template_fn(
size=Param(name="size", default=None),
alpha=FloatParam(name="alpha", default=0.0001),
beta=FloatParam(name="beta", default=0.75),
k=IntParam(name="k", default=1),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"GroupNorm", ["num_groups", "num_channels", "eps", "affine"])
self.params = self.template_fn(
num_groups=Param(name="num_groups", default=None),
num_channels=Param(name="num_channels", default=None),
eps=FloatParam(name="eps", default=1e-05),
affine=BinaryParam(name="affine", default=False, true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple(
"RNNCellBase", ["input_size", "hidden_size", "bias", "num_chunks"])
self.params = self.template_fn(
input_size=IntParam(name="input_size", default=1),
hidden_size=Param(name="hidden_size", default=None),
bias=Param(name="bias", default=None),
num_chunks=Param(name="num_chunks", default=None),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
def __init__(self, **kwargs):
_Factory.__init__(self)
self.template_fn = namedtuple("AdaptiveMaxPool2d",
["output_size", "return_indices"])
self.params = self.template_fn(
output_size=TupleParam(name="output_size", size=2, default=(1, 1)),
return_indices=BinaryParam(name="return_indices",
default=False,
true_prob=0.5),
)
for k, v in kwargs.items():
getattr(self.params, k).val = v
