code: 
  
  
  '''simple docstring'''
  
  import unittest
  from timeit import timeit
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int    ,		_UpperCamelCase      :				int   )		->					int:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						first_num if first_num >= second_num else second_num
     UpperCamelCase__ 						=						max_num
     while (common_mult % first_num > 0) or (common_mult % second_num > 0):
        common_mult += max_num
     return common_mult
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int    ,		_UpperCamelCase      :				int   )		->					int:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     return b if a == 0 else greatest_common_divisor(b % a    ,		_UpperCamelCase   )
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int    ,		_UpperCamelCase      :				int   )		->					int:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     return first_num // greatest_common_divisor(_UpperCamelCase    ,		_UpperCamelCase   ) * second_num
  
  
  
  def        SCREAMING_SNAKE_CASE__(		)		->					str:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						(
         "from __main__ import least_common_multiple_slow, least_common_multiple_fast"
     )
     print(
         "least_common_multiple_slow():"    ,		timeit("least_common_multiple_slow(1000, 999)"    ,		setup=_UpperCamelCase   )    ,		)
     print(
         "least_common_multiple_fast():"    ,		timeit("least_common_multiple_fast(1000, 999)"    ,		setup=_UpperCamelCase   )    ,		)
  
  
  
  
  
  
  
  class  UpperCAmelCase (       unittest.TestCase):
   _lowerCamelCase :					str    					=					(
       (10, 20),
       (13, 15),
       (4, 31),
       (10, 42),
       (43, 34),
       (5, 12),
       (12, 25),
       (10, 25),
       (6, 9),
   )
   _lowerCamelCase :					int    					=					(20, 195, 124, 210, 1462, 60, 300, 50, 18)
  
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      for i, (first_num, second_num) in enumerate(self.test_inputs					):
         UpperCamelCase__ 						=						least_common_multiple_slow(a_,					a_					)
         UpperCamelCase__ 						=						least_common_multiple_fast(a_,					a_					)
         with self.subTest(i=a_					):
            self.assertEqual(a_,					self.expected_results[i]					)
            self.assertEqual(a_,					self.expected_results[i]					)
  
  
  if __name__ == "__main__":
         benchmark()
         unittest.main()
style_context: 
  
  
  '''simple docstring'''
  
  import os
  import sys
  from pathlib import Path
  
  import torch
  
  from transformers.testing_utils import TestCasePlus, execute_subprocess_async, require_torch_multi_gpu
  from utils import load_json
  
  
  __lowercase:		Union[str, Any]							=     torch.cuda.is_available()
  __lowercase:		str							=     [" Sam ate lunch today.", "Sams lunch ingredients."]
  __lowercase:		Optional[Any]							=     ["A very interesting story about what I ate for lunch.", "Avocado, celery, turkey, coffee"]
  __lowercase:		Optional[int]							=     {
      "max_tokens_per_batch": None,
      "supervise_forward": True,
      "normalize_hidden": True,
      "label_smoothing": 0.2,
      "eval_max_gen_length": None,
      "eval_beams": 1,
      "val_metric": "loss",
      "save_top_k": 1,
      "adafactor": True,
      "early_stopping_patience": 2,
      "logger_name": "default",
      "length_penalty": 0.5,
      "cache_dir": "",
      "task": "summarization",
      "num_workers": 2,
      "alpha_hid": 0,
      "freeze_embeds": True,
      "enc_only": False,
      "tgt_suffix": "",
      "resume_from_checkpoint": None,
      "sortish_sampler": True,
      "student_decoder_layers": 1,
      "val_check_interval": 1.0,
      "output_dir": "",
      "fp16": False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
      "no_teacher": False,
      "fp16_opt_level": "O1",
      "gpus": 1 if CUDA_AVAILABLE else 0,
      "n_tpu_cores": 0,
      "max_grad_norm": 1.0,
      "do_train": True,
      "do_predict": True,
      "accumulate_grad_batches": 1,
      "server_ip": "",
      "server_port": "",
      "seed": 42,
      "model_name_or_path": "sshleifer/bart-tiny-random",
      "config_name": "",
      "tokenizer_name": "facebook/bart-large",
      "do_lower_case": False,
      "learning_rate": 0.3,
      "lr_scheduler": "linear",
      "weight_decay": 0.0,
      "adam_epsilon": 1e-0_8,
      "warmup_steps": 0,
      "max_epochs": 1,
      "train_batch_size": 2,
      "eval_batch_size": 2,
      "max_source_length": 12,
      "max_target_length": 12,
      "val_max_target_length": 12,
      "test_max_target_length": 12,
      "fast_dev_run": False,
      "no_cache": False,
      "n_train": -1,
      "n_val": -1,
      "n_test": -1,
      "student_encoder_layers": 1,
      "freeze_encoder": False,
      "auto_scale_batch_size": False,
      "overwrite_output_dir": False,
      "student": None,
  }
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				Path    ,		_UpperCamelCase      :				list   )		->					Optional[Any]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						"\n".join(_UpperCamelCase   )
     Path(_UpperCamelCase   ).open("w"   ).writelines(_UpperCamelCase   )
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				Optional[Any]   )		->					List[str]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     for split in ["train", "val", "test"]:
        _dump_articles(os.path.join(_UpperCamelCase    ,		F'{split}.source'   )    ,		_UpperCamelCase   )
        _dump_articles(os.path.join(_UpperCamelCase    ,		F'{split}.target'   )    ,		_UpperCamelCase   )
     return tmp_dir
  
  
  
  
  
  
  
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__):
  
   @classmethod
   def 		lowercase_						( cls :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return cls
  
   @require_torch_multi_gpu
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						{
          "no_teacher": True,
          "freeze_encoder": True,
          "gpus": 2,
          "overwrite_output_dir": True,
          "sortish_sampler": True,
      }
      self._test_distiller_cli_fork(a_,					check_contents=a_					)
  
   def 		lowercase_						( self :	Tuple,					a_ :	Optional[Any],					a_ :	Optional[int]=True					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						{
          "label_smoothing": 0.0,
          "early_stopping_patience": -1,
          "train_batch_size": 1,
          "eval_batch_size": 2,
          "max_epochs": 2,
          "alpha_mlm": 0.2,
          "alpha_ce": 0.8,
          "do_predict": True,
          "model_name_or_path": "sshleifer/tinier_bart",
          "teacher": CHEAP_ARGS["model_name_or_path"],
          "val_check_interval": 0.5,
      }
      default_updates.update(a_					)
      UpperCamelCase__ 						=						CHEAP_ARGS.copy()
      UpperCamelCase__ 						=						make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()					)
      UpperCamelCase__ 						=						self.get_auto_remove_tmp_dir()
      args_d.update(data_dir=a_,					output_dir=a_,					**a_					)
  
      def convert(a_ :	str,					a_ :	Any					):
         if k in ["tgt_suffix", "server_ip", "server_port", "out", "n_tpu_cores"]:
            return ""
         if v is False or v is None:
            return ""
         if v is True:  # or len(str(v))==0:
            return f'--{k}'
         return f'--{k}={v}'
  
      UpperCamelCase__ 						=						[x for x in (convert(a_,					a_					) for k, v in args_d.items()) if len(a_					)]
      UpperCamelCase__ 						=						[sys.executable, f'{self.test_file_dir}/distillation.py'] + cli_args
      execute_subprocess_async(a_,					env=self.get_env()					)
  
      UpperCamelCase__ 						=						os.listdir(a_					)
      UpperCamelCase__ 						=						{os.path.basename(a_					) for p in contents}
      UpperCamelCase__ 						=						[p for p in contents if p.endswith("ckpt"					)]
      assert len(a_					) > 0
  
      self.assertIn("test_generations.txt",					a_					)
      self.assertIn("test_results.txt",					a_					)
  
      # get the following from the module, (we don't have access to `model` here)
      UpperCamelCase__ 						=						os.path.join(a_,					"metrics.json"					)
      UpperCamelCase__ 						=						"rouge2"
  
      UpperCamelCase__ 						=						load_json(a_					)
      # {'test': [{'test_avg_loss': 10.63731575012207, 'test_avg_rouge1': 0.0, 'test_avg_rouge2': 0.0, 'test_avg_rougeL': 0.0, 'test_avg_gen_time': 0.1822289228439331, 'test_avg_gen_len': 142.0, 'step_count': 1}]}
      print(a_					)
      UpperCamelCase__ 						=						metrics["val"][-1]
      self.assertGreaterEqual(last_step_stats["val_avg_gen_time"],					0.01					)
      self.assertIsInstance(last_step_stats[f'val_avg_{val_metric}'],					a_					)
      self.assertEqual(len(metrics["test"]					),					1					)
      UpperCamelCase__ 						=						int(args_d["max_epochs"] * (1 / args_d["val_check_interval"]) / 2 + 1					)
      self.assertEqual(len(metrics["val"]					),					a_					)