code: 
  
  
  
  
  
  import torch
  
  from accelerate import Accelerator, DistributedType
  
  
  class       a_  :
  
      '''simple docstring'''
  
  
      def __enter__(	self )	->     Union[str, Any]:
          if self.enabled:
              _SCREAMING_SNAKE_CASE             =    self.model.no_sync()
              self.model_sync_obj.__enter__()
  
          return self
  
  
      def __exit__(	self				,	A				,	A				,	A )	->     Optional[Any]:
          if self.enabled:
              # Average all models on exit
              self._sync_and_avg_model_params()
              self.model_sync_obj.__exit__(A				,	A				,	A )
  
  
      def __init__(	self				,	A				,	A				,	A				,	A = True )	->     List[Any]:
          if accelerator.distributed_type not in [
              DistributedType.NO,
              DistributedType.MULTI_CPU,
              DistributedType.MULTI_GPU,
          ]:
              raise NotImplementedError("""LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)""" )
          _SCREAMING_SNAKE_CASE             =    enabled and accelerator.distributed_type != DistributedType.NO
          _SCREAMING_SNAKE_CASE             =    0
          if self.enabled:
              _SCREAMING_SNAKE_CASE             =    accelerator
              _SCREAMING_SNAKE_CASE             =    model
              _SCREAMING_SNAKE_CASE             =    local_sgd_steps
  
  
      def     snake_case_(	self )	->     int:
          self.num_steps += 1
          if not self.enabled:
              return
  
          if self.num_steps % self.local_sgd_steps == 0:
              self._sync_and_avg_model_params()
  
  
  
  
  
      def     snake_case_(	self )	->     List[Any]:
          self.accelerator.wait_for_everyone()
          with self.accelerator.autocast():
              for param in self.model.parameters():
                  _SCREAMING_SNAKE_CASE             =    self.accelerator.reduce(param.data				,	reduction="""mean""" )
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import json
  import os
  import tempfile
  import unittest
  
  from transformers.modelcard import ModelCard
  
  
  class       a_  (       unittest.TestCase ):
  
      '''simple docstring'''
  
  
      def     snake_case_(	self )	->     int:
          _SCREAMING_SNAKE_CASE             =    {
              """model_details""": {
                  """Organization""": """testing""",
                  """Model date""": """today""",
                  """Model version""": """v2.1, Developed by Test Corp in 2019.""",
                  """Architecture""": """Convolutional Neural Network.""",
              },
              """metrics""": """BLEU and ROUGE-1""",
              """evaluation_data""": {
                  """Datasets""": {"""BLEU""": """My-great-dataset-v1""", """ROUGE-1""": """My-short-dataset-v2.1"""},
                  """Preprocessing""": """See details on https://arxiv.org/pdf/1810.03993.pdf""",
              },
              """training_data""": {
                  """Dataset""": """English Wikipedia dump dated 2018-12-01""",
                  """Preprocessing""": (
                      """Using SentencePiece vocabulary of size 52k tokens. See details on"""
                      """ https://arxiv.org/pdf/1810.03993.pdf"""
                  ),
              },
              """quantitative_analyses""": {"""BLEU""": 55.1, """ROUGE-1""": 76},
          }
  
  
      def     snake_case_(	self )	->     Tuple:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
          self.assertTrue(hasattr(A				,	"""model_details""" ) )
          self.assertTrue(hasattr(A				,	"""intended_use""" ) )
          self.assertTrue(hasattr(A				,	"""factors""" ) )
          self.assertTrue(hasattr(A				,	"""metrics""" ) )
          self.assertTrue(hasattr(A				,	"""evaluation_data""" ) )
          self.assertTrue(hasattr(A				,	"""training_data""" ) )
          self.assertTrue(hasattr(A				,	"""quantitative_analyses""" ) )
          self.assertTrue(hasattr(A				,	"""ethical_considerations""" ) )
          self.assertTrue(hasattr(A				,	"""caveats_and_recommendations""" ) )
  
  
      def     snake_case_(	self )	->     List[str]:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
          _SCREAMING_SNAKE_CASE             =    json.loads(modelcard.to_json_string() )
          for key, value in self.inputs_dict.items():
              self.assertEqual(obj[key]				,	A )
  
  
      def     snake_case_(	self )	->     Any:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
  
          with tempfile.TemporaryDirectory() as tmpdirname:
              _SCREAMING_SNAKE_CASE             =    os.path.join(A				,	"""modelcard.json""" )
              model_card_first.to_json_file(A )
              _SCREAMING_SNAKE_CASE             =    ModelCard.from_json_file(A )
  
          self.assertEqual(model_card_second.to_dict()				,	model_card_first.to_dict() )
  
  
  
  
  
      def     snake_case_(	self )	->     List[Any]:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
  
          with tempfile.TemporaryDirectory() as tmpdirname:
              model_card_first.save_pretrained(A )
              _SCREAMING_SNAKE_CASE             =    ModelCard.from_pretrained(A )
  
          self.assertEqual(model_card_second.to_dict()				,	model_card_first.to_dict() )
  
  
  
  