code: def build_constructor_arg_db():
      return {
          torch.nn.AdaptiveAvgPool1d: ((5,), {}),
          torch.nn.AdaptiveAvgPool2d: ((5,), {}),
          torch.nn.AdaptiveAvgPool3d: ((5,), {}),
          torch.nn.AdaptiveLogSoftmaxWithLoss: (
              (100, 20, [5, 10, 15]),
              {},
          ),
          torch.nn.AdaptiveMaxPool1d: ((5,), {}),
          torch.nn.AdaptiveMaxPool2d: ((5,), {}),
          torch.nn.AdaptiveMaxPool3d: ((5,), {}),
          torch.nn.AlphaDropout: ((), {}),
          torch.nn.AvgPool1d: ((3,), {}),
          torch.nn.AvgPool2d: ((3,), {}),
          torch.nn.AvgPool3d: ((3,), {}),
          torch.nn.BCELoss: ((), {}),
          torch.nn.BCEWithLogitsLoss: ((), {}),
          torch.nn.BatchNorm1d: ((5,), {}),
          torch.nn.BatchNorm2d: ((5,), {}),
          torch.nn.BatchNorm3d: ((5,), {}),
          torch.nn.Bilinear: ((2, 3, 4), {}),
          torch.nn.CELU: ((), {}),
          torch.nn.CTCLoss: ((), {}),
          torch.nn.ChannelShuffle: ((4,), {}),
          torch.nn.ConstantPad1d: ((2, 3.5), {}),
          torch.nn.ConstantPad2d: ((2, 3.5), {}),
          torch.nn.ConstantPad3d: ((2, 3.5), {}),
          torch.nn.CircularPad1d: ((2,), {}),
          torch.nn.CircularPad2d: ((2,), {}),
          torch.nn.CircularPad3d: ((2,), {}),
          torch.nn.Conv1d: ((3, 3, 3), {}),
          torch.nn.Conv2d: ((3, 3, 3), {}),
          torch.nn.Conv3d: ((3, 3, 3), {}),
          torch.nn.ConvTranspose1d: ((3, 3, 3), {}),
          torch.nn.ConvTranspose2d: ((3, 3, 3), {}),
          torch.nn.ConvTranspose3d: ((3, 3, 3), {}),
          torch.nn.CosineEmbeddingLoss: ((), {}),
          torch.nn.CosineSimilarity: ((), {}),
          torch.nn.CrossEntropyLoss: ((), {}),
          torch.nn.CrossMapLRN2d: ((5,), {}),
          torch.nn.Dropout1d: ((), {}),
          torch.nn.Dropout2d: ((), {}),
          torch.nn.Dropout3d: ((), {}),
          torch.nn.Dropout: ((), {}),
          torch.nn.ELU: ((), {}),
          torch.nn.Embedding: ((10, 5), {}),
          torch.nn.EmbeddingBag: ((10, 5), {}),
          torch.nn.FeatureAlphaDropout: ((), {}),
          torch.nn.Flatten: ((), {}),
          torch.nn.Fold: ((5, 2), {}),
          torch.nn.FractionalMaxPool2d: ((5, 2), {}),
          torch.nn.FractionalMaxPool3d: ((5, 2), {}),
          torch.nn.GELU: ((), {}),
          torch.nn.GLU: ((), {}),
          torch.nn.GRU: ((5, 10), {}),
          torch.nn.GRUCell: ((5, 10), {}),
          torch.nn.GaussianNLLLoss: ((), {}),
          torch.nn.GroupNorm: ((3, 6, 1e-5, True), {}),
          torch.nn.Hardshrink: ((), {}),
          torch.nn.Hardsigmoid: ((), {}),
          torch.nn.Hardswish: ((), {}),
          torch.nn.Hardtanh: ((), {}),
          torch.nn.HingeEmbeddingLoss: ((), {}),
          torch.nn.HuberLoss: ((), {}),
          torch.nn.Identity: ((), {}),
          torch.nn.InstanceNorm1d: ((5, 1e-5, 0.1, True), {}),
          torch.nn.InstanceNorm2d: ((5, 1e-5, 0.1, True), {}),
          torch.nn.InstanceNorm3d: ((5, 1e-5, 0.1, True), {}),
          torch.nn.KLDivLoss: ((), {}),
          torch.nn.L1Loss: ((), {}),
          torch.nn.LPPool1d: ((2, 3), {}),
          torch.nn.LPPool2d: ((2, 3), {}),
          torch.nn.LPPool3d: ((2, 3), {}),
          torch.nn.LSTM: ((5, 10), {}),
          torch.nn.LSTMCell: ((5, 10), {}),
          torch.nn.LayerNorm: ((2,), {}),
          torch.nn.LazyBatchNorm1d: ((), {}),
          torch.nn.LazyBatchNorm2d: ((), {}),
          torch.nn.LazyBatchNorm3d: ((), {}),
          torch.nn.LazyConv1d: ((5, 2), {}),
          torch.nn.LazyConv2d: ((5, 2), {}),
          torch.nn.LazyConv3d: ((5, 2), {}),
          torch.nn.LazyConvTranspose1d: ((5, 2), {}),
          torch.nn.LazyConvTranspose2d: ((5, 2), {}),
          torch.nn.LazyConvTranspose3d: ((5, 2), {}),
          torch.nn.LazyInstanceNorm1d: ((), {}),
          torch.nn.LazyInstanceNorm2d: ((), {}),
          torch.nn.LazyInstanceNorm3d: ((), {}),
          torch.nn.LazyLinear: ((5,), {}),
          torch.nn.LeakyReLU: ((), {}),
          torch.nn.Linear: ((10, 5), {}),
          torch.nn.LocalResponseNorm: ((2,), {}),
          torch.nn.LogSigmoid: ((), {}),
          torch.nn.LogSoftmax: ((), {}),
          torch.nn.MSELoss: ((), {}),
          torch.nn.MarginRankingLoss: ((), {}),
          torch.nn.MaxPool1d: ((3,), {}),
          torch.nn.MaxPool2d: ((3,), {}),
          torch.nn.MaxPool3d: ((3,), {}),
          torch.nn.MaxUnpool1d: ((5,), {}),
          torch.nn.MaxUnpool2d: ((5,), {}),
          torch.nn.MaxUnpool3d: ((5,), {}),
          torch.nn.Mish: ((), {}),
          torch.nn.ModuleDict: ((), {}),
          torch.nn.ModuleList: ((), {}),
          torch.nn.MultiLabelMarginLoss: ((), {}),
          torch.nn.MultiLabelSoftMarginLoss: ((), {}),
          torch.nn.MultiMarginLoss: ((), {}),
          torch.nn.MultiheadAttention: ((100, 2), {}),
          torch.nn.NLLLoss2d: ((), {}),
          torch.nn.NLLLoss: ((), {}),
          torch.nn.PReLU: ((), {}),
          torch.nn.PairwiseDistance: ((), {}),
          torch.nn.ParameterDict: ((), {}),
          torch.nn.ParameterList: ((), {}),
          torch.nn.PixelShuffle: ((2,), {}),
          torch.nn.PixelUnshuffle: ((2,), {}),
          torch.nn.PoissonNLLLoss: ((), {}),
          torch.nn.RNN: ((5, 10), {}),
          torch.nn.RNNBase: (("LSTM", 5, 10), {}),
          torch.nn.RNNCell: ((5, 10), {}),
          torch.nn.RNNCellBase: ((5, 10, True, 2), {}),
          torch.nn.RReLU: ((), {}),
          torch.nn.ReLU6: ((), {}),
          torch.nn.ReLU: ((), {}),
          torch.nn.ReflectionPad1d: ((2,), {}),
          torch.nn.ReflectionPad2d: ((2,), {}),
          torch.nn.ReflectionPad3d: ((2,), {}),
          torch.nn.ReplicationPad1d: ((2,), {}),
          torch.nn.ReplicationPad2d: ((2,), {}),
          torch.nn.ReplicationPad3d: ((2,), {}),
          torch.nn.SELU: ((), {}),
          torch.nn.Sequential: ((), {}),
          torch.nn.SiLU: ((), {}),
          torch.nn.Sigmoid: ((), {}),
          torch.nn.SmoothL1Loss: ((), {}),
          torch.nn.SoftMarginLoss: ((), {}),
          torch.nn.Softmax2d: ((), {}),
          torch.nn.Softmax: ((), {}),
          torch.nn.Softmin: ((), {}),
          torch.nn.Softplus: ((), {}),
          torch.nn.Softshrink: ((), {}),
          torch.nn.Softsign: ((), {}),
          torch.nn.SyncBatchNorm: ((5,), {}),
          torch.nn.Tanh: ((), {}),
          torch.nn.Tanhshrink: ((), {}),
          torch.nn.Threshold: ((0.1, 20), {}),
          torch.nn.Transformer: ((), {}),
          torch.nn.TransformerDecoder: (
              (torch.nn.TransformerDecoderLayer, 3),
              {},
          ),
          torch.nn.TransformerDecoderLayer: ((10, 2), {}),
          torch.nn.TransformerEncoder: (
              (torch.nn.TransformerEncoderLayer, 3),
              {},
          ),
          torch.nn.TransformerEncoderLayer: ((10, 2), {}),
          torch.nn.TripletMarginLoss: ((), {}),
          torch.nn.TripletMarginWithDistanceLoss: ((), {}),
          torch.nn.Unflatten: ((1, (2, 5, 5)), {}),
          torch.nn.Unfold: ((3,), {}),
          torch.nn.Upsample: ((), {}),
          torch.nn.UpsamplingBilinear2d: ((), {}),
          torch.nn.UpsamplingNearest2d: ((), {}),
          torch.nn.ZeroPad1d: ((0,), {}),
          torch.nn.ZeroPad2d: ((0,), {}),
          torch.nn.ZeroPad3d: ((0,), {}),
          torch.ao.nn.qat.Conv1d: (
              (3, 3, 3),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Conv2d: (
              (3, 3, 3),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Conv3d: (
              (3, 3, 3),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Linear: (
              (5, 2),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Embedding: (
              (10, 12),
              {
                  "qconfig": torch.ao.quantization.float_qparams_weight_only_qconfig,
              },
          ),
          torch.ao.nn.qat.EmbeddingBag: (
              (10, 12),
              {
                  "qconfig": torch.ao.quantization.float_qparams_weight_only_qconfig,
              },
          ),
          torch.ao.nn.quantizable.LSTM: ((5, 6), {}),
          torch.ao.nn.quantizable.LSTMCell: ((5, 6), {}),
          torch.ao.nn.quantizable.MultiheadAttention: ((10, 2), {}),
          torch.ao.nn.quantized.BatchNorm2d: ((2,), {}),
          torch.ao.nn.quantized.BatchNorm3d: ((2,), {}),
          torch.ao.nn.quantized.Dropout: ((), {}),
          torch.ao.nn.quantized.Conv1d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.Conv2d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.Conv3d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.ConvTranspose1d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.ConvTranspose2d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.ConvTranspose3d: (
              (16, 33, (3, 3, 5)),
              {
                  "stride": (2, 1, 1),
                  "padding": (4, 2, 2),
                  "output_padding": (2, 2, 2),
                  "dilation": (1, 1, 1),
              },
          ),
          torch.ao.nn.quantized.DeQuantize: ((), {}),
          torch.ao.nn.quantized.ELU: ((0.01, 0), {}),
          torch.ao.nn.quantized.Embedding: (
              (10, 3),
              {
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.EmbeddingBag: (
              (10, 3),
              {
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.GroupNorm: (
              (
                  2,
                  4,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.Hardswish: (
              (
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.InstanceNorm1d: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.InstanceNorm2d: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.InstanceNorm3d: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.LayerNorm: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.LeakyReLU: ((0.01, 0), {}),
          torch.ao.nn.quantized.Linear: (
              (5, 2),
              {
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.MaxPool2d: ((3,), {}),
          torch.ao.nn.quantized.Quantize: (
              (0.1, 0),
              {
                  "dtype": torch.int16,
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.ReLU6: ((), {}),
          torch.ao.nn.quantized.Sigmoid: ((0.1, 0), {}),
          torch.ao.nn.quantized.Softmax: ((), {}),
          torch.ao.nn.quantized.FloatFunctional: ((), {}),
          torch.ao.nn.quantized.FXFloatFunctional: ((), {}),
          torch.ao.nn.quantized.QFunctional: ((), {}),
          # Remove torch.ao.nn.quantized after the migration completes:
          torch.ao.nn.qat.Conv1d: (
              (3, 3, 3),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Conv2d: (
              (3, 3, 3),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Conv3d: (
              (3, 3, 3),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Linear: (
              (5, 2),
              {
                  "qconfig": torch.ao.quantization.default_qconfig,
              },
          ),
          torch.ao.nn.qat.Embedding: (
              (10, 12),
              {
                  "qconfig": torch.ao.quantization.float_qparams_weight_only_qconfig,
              },
          ),
          torch.ao.nn.qat.EmbeddingBag: (
              (10, 12),
              {
                  "qconfig": torch.ao.quantization.float_qparams_weight_only_qconfig,
              },
          ),
          torch.ao.nn.quantized.BatchNorm2d: ((2,), {}),
          torch.ao.nn.quantized.BatchNorm3d: ((2,), {}),
          torch.ao.nn.quantized.Dropout: ((), {}),
          torch.ao.nn.quantized.Conv1d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.Conv2d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.Conv3d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.ConvTranspose1d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.ConvTranspose2d: ((3, 3, 3), {}),
          torch.ao.nn.quantized.ConvTranspose3d: (
              (16, 33, (3, 3, 5)),
              {
                  "stride": (2, 1, 1),
                  "padding": (4, 2, 2),
                  "output_padding": (2, 2, 2),
                  "dilation": (1, 1, 1),
              },
          ),
          torch.ao.nn.quantized.DeQuantize: ((), {}),
          torch.ao.nn.quantized.ELU: ((0.01, 0), {}),
          torch.ao.nn.quantized.Embedding: (
              (10, 3),
              {
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.EmbeddingBag: (
              (10, 3),
              {
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.GroupNorm: (
              (
                  2,
                  4,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.Hardswish: (
              (
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.InstanceNorm1d: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.InstanceNorm2d: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.InstanceNorm3d: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.LayerNorm: (
              (
                  2,
                  torch.nn.Parameter(torch.tensor(2.0)),
                  torch.nn.Parameter(torch.tensor(2.0)),
                  0.1,
                  0,
              ),
              {},
          ),
          torch.ao.nn.quantized.LeakyReLU: ((0.01, 0), {}),
          torch.ao.nn.quantized.Linear: (
              (5, 2),
              {
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.MaxPool2d: ((3,), {}),
          torch.ao.nn.quantized.PReLU: ((0.01, 0), {}),
          torch.ao.nn.quantized.Quantize: (
              (0.1, 0),
              {
                  "dtype": torch.int16,
                  "factory_kwargs": {},
              },
          ),
          torch.ao.nn.quantized.ReLU6: ((), {}),
          torch.ao.nn.quantized.Sigmoid: ((0.1, 0), {}),
          torch.ao.nn.quantized.Softmax: ((), {}),
          torch.ao.nn.quantized.FloatFunctional: ((), {}),
          torch.ao.nn.quantized.FXFloatFunctional: ((), {}),
          torch.ao.nn.quantized.QFunctional: ((), {}),
      }
  
file_path: pytorch/test/test_module_init.py
imports: import inspect
  import torch
  from unittest import mock
  from unittest.mock import MagicMock, patch
  from torch.testing._internal.common_dtype import floating_types
  from torch.testing._internal.common_device_type import instantiate_device_type_tests, dtypes
  from torch.testing._internal.common_quantization import skipIfNoFBGEMM
  from torch.testing._internal.common_utils import TestCase, run_tests
label_desc: Use image node_id 1 for calling a global function with example usage: build_constructor_arg_db() and returns: dict