          self._name = model_name
          self._iterations = 0
          self._mixed_precision_layers: List[str] = []
          self._rebuild_model = False
          self._sessions: Dict[int, dict] = {}
          self._lowest_avg_loss: Dict[str, float] = {}
          self._config: Dict[str, "ConfigValueType"] = {}
          self._load(config_changeable_items)
          self._session_id = self._new_session_id()
          self._create_new_session(no_logs, config_changeable_items)
          logger.debug("Initialized %s:", self.__class__.__name__)
  
 
</s> remove         self._mixed_precision_layers: List[str] = []
 </s> add         self._mixed_precision_layers: T.List[str] = [] </s> remove         self._display = dict(min=show_min, mean=show_mean, max=show_max)
 </s> add         self._display = {"min": show_min, "mean": show_mean, "max": show_max} </s> remove         self._queues: Dict[Literal["load", "save"], "EventQueue"] = {}
        self._threads: Dict[Literal["load", "save"], MultiThread] = {}
 </s> add         self._queues: T.Dict[Literal["load", "save"], EventQueue] = {}
        self._threads: T.Dict[Literal["load", "save"], MultiThread] = {} </s> remove         self.images: Dict[Literal["a", "b"], List[np.ndarray]] = {}
 </s> add         self.images: T.Dict[Literal["a", "b"], T.List[np.ndarray]] = {} </s> remove         self._inputs: List[keras.layers.Layer] = []
        self._names: List[str] = []
        self._funcs: Dict[str, Callable] = {}

        logcosh = losses.LogCosh() if get_backend() == "amd" else k_losses.logcosh
        self._loss_dict = dict(ffl=LossClass(function=losses.FocalFrequencyLoss),
                               flip=LossClass(function=losses.LDRFLIPLoss,
                                              kwargs=dict(color_order=color_order)),
                               gmsd=LossClass(function=losses.GMSDLoss),
                               l_inf_norm=LossClass(function=losses.LInfNorm),
                               laploss=LossClass(function=losses.LaplacianPyramidLoss),
                               logcosh=LossClass(function=logcosh,
                                                 init=False),
                               lpips_alex=LossClass(function=losses.LPIPSLoss,
                                                    kwargs=dict(trunk_network="alex")),
                               lpips_squeeze=LossClass(function=losses.LPIPSLoss,
                                                       kwargs=dict(trunk_network="squeeze")),
                               lpips_vgg16=LossClass(function=losses.LPIPSLoss,
                                                     kwargs=dict(trunk_network="vgg16")),
                               ms_ssim=LossClass(function=losses.MSSIMLoss),
                               mae=LossClass(function=k_losses.mean_absolute_error,
                                             init=False),
                               mse=LossClass(function=k_losses.mean_squared_error,
                                             init=False),
                               pixel_gradient_diff=LossClass(function=losses.GradientLoss),
                               ssim=LossClass(function=losses.DSSIMObjective),
                               smooth_loss=LossClass(function=losses.GeneralizedLoss))
 </s> add         self._inputs: T.List[tf.keras.layers.Layer] = []
        self._names: T.List[str] = []
        self._funcs: T.Dict[str, T.Callable] = {}

        self._loss_dict = {"ffl": LossClass(function=losses.FocalFrequencyLoss),
                           "flip": LossClass(function=losses.LDRFLIPLoss,
                                             kwargs={"color_order": color_order}),
                           "gmsd": LossClass(function=losses.GMSDLoss),
                           "l_inf_norm": LossClass(function=losses.LInfNorm),
                           "laploss": LossClass(function=losses.LaplacianPyramidLoss),
                           "logcosh": LossClass(function=k_losses.logcosh, init=False),
                           "lpips_alex": LossClass(function=losses.LPIPSLoss,
                                                   kwargs={"trunk_network": "alex"}),
                           "lpips_squeeze": LossClass(function=losses.LPIPSLoss,
                                                      kwargs={"trunk_network": "squeeze"}),
                           "lpips_vgg16": LossClass(function=losses.LPIPSLoss,
                                                    kwargs={"trunk_network": "vgg16"}),
                           "ms_ssim": LossClass(function=losses.MSSIMLoss),
                           "mae": LossClass(function=k_losses.mean_absolute_error, init=False),
                           "mse": LossClass(function=k_losses.mean_squared_error, init=False),
                           "pixel_gradient_diff": LossClass(function=losses.GradientLoss),
                           "ssim": LossClass(function=losses.DSSIMObjective),
                           "smooth_loss": LossClass(function=losses.GeneralizedLoss)}
        self._sessions: T.Dict[int, dict] = {}
        self._lowest_avg_loss: T.Dict[str, float] = {}
        self._config: T.Dict[str, ConfigValueType] = {}
          self._name = model_name
          self._iterations = 0
          self._mixed_precision_layers: List[str] = []
          self._rebuild_model = False
        self._sessions: T.Dict[int, dict] = {}
        self._lowest_avg_loss: T.Dict[str, float] = {}
        self._config: T.Dict[str, ConfigValueType] = {}
        self._sessions: T.Dict[int, dict] = {}
        self._lowest_avg_loss: T.Dict[str, float] = {}
        self._config: T.Dict[str, ConfigValueType] = {}
        self._sessions: T.Dict[int, dict] = {}
        self._lowest_avg_loss: T.Dict[str, float] = {}
        self._config: T.Dict[str, ConfigValueType] = {}
          self._load(config_changeable_items)
          self._session_id = self._new_session_id()
          self._create_new_session(no_logs, config_changeable_items)
          logger.debug("Initialized %s:", self.__class__.__name__)
  
keep keep keep keep replace replace replace keep keep keep keep keep
 Remove plaidML support (#1325)

* Remove PlaidML reference from readme files

* Remove AMD option from installers

* remove amd requirements and update setup.py

* remove plaidml test from CI workflow

* gpustats: remove plaidml backend

* plaid removals:
  - faceswap.py - python version check
  - setup.cfg - plaidml typing ignore
  - lib.keras_utils - All plaid code
  - lib.launcher.py - All plaidml checks and configuration

* remove tf2.2 specific code from GUI event reader

* lib.model - remove all plaidml implementations

* plugins.extract - remove plaidml code

* plugins.train remove plaidml code

* lib.convert - remove plaidml code

* tools.model: remove plaidml code

* Remove plaidML tests from unit tests

* remove plaidml_utils and docsting cleanups

* Remove plaidML refs from configs

* fix keras imports 
plugins/train/model/_base/model.py