text: """
  A federated learning server for MistNet.
  Reference:
  P. Wang, et al. "MistNet: Towards Private Neural Network Training with Local
  Differential Privacy," found in docs/papers.
  """
  
  import logging
  import os
  from itertools import chain
  
  from plato.config import Config
  from plato.samplers import all_inclusive
  
  from plato.servers import fedavg
  
  os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
  os.environ["MKL_THREADING_LAYER"] = "GNU"
  
  import torch.multiprocessing
  
  torch.multiprocessing.set_sharing_strategy('file_system')
  
  
  class Server(fedavg.Server):
      """The MistNet server for federated learning."""
      def __init__(self, model=None, algorithm=None, trainer=None):
          super().__init__(model=model, algorithm=algorithm, trainer=trainer)
  
          # MistNet requires one round of client-server communication
          assert Config().trainer.rounds == 1
  
      def load_trainer(self):
          """Setting up a pre-trained model to be loaded on the server."""
          super().load_trainer()
  
          logging.info("[Server #%d] Loading a pre-trained model.", os.getpid())
          self.trainer.load_model()
  
      async def process_reports(self):
          """Process the features extracted by the client and perform server-side training."""
          features = [features for (__, features) in self.updates]
  
          # Faster way to deep flatten a list of lists compared to list comprehension
          feature_dataset = list(chain.from_iterable(features))
  
          # Training the model using all the features received from the client
          sampler = all_inclusive.Sampler(feature_dataset)
          self.algorithm.train(feature_dataset, sampler,
                               Config().algorithm.cut_layer)
  
          # Test the updated model
          self.accuracy = self.trainer.test(self.testset)
          logging.info('[Server #{:d}] Global model accuracy: {:.2f}%\n'.format(
              os.getpid(), 100 * self.accuracy))
  
          await self.wrap_up_processing_reports()
  