


from __future__ import annotations
def 							_UpperCAmelCase				(UpperCamelCase__     :  list[int]				,							UpperCamelCase__     :  int						):
       if len(UpperCamelCase__						) < k or k < 0:
              raise ValueError("Invalid Input"						)
       _A      :       int				    = sum(array[:k]						)
       for i in range(len(UpperCamelCase__						) - k						):
              _A      :       Optional[int]				    = current_sum - array[i] + array[i + k]
              _A      :       str				    = max(UpperCamelCase__				,							UpperCamelCase__						)
       return max_sum


if __name__ == "__main__":
    from doctest import testmod
    from random import randint

    testmod()
    lowerCAmelCase__      		= [randint(-10_00, 10_00) for i in range(1_00)]
    lowerCAmelCase__      		= randint(0, 1_10)
    print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")




import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_torch_available
from transformers.testing_utils import require_torch, torch_device


if is_torch_available():
    from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments







@require_torch
class      lowerCAmelCase__       (				unittest.TestCase):




     '''simple docstring'''


     def  _lowerCamelCase (						self ,						__lowerCamelCase)			->				Dict:
            for model_result in results.values():
                   for batch_size, sequence_length in zip(model_result["bs"] ,						model_result["ss"]):
                          _A      :       Optional[int]				    = model_result["result"][batch_size][sequence_length]
                          self.assertIsNotNone(__lowerCamelCase)


     def  _lowerCamelCase (						self)			->				int:
            _A      :       Optional[int]				    = "sshleifer/tiny-gpt2"
            _A      :       int				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       List[str]				    = PyTorchBenchmark(__lowerCamelCase)
            _A      :       Optional[Any]				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     def  _lowerCamelCase (						self)			->				Dict:
            _A      :       int				    = "sgugger/tiny-distilbert-classification"
            _A      :       str				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						only_pretrain_model=__lowerCamelCase ,						)
            _A      :       Dict				    = PyTorchBenchmark(__lowerCamelCase)
            _A      :       Union[str, Any]				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     def  _lowerCamelCase (						self)			->				Optional[Any]:
            _A      :       Tuple				    = "sshleifer/tiny-gpt2"
            _A      :       Optional[Any]				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						torchscript=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Union[str, Any]				    = PyTorchBenchmark(__lowerCamelCase)
            _A      :       List[str]				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     @unittest.skipIf(torch_device == "cpu" ,						"Cant do half precision")
     def  _lowerCamelCase (						self)			->				int:
            _A      :       Any				    = "sshleifer/tiny-gpt2"
            _A      :       Tuple				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						fpaa=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Any				    = PyTorchBenchmark(__lowerCamelCase)
            _A      :       Union[str, Any]				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     def  _lowerCamelCase (						self)			->				Any:
            _A      :       Union[str, Any]				    = "sshleifer/tiny-gpt2"
            _A      :       Any				    = AutoConfig.from_pretrained(__lowerCamelCase)
            # set architectures equal to `None`
            _A      :       Dict				    = None
            _A      :       Any				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Union[str, Any]				    = PyTorchBenchmark(__lowerCamelCase ,						configs=[config])
            _A      :       int				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     def  _lowerCamelCase (						self)			->				int:
            _A      :       List[Any]				    = "sshleifer/tiny-gpt2"
            _A      :       int				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Optional[Any]				    = PyTorchBenchmark(__lowerCamelCase)
            _A      :       int				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result)
            self.check_results_dict_not_empty(results.memory_train_result)


     @unittest.skipIf(torch_device == "cpu" ,						"Can't do half precision")
     def  _lowerCamelCase (						self)			->				Optional[Any]:
            _A      :       Any				    = "sshleifer/tiny-gpt2"
            _A      :       Tuple				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						fpaa=__lowerCamelCase ,						multi_process=__lowerCamelCase ,						)
            _A      :       List[Any]				    = PyTorchBenchmark(__lowerCamelCase)
            _A      :       Tuple				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result)
            self.check_results_dict_not_empty(results.memory_train_result)


     def  _lowerCamelCase (						self)			->				str:
            _A      :       List[str]				    = "sshleifer/tiny-gpt2"
            _A      :       Union[str, Any]				    = AutoConfig.from_pretrained(__lowerCamelCase)
            _A      :       Any				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Optional[Any]				    = PyTorchBenchmark(__lowerCamelCase ,						configs=[config])
            _A      :       Tuple				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     def  _lowerCamelCase (						self)			->				int:
            _A      :       Tuple				    = "sshleifer/tinier_bart"
            _A      :       Optional[Any]				    = AutoConfig.from_pretrained(__lowerCamelCase)
            _A      :       Optional[int]				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Dict				    = PyTorchBenchmark(__lowerCamelCase ,						configs=[config])
            _A      :       Optional[int]				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result)
            self.check_results_dict_not_empty(results.memory_inference_result)


     def  _lowerCamelCase (						self)			->				str:
            _A      :       List[Any]				    = "sshleifer/tiny-gpt2"
            _A      :       Optional[Any]				    = AutoConfig.from_pretrained(__lowerCamelCase)
            _A      :       Optional[Any]				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       List[str]				    = PyTorchBenchmark(__lowerCamelCase ,						configs=[config])
            _A      :       Dict				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result)
            self.check_results_dict_not_empty(results.memory_train_result)


     def  _lowerCamelCase (						self)			->				int:
            _A      :       int				    = "sshleifer/tinier_bart"
            _A      :       str				    = AutoConfig.from_pretrained(__lowerCamelCase)
            _A      :       Tuple				    = PyTorchBenchmarkArguments(
                models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						multi_process=__lowerCamelCase ,						)
            _A      :       Tuple				    = PyTorchBenchmark(__lowerCamelCase ,						configs=[config])
            _A      :       Union[str, Any]				    = benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result)
            self.check_results_dict_not_empty(results.memory_train_result)


     def  _lowerCamelCase (						self)			->				Dict:
            _A      :       List[str]				    = "sshleifer/tiny-gpt2"
            with tempfile.TemporaryDirectory() as tmp_dir:
                   _A      :       Optional[Any]				    = PyTorchBenchmarkArguments(
                       models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						save_to_csv=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						inference_time_csv_file=os.path.join(__lowerCamelCase ,						"inf_time.csv") ,						train_memory_csv_file=os.path.join(__lowerCamelCase ,						"train_mem.csv") ,						inference_memory_csv_file=os.path.join(__lowerCamelCase ,						"inf_mem.csv") ,						train_time_csv_file=os.path.join(__lowerCamelCase ,						"train_time.csv") ,						env_info_csv_file=os.path.join(__lowerCamelCase ,						"env.csv") ,						multi_process=__lowerCamelCase ,						)
                   _A      :       Tuple				    = PyTorchBenchmark(__lowerCamelCase)
                   benchmark.run()
                   self.assertTrue(Path(os.path.join(__lowerCamelCase ,						"inf_time.csv")).exists())
                   self.assertTrue(Path(os.path.join(__lowerCamelCase ,						"train_time.csv")).exists())
                   self.assertTrue(Path(os.path.join(__lowerCamelCase ,						"inf_mem.csv")).exists())
                   self.assertTrue(Path(os.path.join(__lowerCamelCase ,						"train_mem.csv")).exists())
                   self.assertTrue(Path(os.path.join(__lowerCamelCase ,						"env.csv")).exists())


     def  _lowerCamelCase (						self)			->				int:
            _A      :       Dict				    = "sshleifer/tiny-gpt2"

            def _check_summary_is_not_empty(__lowerCamelCase):
                   self.assertTrue(hasattr(__lowerCamelCase ,						"sequential"))
                   self.assertTrue(hasattr(__lowerCamelCase ,						"cumulative"))
                   self.assertTrue(hasattr(__lowerCamelCase ,						"current"))
                   self.assertTrue(hasattr(__lowerCamelCase ,						"total"))

            with tempfile.TemporaryDirectory() as tmp_dir:
                   _A      :       Union[str, Any]				    = PyTorchBenchmarkArguments(
                       models=[MODEL_ID] ,						training=__lowerCamelCase ,						inference=__lowerCamelCase ,						sequence_lengths=[8] ,						batch_sizes=[1] ,						log_filename=os.path.join(__lowerCamelCase ,						"log.txt") ,						log_print=__lowerCamelCase ,						trace_memory_line_by_line=__lowerCamelCase ,						multi_process=__lowerCamelCase ,						)
                   _A      :       Optional[int]				    = PyTorchBenchmark(__lowerCamelCase)
                   _A      :       Dict				    = benchmark.run()
                   _check_summary_is_not_empty(result.inference_summary)
                   _check_summary_is_not_empty(result.train_summary)
                   self.assertTrue(Path(os.path.join(__lowerCamelCase ,						"log.txt")).exists())
