docstr: Lazily initializes a linear model. This will be called for you in a
  train method.
  
  Args:
      in_features (int):
          The number of input features
      output_features (int):
          The number of output features.
      norm_type (str, optional):
          The type of normalization that can occur. Please assign this
          to one of `PyTorchLinearModel.SUPPORTED_NORMS`.
      affine_norm (bool):
          Whether or not to learn an affine transformation of the
          normalization parameters used.
      bias (bool):
          Whether to add a bias term. Not needed if normalized input.
      weight_values (Tensor, optional):
          The values to initialize the linear model with. This must be a
          1D or 2D tensor, and of the form `(num_outputs, num_features)` or
          `(num_features,)`. Additionally, if this is provided you need not
          to provide `in_features` or `out_features`.
      bias_value (Tensor, optional):
          The bias value to initialize the model with.
      classes (Tensor, optional):
          The list of prediction classes supported by the model in case it
          performs classificaton. In case of regression it is set to None.
          Default: None
code: def _construct_model_params(
      self,
      in_features: Optional[int] = None,
      out_features: Optional[int] = None,
      norm_type: Optional[str] = None,
      affine_norm: bool = False,
      bias: bool = True,
      weight_values: Optional[Tensor] = None,
      bias_value: Optional[Tensor] = None,
      classes: Optional[Tensor] = None,
  ):
      r"""
      Lazily initializes a linear model. This will be called for you in a
      train method.
  
      Args:
          in_features (int):
              The number of input features
          output_features (int):
              The number of output features.
          norm_type (str, optional):
              The type of normalization that can occur. Please assign this
              to one of `PyTorchLinearModel.SUPPORTED_NORMS`.
          affine_norm (bool):
              Whether or not to learn an affine transformation of the
              normalization parameters used.
          bias (bool):
              Whether to add a bias term. Not needed if normalized input.
          weight_values (Tensor, optional):
              The values to initialize the linear model with. This must be a
              1D or 2D tensor, and of the form `(num_outputs, num_features)` or
              `(num_features,)`. Additionally, if this is provided you need not
              to provide `in_features` or `out_features`.
          bias_value (Tensor, optional):
              The bias value to initialize the model with.
          classes (Tensor, optional):
              The list of prediction classes supported by the model in case it
              performs classificaton. In case of regression it is set to None.
              Default: None
      """
      if norm_type not in LinearModel.SUPPORTED_NORMS:
          raise ValueError(
              f"{norm_type} not supported. Please use {LinearModel.SUPPORTED_NORMS}"
          )
  
      if weight_values is not None:
          in_features = weight_values.shape[-1]
          out_features = (
              1
              if len(weight_values.shape) == 1
              else weight_values.shape[0]
          )
  
      if in_features is None or out_features is None:
          raise ValueError(
              "Please provide `in_features` and `out_features` or `weight_values`"
          )
  
      if norm_type == "batch_norm":
          self.norm = nn.BatchNorm1d(
              in_features, eps=1e-8, affine=affine_norm
          )
      elif norm_type == "layer_norm":
          self.norm = nn.LayerNorm(
              in_features, eps=1e-8, elementwise_affine=affine_norm
          )
      else:
          self.norm = None
  
      self.linear = nn.Linear(in_features, out_features, bias=bias)
  
      if weight_values is not None:
          self.linear.weight.data = weight_values
  
      if bias_value is not None:
          if not bias:
              raise ValueError(
                  "`bias_value` is not None and bias is False"
              )
  
          self.linear.bias.data = bias_value
  
      if classes is not None:
          self.linear.classes = classes
  
imports: from typing import Callable, cast, List, Optional
  import torch.nn
  from captum._utils.models.model import Model
  from torch import Tensor
  from torch.utils.data import DataLoader
label_desc: Use image node_id 2 for calling the LinearModel obj's underlying member method code with example usage: obj._construct_model_params(in_features, out_features, norm_type, affine_norm, bias, weight_values, bias_value, classes) without return types