class_docstr: EfficientAd model.
  
  Args:
      teacher_out_channels (int): number of convolution output channels of the pre-trained teacher model
      pretrained_models_dir (str): path to the pretrained model weights
      input_size (tuple): size of input images
      model_size (str): size of student and teacher model
      padding (bool): use padding in convoluional layers
      pad_maps (bool): relevant if padding is set to False. In this case, pad_maps = True pads the
          output anomaly maps so that their size matches the size in the padding = True case.
      device (str): which device the model should be loaded on
code: def __init__(
      self,
      teacher_out_channels: int,
      input_size: tuple[int, int],
      model_size: EfficientAdModelSize = EfficientAdModelSize.S,
      padding=False,
      pad_maps=True,
  ) -> None:
      super().__init__()
  
      self.pad_maps = pad_maps
      self.teacher: PDN_M | PDN_S
      self.student: PDN_M | PDN_S
  
      if model_size == EfficientAdModelSize.M:
          self.teacher = PDN_M(
              out_channels=teacher_out_channels, padding=padding
          ).eval()
          self.student = PDN_M(
              out_channels=teacher_out_channels * 2, padding=padding
          )
  
      elif model_size == EfficientAdModelSize.S:
          self.teacher = PDN_S(
              out_channels=teacher_out_channels, padding=padding
          ).eval()
          self.student = PDN_S(
              out_channels=teacher_out_channels * 2, padding=padding
          )
  
      else:
          raise ValueError(f"Unknown model size {model_size}")
  
      self.ae: AutoEncoder = AutoEncoder(
          out_channels=teacher_out_channels,
          padding=padding,
          img_size=input_size,
      )
      self.teacher_out_channels: int = teacher_out_channels
      self.input_size: tuple[int, int] = input_size
  
      self.mean_std: nn.ParameterDict = nn.ParameterDict(
          {
              "mean": torch.zeros((1, self.teacher_out_channels, 1, 1)),
              "std": torch.zeros((1, self.teacher_out_channels, 1, 1)),
          }
      )
  
      self.quantiles: nn.ParameterDict = nn.ParameterDict(
          {
              "qa_st": torch.tensor(0.0),
              "qb_st": torch.tensor(0.0),
              "qa_ae": torch.tensor(0.0),
              "qb_ae": torch.tensor(0.0),
          }
      )
  
imports: from __future__ import annotations
  import logging
  import random
  from enum import Enum
  import torch
  import torch.nn.functional
  from torch import Tensor, nn
  from torchvision import transforms
label_desc: Use image node_id 1 to create a new EfficientAdModel object from inherited base classes: nn with example: obj = EfficientAdModel(teacher_out_channels, input_size, model_size, padding, pad_maps)