


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  snake_case_     (unittest.TestCase   ):
					def 				lowerCamelCase__(   self     :Any    ,__snake_case     :List[str]   )      ->					Union[str, Any]:
												for model_result in results.values():
																			for batch_size, sequence_length in zip(model_result['bs']    ,model_result['ss']   ):
																										a__    =  model_result['''result'''][batch_size][sequence_length]
																										self.assertIsNotNone(_UpperCAmelCase   )
					def 				lowerCamelCase__(   self     :str   )      ->					List[str]:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase   )
												a__    =  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   )      ->					List[Any]:
												a__    =  '''sgugger/tiny-distilbert-classification'''
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,only_pretrain_model=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase   )
												a__    =  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   )      ->					str:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,torchscript=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase   )
												a__    =  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     :Optional[Any]   )      ->					Optional[int]:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,fpaa=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase   )
												a__    =  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     :List[str]   )      ->					Optional[Any]:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  AutoConfig.from_pretrained(_UpperCAmelCase   )
												# set architectures equal to `None`
												a__    =  None
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase    ,configs=[config]   )
												a__    =  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   )      ->					str:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase   )
												a__    =  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     :Dict   )      ->					Any:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,fpaa=_UpperCAmelCase    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase   )
												a__    =  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     :Union[str, Any]   )      ->					Optional[Any]:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  AutoConfig.from_pretrained(_UpperCAmelCase   )
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase    ,configs=[config]   )
												a__    =  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     :Tuple   )      ->					Union[str, Any]:
												a__    =  '''sshleifer/tinier_bart'''
												a__    =  AutoConfig.from_pretrained(_UpperCAmelCase   )
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase    ,configs=[config]   )
												a__    =  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   )      ->					Any:
												a__    =  '''sshleifer/tiny-gpt2'''
												a__    =  AutoConfig.from_pretrained(_UpperCAmelCase   )
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase    ,configs=[config]   )
												a__    =  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     :Tuple   )      ->					Tuple:
												a__    =  '''sshleifer/tinier_bart'''
												a__    =  AutoConfig.from_pretrained(_UpperCAmelCase   )
												a__    =  PyTorchBenchmarkArguments(
												    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,multi_process=_UpperCAmelCase    ,)
												a__    =  PyTorchBenchmark(_UpperCAmelCase    ,configs=[config]   )
												a__    =  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     :Optional[int]   )      ->					Dict:
												a__    =  '''sshleifer/tiny-gpt2'''
												with tempfile.TemporaryDirectory() as tmp_dir:
																			a__    =  PyTorchBenchmarkArguments(
																			    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,save_to_csv=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,inference_time_csv_file=os.path.join(_UpperCAmelCase    ,'inf_time.csv'   )    ,train_memory_csv_file=os.path.join(_UpperCAmelCase    ,'train_mem.csv'   )    ,inference_memory_csv_file=os.path.join(_UpperCAmelCase    ,'inf_mem.csv'   )    ,train_time_csv_file=os.path.join(_UpperCAmelCase    ,'train_time.csv'   )    ,env_info_csv_file=os.path.join(_UpperCAmelCase    ,'env.csv'   )    ,multi_process=_UpperCAmelCase    ,)
																			a__    =  PyTorchBenchmark(_UpperCAmelCase   )
																			benchmark.run()
																			self.assertTrue(Path(os.path.join(_UpperCAmelCase    ,'inf_time.csv'   )   ).exists()   )
																			self.assertTrue(Path(os.path.join(_UpperCAmelCase    ,'train_time.csv'   )   ).exists()   )
																			self.assertTrue(Path(os.path.join(_UpperCAmelCase    ,'inf_mem.csv'   )   ).exists()   )
																			self.assertTrue(Path(os.path.join(_UpperCAmelCase    ,'train_mem.csv'   )   ).exists()   )
																			self.assertTrue(Path(os.path.join(_UpperCAmelCase    ,'env.csv'   )   ).exists()   )



					def 				lowerCamelCase__(   self     :List[str]   )      ->					Any:
												a__    =  '''sshleifer/tiny-gpt2'''

												def _check_summary_is_not_empty(__snake_case     :Union[str, Any]   ):
																			self.assertTrue(hasattr(_UpperCAmelCase    ,'sequential'   )   )
																			self.assertTrue(hasattr(_UpperCAmelCase    ,'cumulative'   )   )
																			self.assertTrue(hasattr(_UpperCAmelCase    ,'current'   )   )
																			self.assertTrue(hasattr(_UpperCAmelCase    ,'total'   )   )

												with tempfile.TemporaryDirectory() as tmp_dir:
																			a__    =  PyTorchBenchmarkArguments(
																			    models=[MODEL_ID]    ,training=_UpperCAmelCase    ,inference=_UpperCAmelCase    ,sequence_lengths=[8]    ,batch_sizes=[1]    ,log_filename=os.path.join(_UpperCAmelCase    ,'log.txt'   )    ,log_print=_UpperCAmelCase    ,trace_memory_line_by_line=_UpperCAmelCase    ,multi_process=_UpperCAmelCase    ,)
																			a__    =  PyTorchBenchmark(_UpperCAmelCase   )
																			a__    =  benchmark.run()
																			_check_summary_is_not_empty(result.inference_summary   )
																			_check_summary_is_not_empty(result.train_summary   )
																			self.assertTrue(Path(os.path.join(_UpperCAmelCase    ,'log.txt'   )   ).exists()   )








from manim import *







class  snake_case_     (lowerCamelCase_   ):
					def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					Optional[int]:
												a__    =  Rectangle(height=0.5    ,width=0.5   )
												a__    =  Rectangle(height=0.46    ,width=0.46   ).set_stroke(width=0   )

												a__    =  Rectangle(height=0.25    ,width=0.25   )

												a__    =  [mem.copy() for i in range(6   )]
												a__    =  [mem.copy() for i in range(6   )]
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  VGroup(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  Text('CPU'    ,font_size=24   )
												a__    =  Group(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0.5    ,aligned_edge=__snake_case   )
												cpu.move_to([-2.5, -0.5, 0]   )
												self.add(__snake_case   )

												a__    =  [mem.copy() for i in range(4   )]
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  Text('GPU'    ,font_size=24   )
												a__    =  Group(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0.5    ,aligned_edge=__snake_case   )
												gpu.move_to([-1, -1, 0]   )
												self.add(__snake_case   )

												a__    =  [mem.copy() for i in range(6   )]
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )

												a__    =  Text('Model'    ,font_size=24   )
												a__    =  Group(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0.5    ,aligned_edge=__snake_case   )
												model.move_to([3, -1.0, 0]   )
												self.add(__snake_case   )

												a__    =  []
												a__    =  []

												for i, rect in enumerate(__snake_case   ):
																			a__    =  fill.copy().set_fill(__snake_case    ,opacity=0.8   )
																			target.move_to(__snake_case   )
																			model_arr.append(__snake_case   )

																			a__    =  Rectangle(height=0.46    ,width=0.46   ).set_stroke(width=0.0   ).set_fill(__snake_case    ,opacity=0.8   )
																			cpu_target.move_to(cpu_left_col_base[i]   )
																			model_cpu_arr.append(__snake_case   )

												self.add(*__snake_case    ,*__snake_case   )

												a__    =  [meta_mem.copy() for i in range(6   )]
												a__    =  [meta_mem.copy() for i in range(6   )]
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  VGroup(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  Text('Disk'    ,font_size=24   )
												a__    =  Group(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0.5    ,aligned_edge=__snake_case   )
												disk.move_to([-4, -1.25, 0]   )
												self.add(__snake_case    ,__snake_case   )

												a__    =  Square(side_length=2.2   )
												key.move_to([-5, 2, 0]   )

												a__    =  MarkupText(
												    F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'    ,font_size=18    ,)

												key_text.move_to([-5, 2.4, 0]   )

												self.add(__snake_case    ,__snake_case   )

												a__    =  MarkupText(
												    F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'    ,font_size=18    ,)

												blue_text.next_to(__snake_case    ,DOWN * 2.4    ,aligned_edge=key_text.get_left()   )
												self.add(__snake_case   )

												a__    =  MarkupText(
												    F'Now watch as an input is passed through the model\nand how the memory is utilized and handled.'    ,font_size=24    ,)
												step_a.move_to([2, 2, 0]   )

												self.play(Write(__snake_case   )   )

												a__    =  Square(0.3   )
												input.set_fill(__snake_case    ,opacity=1.0   )
												input.set_stroke(width=0.0   )
												input.next_to(model_base[0]    ,__snake_case    ,buff=0.5   )

												self.play(Write(__snake_case   )   )

												input.generate_target()
												input.target.next_to(model_arr[0]    ,direction=__snake_case    ,buff=0.02   )
												self.play(MoveToTarget(__snake_case   )   )

												self.play(FadeOut(__snake_case   )   )

												a__    =  Arrow(start=__snake_case    ,end=__snake_case    ,color=__snake_case    ,buff=0.5   )
												a.next_to(model_arr[0].get_left()    ,__snake_case    ,buff=0.2   )

												model_cpu_arr[0].generate_target()
												model_cpu_arr[0].target.move_to(gpu_rect[0]   )

												a__    =  MarkupText(
												    F'As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.'    ,font_size=24    ,)
												step_a.move_to([2, 2, 0]   )

												self.play(Write(__snake_case    ,run_time=3   )   )

												a__    =  {'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

												self.play(
												    Write(__snake_case   )    ,Circumscribe(model_arr[0]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(model_cpu_arr[0]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(gpu_rect[0]    ,color=__snake_case    ,**__snake_case   )    ,)
												self.play(MoveToTarget(model_cpu_arr[0]   )   )

												a__    =  a.copy()
												for i in range(6   ):
																			a_c.next_to(model_arr[i].get_right() + 0.02    ,__snake_case    ,buff=0.2   )

																			input.generate_target()
																			input.target.move_to(model_arr[i].get_right() + 0.02   )

																			a__    =  AnimationGroup(
																			    FadeOut(__snake_case    ,run_time=0.5   )    ,MoveToTarget(__snake_case    ,run_time=0.5   )    ,FadeIn(__snake_case    ,run_time=0.5   )    ,lag_ratio=0.2   )

																			self.play(__snake_case   )

																			model_cpu_arr[i].generate_target()
																			model_cpu_arr[i].target.move_to(cpu_left_col_base[i]   )

																			if i < 5:
																										model_cpu_arr[i + 1].generate_target()
																										model_cpu_arr[i + 1].target.move_to(gpu_rect[0]   )
																										if i >= 1:
																																	a__    =  0.7

																										self.play(
																										    Circumscribe(model_arr[i]    ,**__snake_case   )    ,Circumscribe(cpu_left_col_base[i]    ,**__snake_case   )    ,Circumscribe(cpu_left_col_base[i + 1]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(gpu_rect[0]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(model_arr[i + 1]    ,color=__snake_case    ,**__snake_case   )    ,)
																										if i < 1:
																																	self.play(
																																	    MoveToTarget(model_cpu_arr[i]   )    ,MoveToTarget(model_cpu_arr[i + 1]   )    ,)
																										else:
																																	self.play(
																																	    MoveToTarget(model_cpu_arr[i]    ,run_time=0.7   )    ,MoveToTarget(model_cpu_arr[i + 1]    ,run_time=0.7   )    ,)
																			else:
																										model_cpu_arr[i].generate_target()
																										model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]   )
																										input.generate_target()
																										input.target.next_to(model_arr[-1].get_right()    ,RIGHT + 0.02    ,buff=0.2   )

																										self.play(
																										    Circumscribe(model_arr[-1]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(cpu_left_col_base[-1]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(gpu_rect[0]    ,color=__snake_case    ,**__snake_case   )    ,)

																										self.play(MoveToTarget(model_cpu_arr[i]   )   )

																			a__    =  a_c
																			a__    =  a_c.copy()

												input.generate_target()
												input.target.next_to(model_base[-1]    ,RIGHT + 0.02    ,buff=0.5   )
												self.play(
												    FadeOut(__snake_case   )    ,FadeOut(__snake_case    ,run_time=0.5   )    ,)

												a__    =  MarkupText(F'Inference on a model too large for GPU memory\nis successfully completed.'    ,font_size=24   )
												step_a.move_to([2, 2, 0]   )

												self.play(Write(__snake_case    ,run_time=3   )    ,MoveToTarget(__snake_case   )   )

												self.wait()




